NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

UserDict.py (5275B)


      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\carbon\common\stdlib\UserDict.py
      2 
      3 
      4 class UserDict:
      5 
      6     def __init__(self, dict = None, **kwargs):
      7         self.data = {}
      8         if dict is not None:
      9             self.update(dict)
     10         if len(kwargs):
     11             self.update(kwargs)
     12 
     13     def __repr__(self):
     14         return repr(self.data)
     15 
     16     def __cmp__(self, dict):
     17         if isinstance(dict, UserDict):
     18             return cmp(self.data, dict.data)
     19         else:
     20             return cmp(self.data, dict)
     21 
     22     __hash__ = None
     23 
     24     def __len__(self):
     25         return len(self.data)
     26 
     27     def __getitem__(self, key):
     28         if key in self.data:
     29             return self.data[key]
     30         if hasattr(self.__class__, '__missing__'):
     31             return self.__class__.__missing__(self, key)
     32         raise KeyError(key)
     33 
     34     def __setitem__(self, key, item):
     35         self.data[key] = item
     36 
     37     def __delitem__(self, key):
     38         del self.data[key]
     39 
     40     def clear(self):
     41         self.data.clear()
     42 
     43     def copy(self):
     44         if self.__class__ is UserDict:
     45             return UserDict(self.data.copy())
     46         import copy
     47         data = self.data
     48         try:
     49             self.data = {}
     50             c = copy.copy(self)
     51         finally:
     52             self.data = data
     53 
     54         c.update(self)
     55         return c
     56 
     57     def keys(self):
     58         return self.data.keys()
     59 
     60     def items(self):
     61         return self.data.items()
     62 
     63     def iteritems(self):
     64         return self.data.iteritems()
     65 
     66     def iterkeys(self):
     67         return self.data.iterkeys()
     68 
     69     def itervalues(self):
     70         return self.data.itervalues()
     71 
     72     def values(self):
     73         return self.data.values()
     74 
     75     def has_key(self, key):
     76         return key in self.data
     77 
     78     def update(self, dict = None, **kwargs):
     79         if dict is None:
     80             pass
     81         elif isinstance(dict, UserDict):
     82             self.data.update(dict.data)
     83         elif isinstance(dict, type({})) or not hasattr(dict, 'items'):
     84             self.data.update(dict)
     85         else:
     86             for k, v in dict.items():
     87                 self[k] = v
     88 
     89         if len(kwargs):
     90             self.data.update(kwargs)
     91 
     92     def get(self, key, failobj = None):
     93         if key not in self:
     94             return failobj
     95         return self[key]
     96 
     97     def setdefault(self, key, failobj = None):
     98         if key not in self:
     99             self[key] = failobj
    100         return self[key]
    101 
    102     def pop(self, key, *args):
    103         return self.data.pop(key, *args)
    104 
    105     def popitem(self):
    106         return self.data.popitem()
    107 
    108     def __contains__(self, key):
    109         return key in self.data
    110 
    111     @classmethod
    112     def fromkeys(cls, iterable, value = None):
    113         d = cls()
    114         for key in iterable:
    115             d[key] = value
    116 
    117         return d
    118 
    119 
    120 class IterableUserDict(UserDict):
    121 
    122     def __iter__(self):
    123         return iter(self.data)
    124 
    125 
    126 import _abcoll
    127 _abcoll.MutableMapping.register(IterableUserDict)
    128 
    129 class DictMixin:
    130 
    131     def __iter__(self):
    132         for k in self.keys():
    133             yield k
    134 
    135     def has_key(self, key):
    136         try:
    137             self[key]
    138         except KeyError:
    139             return False
    140 
    141         return True
    142 
    143     def __contains__(self, key):
    144         return self.has_key(key)
    145 
    146     def iteritems(self):
    147         for k in self:
    148             yield (k, self[k])
    149 
    150     def iterkeys(self):
    151         return self.__iter__()
    152 
    153     def itervalues(self):
    154         for _, v in self.iteritems():
    155             yield v
    156 
    157     def values(self):
    158         return [ v for _, v in self.iteritems() ]
    159 
    160     def items(self):
    161         return list(self.iteritems())
    162 
    163     def clear(self):
    164         for key in self.keys():
    165             del self[key]
    166 
    167     def setdefault(self, key, default = None):
    168         try:
    169             return self[key]
    170         except KeyError:
    171             self[key] = default
    172 
    173         return default
    174 
    175     def pop(self, key, *args):
    176         if len(args) > 1:
    177             raise TypeError, 'pop expected at most 2 arguments, got ' + repr(1 + len(args))
    178         try:
    179             value = self[key]
    180         except KeyError:
    181             if args:
    182                 return args[0]
    183             raise
    184 
    185         del self[key]
    186         return value
    187 
    188     def popitem(self):
    189         try:
    190             k, v = self.iteritems().next()
    191         except StopIteration:
    192             raise KeyError, 'container is empty'
    193 
    194         del self[k]
    195         return (k, v)
    196 
    197     def update(self, other = None, **kwargs):
    198         if other is None:
    199             pass
    200         elif hasattr(other, 'iteritems'):
    201             for k, v in other.iteritems():
    202                 self[k] = v
    203 
    204         elif hasattr(other, 'keys'):
    205             for k in other.keys():
    206                 self[k] = other[k]
    207 
    208         else:
    209             for k, v in other:
    210                 self[k] = v
    211 
    212         if kwargs:
    213             self.update(kwargs)
    214 
    215     def get(self, key, default = None):
    216         try:
    217             return self[key]
    218         except KeyError:
    219             return default
    220 
    221     def __repr__(self):
    222         return repr(dict(self.iteritems()))
    223 
    224     def __cmp__(self, other):
    225         if other is None:
    226             return 1
    227         if isinstance(other, DictMixin):
    228             other = dict(other.iteritems())
    229         return cmp(dict(self.iteritems()), other)
    230 
    231     def __len__(self):
    232         return len(self.keys())