-

cool-RR · cool-RR · commit d1ef3ac5c480 · 2014-03-09T00:34:11.000+02:00
diff --git a/source_py3/python_toolbox/nifty_collections/ordered_dict.py b/source_py3/python_toolbox/nifty_collections/ordered_dict.py
@@ -14,7 +14,7 @@
 
 class OrderedDict(StdlibOrderedDict):
     
-    def sort(self, key=None, reversed=False):
+    def sort(self, key=None, reverse=False):
         '''
         Sort the items according to their keys, changing the order in-place.
         
@@ -23,9 +23,8 @@ def sort(self, key=None, reversed=False):
         '''
         key_function = \
                    comparison_tools.process_key_function_or_attribute_name(key)
-        sorted_keys = sorted(self.keys(), key=key_function)
-        step = -1 if reversed else 1
-        for key_ in sorted_keys[1::step]:
+        sorted_keys = sorted(self.keys(), key=key_function, reverse=reverse)
+        for key_ in sorted_keys[1:]:
             self.move_to_end(key_)
         
     
diff --git a/source_py3/python_toolbox/nifty_collections/ordered_set.py b/source_py3/python_toolbox/nifty_collections/ordered_set.py
@@ -10,6 +10,9 @@
 
 import collections
 
+from python_toolbox import comparison_tools
+
+
 KEY, PREV, NEXT = range(3)
 
 
@@ -22,49 +25,53 @@ class OrderedSet(collections.MutableSet):
     '''
 
     def __init__(self, iterable=None):
-        self.end = end = [] 
-        end += [None, end, end]         # sentinel node for doubly linked list
-        self.map = {}                   # key --> [key, prev, next]
+        self.clear()
         if iterable is not None:
             self |= iterable
 
+
+    def clear(self):
+        self._end = [] 
+        self._end += [None, self._end, self._end]
+        self._map = {}                   
+
     def __len__(self):
-        return len(self.map)
+        return len(self._map)
 
     def __contains__(self, key):
-        return key in self.map
+        return key in self._map
 
     def add(self, key):
         """
         Add an element to a set.
     
         This has no effect if the element is already present.
         """
-        if key not in self.map:
-            end = self.end
+        if key not in self._map:
+            end = self._end
             curr = end[PREV]
-            curr[NEXT] = end[PREV] = self.map[key] = [key, curr, end]
+            curr[NEXT] = end[PREV] = self._map[key] = [key, curr, end]
 
     def discard(self, key):
         """
         Remove an element from a set if it is a member.
     
         If the element is not a member, do nothing.
         """
-        if key in self.map:        
-            key, prev, next = self.map.pop(key)
+        if key in self._map:        
+            key, prev, next = self._map.pop(key)
             prev[NEXT] = next
             next[PREV] = prev
 
     def __iter__(self):
-        end = self.end
+        end = self._end
         curr = end[NEXT]
         while curr is not end:
             yield curr[KEY]
             curr = curr[NEXT]
 
     def __reversed__(self):
-        end = self.end
+        end = self._end
         curr = end[PREV]
         while curr is not end:
             yield curr[KEY]
@@ -92,3 +99,34 @@ def __del__(self):
         self.clear()                    # remove circular references
         # todo: is this really needed? i'm worried about this making the gc not
         # drop circulary-referencing objects.
+
+    def move_to_end(self, key):
+        '''Move an existing element to the end (or beginning if last==False).
+
+        Raises KeyError if the element does not exist.
+        When last=True, acts like a fast version of self[key]=self.pop(key).
+
+        '''
+        # Inefficient implementation until someone cares.
+        if key in self:
+            self.remove(key)
+            self.add(key)
+            
+    
+    def sort(self, key=None, reverse=False):
+        '''
+        Sort the items according to their keys, changing the order in-place.
+        
+        The optional `key` argument will be passed to the `sorted` function as
+        a key function.
+        '''
+        # Inefficient implementation until someone cares.
+        key_function = \
+                   comparison_tools.process_key_function_or_attribute_name(key)
+        sorted_members = sorted(tuple(self), key=key_function, reverse=reverse)
+        
+        self.clear()
+        for member in sorted_members[1:]:
+            self.move_to_end(member)
+        
+      
