src/third_party/pyelftools/elftools/common/ordereddict.py

   1 # http://code.activestate.com/recipes/576693/ (r9)\r
   2 #       Created by Raymond Hettinger on Wed, 18 Mar 2009 (MIT) \r
   3 #\r
   4 # Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 \r
   5 # and pypy.\r
   6 # Passes Python2.7's test suite and incorporates all the latest updates.\r
   7 #\r
   8 \r
   9 try:\r
  10     from thread import get_ident as _get_ident\r
  11 except ImportError:\r
  12     from dummy_thread import get_ident as _get_ident\r
  13 \r
  14 try:\r
  15     from _abcoll import KeysView, ValuesView, ItemsView\r
  16 except ImportError:\r
  17     pass\r
  18 \r
  19 \r
  20 class OrderedDict(dict):\r
  21     'Dictionary that remembers insertion order'\r
  22     # An inherited dict maps keys to values.\r
  23     # The inherited dict provides __getitem__, __len__, __contains__, and get.\r
  24     # The remaining methods are order-aware.\r
  25     # Big-O running times for all methods are the same as for regular dictionaries.\r
  26 \r
  27     # The internal self.__map dictionary maps keys to links in a doubly linked list.\r
  28     # The circular doubly linked list starts and ends with a sentinel element.\r
  29     # The sentinel element never gets deleted (this simplifies the algorithm).\r
  30     # Each link is stored as a list of length three:  [PREV, NEXT, KEY].\r
  31 \r
  32     def __init__(self, *args, **kwds):\r
  33         '''Initialize an ordered dictionary.  Signature is the same as for\r
  34         regular dictionaries, but keyword arguments are not recommended\r
  35         because their insertion order is arbitrary.\r
  36 \r
  37         '''\r
  38         if len(args) > 1:\r
  39             raise TypeError('expected at most 1 arguments, got %d' % len(args))\r
  40         try:\r
  41             self.__root\r
  42         except AttributeError:\r
  43             self.__root = root = []                     # sentinel node\r
  44             root[:] = [root, root, None]\r
  45             self.__map = {}\r
  46         self.__update(*args, **kwds)\r
  47 \r
  48     def __setitem__(self, key, value, dict_setitem=dict.__setitem__):\r
  49         'od.__setitem__(i, y) <==> od[i]=y'\r
  50         # Setting a new item creates a new link which goes at the end of the linked\r
  51         # list, and the inherited dictionary is updated with the new key/value pair.\r
  52         if key not in self:\r
  53             root = self.__root\r
  54             last = root[0]\r
  55             last[1] = root[0] = self.__map[key] = [last, root, key]\r
  56         dict_setitem(self, key, value)\r
  57 \r
  58     def __delitem__(self, key, dict_delitem=dict.__delitem__):\r
  59         'od.__delitem__(y) <==> del od[y]'\r
  60         # Deleting an existing item uses self.__map to find the link which is\r
  61         # then removed by updating the links in the predecessor and successor nodes.\r
  62         dict_delitem(self, key)\r
  63         link_prev, link_next, key = self.__map.pop(key)\r
  64         link_prev[1] = link_next\r
  65         link_next[0] = link_prev\r
  66 \r
  67     def __iter__(self):\r
  68         'od.__iter__() <==> iter(od)'\r
  69         root = self.__root\r
  70         curr = root[1]\r
  71         while curr is not root:\r
  72             yield curr[2]\r
  73             curr = curr[1]\r
  74 \r
  75     def __reversed__(self):\r
  76         'od.__reversed__() <==> reversed(od)'\r
  77         root = self.__root\r
  78         curr = root[0]\r
  79         while curr is not root:\r
  80             yield curr[2]\r
  81             curr = curr[0]\r
  82 \r
  83     def clear(self):\r
  84         'od.clear() -> None.  Remove all items from od.'\r
  85         try:\r
  86             for node in self.__map.itervalues():\r
  87                 del node[:]\r
  88             root = self.__root\r
  89             root[:] = [root, root, None]\r
  90             self.__map.clear()\r
  91         except AttributeError:\r
  92             pass\r
  93         dict.clear(self)\r
  94 \r
  95     def popitem(self, last=True):\r
  96         '''od.popitem() -> (k, v), return and remove a (key, value) pair.\r
  97         Pairs are returned in LIFO order if last is true or FIFO order if false.\r
  98 \r
  99         '''\r
 100         if not self:\r
 101             raise KeyError('dictionary is empty')\r
 102         root = self.__root\r
 103         if last:\r
 104             link = root[0]\r
 105             link_prev = link[0]\r
 106             link_prev[1] = root\r
 107             root[0] = link_prev\r
 108         else:\r
 109             link = root[1]\r
 110             link_next = link[1]\r
 111             root[1] = link_next\r
 112             link_next[0] = root\r
 113         key = link[2]\r
 114         del self.__map[key]\r
 115         value = dict.pop(self, key)\r
 116         return key, value\r
 117 \r
 118     # -- the following methods do not depend on the internal structure --\r
 119 \r
 120     def keys(self):\r
 121         'od.keys() -> list of keys in od'\r
 122         return list(self)\r
 123 \r
 124     def values(self):\r
 125         'od.values() -> list of values in od'\r
 126         return [self[key] for key in self]\r
 127 \r
 128     def items(self):\r
 129         'od.items() -> list of (key, value) pairs in od'\r
 130         return [(key, self[key]) for key in self]\r
 131 \r
 132     def iterkeys(self):\r
 133         'od.iterkeys() -> an iterator over the keys in od'\r
 134         return iter(self)\r
 135 \r
 136     def itervalues(self):\r
 137         'od.itervalues -> an iterator over the values in od'\r
 138         for k in self:\r
 139             yield self[k]\r
 140 \r
 141     def iteritems(self):\r
 142         'od.iteritems -> an iterator over the (key, value) items in od'\r
 143         for k in self:\r
 144             yield (k, self[k])\r
 145 \r
 146     def update(*args, **kwds):\r
 147         '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.\r
 148 \r
 149         If E is a dict instance, does:           for k in E: od[k] = E[k]\r
 150         If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]\r
 151         Or if E is an iterable of items, does:   for k, v in E: od[k] = v\r
 152         In either case, this is followed by:     for k, v in F.items(): od[k] = v\r
 153 \r
 154         '''\r
 155         if len(args) > 2:\r
 156             raise TypeError('update() takes at most 2 positional '\r
 157                             'arguments (%d given)' % (len(args),))\r
 158         elif not args:\r
 159             raise TypeError('update() takes at least 1 argument (0 given)')\r
 160         self = args[0]\r
 161         # Make progressively weaker assumptions about "other"\r
 162         other = ()\r
 163         if len(args) == 2:\r
 164             other = args[1]\r
 165         if isinstance(other, dict):\r
 166             for key in other:\r
 167                 self[key] = other[key]\r
 168         elif hasattr(other, 'keys'):\r
 169             for key in other.keys():\r
 170                 self[key] = other[key]\r
 171         else:\r
 172             for key, value in other:\r
 173                 self[key] = value\r
 174         for key, value in kwds.items():\r
 175             self[key] = value\r
 176 \r
 177     __update = update  # let subclasses override update without breaking __init__\r
 178 \r
 179     __marker = object()\r
 180 \r
 181     def pop(self, key, default=__marker):\r
 182         '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.\r
 183         If key is not found, d is returned if given, otherwise KeyError is raised.\r
 184 \r
 185         '''\r
 186         if key in self:\r
 187             result = self[key]\r
 188             del self[key]\r
 189             return result\r
 190         if default is self.__marker:\r
 191             raise KeyError(key)\r
 192         return default\r
 193 \r
 194     def setdefault(self, key, default=None):\r
 195         'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'\r
 196         if key in self:\r
 197             return self[key]\r
 198         self[key] = default\r
 199         return default\r
 200 \r
 201     def __repr__(self, _repr_running={}):\r
 202         'od.__repr__() <==> repr(od)'\r
 203         call_key = id(self), _get_ident()\r
 204         if call_key in _repr_running:\r
 205             return '...'\r
 206         _repr_running[call_key] = 1\r
 207         try:\r
 208             if not self:\r
 209                 return '%s()' % (self.__class__.__name__,)\r
 210             return '%s(%r)' % (self.__class__.__name__, self.items())\r
 211         finally:\r
 212             del _repr_running[call_key]\r
 213 \r
 214     def __reduce__(self):\r
 215         'Return state information for pickling'\r
 216         items = [[k, self[k]] for k in self]\r
 217         inst_dict = vars(self).copy()\r
 218         for k in vars(OrderedDict()):\r
 219             inst_dict.pop(k, None)\r
 220         if inst_dict:\r
 221             return (self.__class__, (items,), inst_dict)\r
 222         return self.__class__, (items,)\r
 223 \r
 224     def copy(self):\r
 225         'od.copy() -> a shallow copy of od'\r
 226         return self.__class__(self)\r
 227 \r
 228     @classmethod\r
 229     def fromkeys(cls, iterable, value=None):\r
 230         '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S\r
 231         and values equal to v (which defaults to None).\r
 232 \r
 233         '''\r
 234         d = cls()\r
 235         for key in iterable:\r
 236             d[key] = value\r
 237         return d\r
 238 \r
 239     def __eq__(self, other):\r
 240         '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive\r
 241         while comparison to a regular mapping is order-insensitive.\r
 242 \r
 243         '''\r
 244         if isinstance(other, OrderedDict):\r
 245             return len(self)==len(other) and self.items() == other.items()\r
 246         return dict.__eq__(self, other)\r
 247 \r
 248     def __ne__(self, other):\r
 249         return not self == other\r
 250 \r
 251     # -- the following methods are only used in Python 2.7 --\r
 252 \r
 253     def viewkeys(self):\r
 254         "od.viewkeys() -> a set-like object providing a view on od's keys"\r
 255         return KeysView(self)\r
 256 \r
 257     def viewvalues(self):\r
 258         "od.viewvalues() -> an object providing a view on od's values"\r
 259         return ValuesView(self)\r
 260 \r
 261     def viewitems(self):\r
 262         "od.viewitems() -> a set-like object providing a view on od's items"\r
 263         return ItemsView(self)\r
 264 \r