mdw@git.distorted.org.uk Git - mLib-python/blob - mapping.pyx

   1 ### -*-pyrex-*-
   2 ###
   3 ### Common mapping stuff
   4 ###
   5 ### (c) 2005 Straylight/Edgeware
   6 ###
   7
   8 ###----- Licensing notice ---------------------------------------------------
   9 ###
  10 ### This file is part of the Python interface to mLib.
  11 ###
  12 ### mLib/Python is free software; you can redistribute it and/or modify
  13 ### it under the terms of the GNU General Public License as published by
  14 ### the Free Software Foundation; either version 2 of the License, or
  15 ### (at your option) any later version.
  16 ###
  17 ### mLib/Python is distributed in the hope that it will be useful,
  18 ### but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ### GNU General Public License for more details.
  21 ###
  22 ### You should have received a copy of the GNU General Public License
  23 ### along with mLib/Python; if not, write to the Free Software Foundation,
  24 ### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25
  26 cdef class _MapIterator:
  27   cdef void *_next(me):
  28     return NULL
  29
  30 cdef class _Mapping:
  31
  32   ## Subclasses must implement these.
  33   cdef int _init(me) except -1:
  34     raise TypeError('abstract class')
  35   cdef void *_find(me, object key, unsigned *f) except NULL:
  36     raise SystemError('unimplemented _find')
  37   cdef object _key(me, void *e):
  38     return None
  39   cdef object _value(me, void *e):
  40     return None
  41   cdef void _setval(me, void *e, object val):
  42     pass
  43   cdef void _del(me, void *e):
  44     pass
  45   cdef _MapIterator _iter(me):
  46     raise SystemError('unimplemented _iter')
  47
  48   ## Initialization.
  49   def __init__(me, stuff = None, **kw):
  50     me._init()
  51     me.update(stuff, **kw)
  52
  53   ## Bulk update.
  54   def update(me, stuff = None, **kw):
  55     """D.update([MAP], **KW): insert mappings from MAP and KW"""
  56     cdef unsigned f
  57     if stuff is None:
  58       pass
  59     elif hasattr(stuff, 'itemiter'):
  60       for k, v in stuff.itemiter:
  61         me._setval(me._find(k, &f), v)
  62     elif hasattr(stuff, 'keys'):
  63       for k in stuff.keys():
  64         me._setval(me._find( k, &f), stuff[k])
  65     else:
  66       for k, v in stuff:
  67         me._setval(me._find(k, &f), v)
  68     for k, v in kw.iteritems():
  69       me._setval(me._find(k, &f), v)
  70     return me
  71
  72   ## Item access.
  73   def __getitem__(me, key):
  74     cdef void *e = me._find(key, NULL)
  75     return me._value(e)
  76   def __setitem__(me, key, value):
  77     cdef unsigned f
  78     me._setval(me._find(key, &f), value)
  79   def __delitem__(me, key):
  80     cdef unsigned f
  81     cdef void *e = me._find(key, &f)
  82     if not e:
  83       raise KeyError(key)
  84     me._del(e)
  85   def get(me, key, default = None):
  86     """D.get(KEY, [default = None]) -> VALUE: value at KEY, or DEFAULT"""
  87     cdef void *e = me._find(key, NULL)
  88     if not e:
  89       return default
  90     return me._value(e)
  91   def setdefault(me, key, default = None):
  92     """
  93     D.setdefault(KEY, [default = None]) -> VALUE:
  94       return value at key, or store DEFAULT at key and return that"""
  95     cdef unsigned f
  96     cdef void *e = me._find(key, &f)
  97     if f:
  98       return me._value(e)
  99     else:
 100       me._setval(e, default)
 101       return default
 102   def pop(me, key, default = None):
 103     """
 104     D.pop(KEY, [default = None]) -> VALUE:
 105       return value at key or DEFAULT, and remove KEY"""
 106     cdef void *e = me._find(key, NULL)
 107     if not e:
 108       return default
 109     rc = me._value(e)
 110     me._del(e)
 111     return rc
 112   def popitem(me):
 113     """D.popitem() -> KEY, VALUE: return and remove an association pair"""
 114     cdef _MapIterator i = me._iter()
 115     cdef void *e = i._next()
 116     if not e:
 117       raise ValueError('popitem(): table is empty')
 118     return me._key(e), me._value(e)
 119
 120   ## Lists of items.
 121   IF PYVERSION < (3,):
 122     cdef object _list(me, object (*func)(_Mapping m, void *e)):
 123       cdef _MapIterator i = me._iter()
 124       cdef void *e
 125       l = []
 126       while 1:
 127         e = i._next()
 128         if not e:
 129           break
 130         l.append(func(me, e))
 131       return l
 132
 133     def keys(me):
 134       """D.keys() -> LIST: return a list of known keys"""
 135       return me._list(_map_key)
 136     def values(me):
 137       """D.values() -> LIST: return a list of known values"""
 138       return me._list(_map_value)
 139     def items(me):
 140       """D.items() -> LIST: return a list of known (KEY, VALUE) pairs"""
 141       return me._list(_map_item)
 142
 143   def clear(me):
 144     """D.clear(): remove all mappings"""
 145     cdef _MapIterator i = me._iter()
 146     cdef void *e
 147     while 1:
 148       e = i._next()
 149       if not e:
 150         break
 151       me._del(e)
 152     return me
 153
 154   ## Iteration.
 155   def __iter__(me):
 156     return MapKeyIter(me)
 157   IF PYVERSION >= (3,):
 158     def keys(me):
 159       """D.keys() -> ITER: return iterator over keys"""
 160       return MapKeyIter(me)
 161     def values(me):
 162       """D.values() -> ITER: return iterator over values"""
 163       return MapValueIter(me)
 164     def items(me):
 165       """D.items() -> ITER: return iterator over (KEY, VALUE) pairs"""
 166       return MapItemIter(me)
 167   ELSE:
 168     def iterkeys(me):
 169       """D.iterkeys() -> ITER: return iterator over keys"""
 170       return MapKeyIter(me)
 171     def itervalues(me):
 172       """D.itervalues() -> ITER: return iterator over values"""
 173       return MapValueIter(me)
 174     def iteritems(me):
 175       """D.iteritems() -> ITER: return iterator over (KEY, VALUE) pairs"""
 176       return MapItemIter(me)
 177
 178 cdef class _MapIterBase:
 179   cdef _Mapping m
 180   cdef object (*func)(_Mapping m, void *e)
 181   cdef _MapIterator i
 182   cdef int _init(me) except -1:
 183     raise TypeError('abstract class')
 184   def __init__(me, _Mapping m):
 185     me.m = m
 186     me.i = m._iter()
 187     me._init()
 188   def __iter__(me):
 189     return me
 190   def __next__(me):
 191     cdef void *e
 192     e = me.i._next()
 193     if not e:
 194       raise StopIteration
 195     return me.func(me.m, e)
 196 cdef class MapKeyIter (_MapIterBase):
 197   cdef int _init(me) except -1:
 198     me.func = _map_key
 199     return 0
 200 cdef class MapValueIter (_MapIterBase):
 201   cdef int _init(me) except -1:
 202     me.func = _map_value
 203     return 0
 204 cdef class MapItemIter (_MapIterBase):
 205   cdef int _init(me) except -1:
 206     me.func = _map_item
 207     return 0
 208
 209 cdef object _map_key(_Mapping m, void *e):
 210   return m._key(e)
 211 cdef object _map_value(_Mapping m, void *e):
 212   return m._value(e)
 213 cdef object _map_item(_Mapping m, void *e):
 214   return m._key(e), m._value(e)
 215
 216 ###----- That's all, folks --------------------------------------------------