[jToolkit-cvs] jToolkit cidict.py,1.3,1.4

[<dav...@us...>]

Update of /cvsroot/jtoolkit/jToolkit
In directory sc8-pr-cvs1:/tmp/cvs-serv13467

Modified Files:
	cidict.py 
Log Message:
added more intelligense to handle str/unicode comparisons
added an ordereddict class


Index: cidict.py
===================================================================
RCS file: /cvsroot/jtoolkit/jToolkit/cidict.py,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** cidict.py	25 Sep 2003 17:36:55 -0000	1.3
--- cidict.py	2 Dec 2003 08:21:43 -0000	1.4
***************
*** 21,24 ****
--- 21,26 ----
  # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
+ from __future__ import generators
+ 
  def filterdict(origdict, keyset):
    """returns the subset of origdict containing only the keys in keyset and their corresponding values """
***************
*** 41,44 ****
--- 43,54 ----
        if (type(lvalue) != type(rvalue)) and not (type(lvalue) in (str, unicode) and type(rvalue) in (str, unicode)):
          diffdict[key] = lvalue
+       elif type(lvalue) != type(rvalue):
+         # handle str/unicode mismatch
+         if type(lvalue) == str: lvaluecmp = lvalue.decode('iso8859')
+         else: lvaluecmp = lvalue
+         if type(rvalue) == str: rvaluecmp = rvalue.decode('iso8859')
+         else: rvaluecmp = rvalue
+         if lvaluecmp != rvaluecmp:
+           diffdict[key] = lvalue
        elif lvalue != rvalue:
          diffdict[key] = lvalue
***************
*** 119,121 ****
--- 129,211 ----
      else:
        return default
+ 
+ class ordereddict(dict):
+   """a dictionary which remembers its keys in the order in which they were given"""
+   def __init__(self, *args):
+     if len(args) == 0:
+       super(ordereddict, self).__init__()
+       self.order = []
+     elif len(args) > 1:
+       raise TypeError("ordereddict() takes at most 1 argument (%d given)" % len(args))
+     else:
+       initarg = args[0]
+       apply(super(ordereddict, self).__init__, args)
+       if hasattr(initarg, "keys"):
+         self.order = initarg.keys()
+       else:
+         # danger: could have duplicate keys...
+         self.order = []
+         checkduplicates = {}
+         for key, value in initarg:
+           if not key in checkduplicates:
+             self.order.append(key)
+             checkduplicates[key] = None
+ 
+   def __setitem__(self, key, value):
+     alreadypresent = key in self
+     result = dict.__setitem__(self, key, value)
+     if not alreadypresent: self.order.append(key)
+     return result
+ 
+   def update(self, updatedict):
+     """D.update(E) -> None.  Update D from E: for k in E.keys(): D[k] = E[k]"""
+     for key, value in updatedict.iteritems():
+       self[key] = value
+ 
+   def __delitem__(self, key):
+     alreadypresent = key in self
+     result = dict.__delitem__(self, key)
+     if not alreadypresent: del self.order[self.order.find(key)]
+     return result
+ 
+   def copy(self):
+     """D.copy() -> a shallow copy of D"""
+     thecopy = ordereddict(super(ordereddict, self).copy())
+     thecopy.order = self.order[:]
+     return thecopy
+ 
+   def items(self):
+     """D.items() -> list of D's (key, value) pairs, as 2-tuples"""
+     return [(key, self[key]) for key in self.order]
+ 
+   def iteritems(self):
+     """D.iteritems() -> an iterator over the (key, value) items of D"""
+     for key in self.order:
+       yield (key, self[key])
+ 
+   def iterkeys(self):
+     """D.iterkeys() -> an iterator over the keys of D"""
+     for key in self.order:
+       yield key
+ 
+   __iter__ = iterkeys
+ 
+   def itervalues(self):
+     """D.itervalues() -> an iterator over the values of D"""
+     for key in self.order:
+       yield self[key]
+ 
+   def keys(self):
+     """D.keys() -> list of D's keys"""
+     return self.order[:]
+ 
+   def popitem(self):
+     """D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty"""
+     if len(self.order) == 0:
+       raise KeyError("popitem(): ordered dictionary is empty")
+     k = self.order.pop()
+     v = self[k]
+     del self[k]
+     return (k,v)
+