Rev 2252: move 'content' to be the last member in _range_map, it just looks cleaner in http://bzr.arbash-meinel.com/branches/bzr/0.15-dev/list_patch

John Arbash Meinel john at arbash-meinel.com
Tue Jan 30 16:53:26 GMT 2007


At http://bzr.arbash-meinel.com/branches/bzr/0.15-dev/list_patch

------------------------------------------------------------
revno: 2252
revision-id: john at arbash-meinel.com-20070130165322-t5q71sf9ei1co1w7
parent: john at arbash-meinel.com-20070130163007-lb5g247vjygjhkzb
committer: John Arbash Meinel <john at arbash-meinel.com>
branch nick: list_patch
timestamp: Tue 2007-01-30 10:53:22 -0600
message:
  move 'content' to be the last member in _range_map, it just looks cleaner
modified:
  bzrlib/hybrid_linked_list.py   hybrid_linked_list.p-20070130001028-zlexwz74tzo56o2t-1
  bzrlib/tests/test_hybrid_linked_list.py test_hybrid_linked_l-20070130001028-zlexwz74tzo56o2t-2
-------------- next part --------------
=== modified file 'bzrlib/hybrid_linked_list.py'
--- a/bzrlib/hybrid_linked_list.py	2007-01-30 16:30:07 +0000
+++ b/bzrlib/hybrid_linked_list.py	2007-01-30 16:53:22 +0000
@@ -62,7 +62,7 @@
         cur_range_id = self._head
 
         while cur_range_id is not None:
-            content, start, end = self._range_map[cur_range_id]
+            start, end, content = self._range_map[cur_range_id]
             for pos in xrange(start, end):
                 yield content[pos]
             cur_range_id = self._links[cur_range_id]
@@ -71,14 +71,14 @@
         cur_range_id = self._head
         length = 0
         while cur_range_id is not None:
-            content, start, end = self._range_map[cur_range_id]
+            start, end, content = self._range_map[cur_range_id]
             length += (end - start)
             cur_range_id = self._links[cur_range_id]
         return length
 
     def __getitem__(self, pos):
         (prev_range_id, cur_range_id, offset,
-         content, start, end) = self._find_nodes_for_pos(pos)
+         start, end, content) = self._find_nodes_for_pos(pos)
         return content[start+offset]
 
     def flatten(self):
@@ -100,7 +100,7 @@
         content = start = end = None
 
         while cur_range_id is not None:
-            content, start, end = self._range_map[cur_range_id]
+            start, end, content = self._range_map[cur_range_id]
             next_pos = cur_pos + (end - start)
             if pos < next_pos:
                 break
@@ -109,20 +109,20 @@
             cur_pos = next_pos
             content = start = end = None
         return (prev_range_id, cur_range_id, pos - cur_pos,
-                content, start, end)
+                start, end, content)
 
-    def _new_range_id(self, content, start, end):
+    def _new_range_id(self, start, end, content):
         """Get a new range id."""
         self._ranges_counter += 1
-        self._range_map[self._ranges_counter] = (content, start, end)
+        self._range_map[self._ranges_counter] = (start, end, content)
         return self._ranges_counter
 
     def insert(self, start, content):
         """Insert a set of entries starting at the first position."""
-        new_range_id = self._new_range_id(content, 0, len(content))
+        new_range_id = self._new_range_id(0, len(content), content)
 
         (prev_range_id, cur_range_id, offset,
-         content, start, end) = self._find_nodes_for_pos(start)
+         start, end, content) = self._find_nodes_for_pos(start)
 
         if offset == 0:
             # We are inserting before an existing node, or at the exact end of
@@ -149,7 +149,7 @@
                 # We need to break up the current node, and insert the
                 # requested one
                 break_point = start + offset
-                split_range_id = self._new_range_id(content, break_point, end)
+                split_range_id = self._new_range_id(break_point, end, content)
                 next_range_id = self._links[cur_range_id]
                 self._links[split_range_id] = next_range_id
                 self._links[new_range_id] = split_range_id
@@ -159,7 +159,7 @@
                 # self._links[prev_range_id] = new_head_range
                 # And then afterwards we would want to delete the cur_range_id
                 # entry in the map
-                self._range_map[cur_range_id] = (content, start, break_point)
+                self._range_map[cur_range_id] = (start, break_point, content)
                 self._links[cur_range_id] = new_range_id
 
     def delete(self, start, end):
@@ -177,7 +177,7 @@
             return
 
         (prev_range_id, cur_range_id, offset,
-         content, cur_start, cur_end) = self._find_nodes_for_pos(start)
+         cur_start, cur_end, content) = self._find_nodes_for_pos(start)
 
         if cur_range_id is None:
             # We fell off the end, nothing to do
@@ -216,8 +216,9 @@
                 else:
                     # CASE 2: we save the beginning, but remove the tail
                     # This only requires a node entry update
-                    self._range_map[cur_range_id] = (content, cur_start,
-                                                     cur_start + offset)
+                    self._range_map[cur_range_id] = (cur_start,
+                                                     cur_start + offset,
+                                                     content)
                     prev_range_id = cur_range_id
                 remove_length -= possible_remove_length
                 if remove_length == 0:
@@ -225,13 +226,13 @@
                 # step to next
                 offset = 0
                 cur_range_id = next_range_id
-                content, cur_start, cur_end = self._range_map[next_range_id]
+                cur_start, cur_end, content = self._range_map[next_range_id]
             else:
                 if offset == 0:
                     # CASE 3: We remove only the beginning of this node
                     # Only requires a node entry update
-                    self._range_map[cur_range_id] = (content,
-                            cur_start + remove_length, cur_end)
+                    self._range_map[cur_range_id] = (cur_start + remove_length,
+                                                     cur_end, content)
                 else:
                     # We have a beginning and a tail, we need to create a new
                     # record, and update the current one
@@ -241,14 +242,14 @@
                     new_end = cur_start + offset
                     new_start = new_end + remove_length
 
-                    new_tail_range_id = self._new_range_id(content,
-                                                           new_start, cur_end)
+                    new_tail_range_id = self._new_range_id(new_start, cur_end,
+                                                           content)
                     next_range_id = self._links[cur_range_id]
                     self._links[new_tail_range_id] = next_range_id
 
                     self._links[cur_range_id] = new_tail_range_id
-                    self._range_map[cur_range_id] = (content, cur_start,
-                                                     new_end)
+                    self._range_map[cur_range_id] = (cur_start, new_end,
+                                                     content)
                 # We officially removed enough, so we are done
                 break
                 # we are not removing the start of this node

=== modified file 'bzrlib/tests/test_hybrid_linked_list.py'
--- a/bzrlib/tests/test_hybrid_linked_list.py	2007-01-30 16:30:07 +0000
+++ b/bzrlib/tests/test_hybrid_linked_list.py	2007-01-30 16:53:22 +0000
@@ -40,12 +40,12 @@
         hll.delete(2, 3)
         hll.delete(5, 7)
         self.assertEqual([0, 1, 3, 4, 5, 8], list(hll))
-        self.assertEqual((None, 0, 0, content, 0, 2), hll._find_nodes_for_pos(0))
-        self.assertEqual((None, 0, 1, content, 0, 2), hll._find_nodes_for_pos(1))
-        self.assertEqual((0, 1, 0, content, 3, 6), hll._find_nodes_for_pos(2))
-        self.assertEqual((0, 1, 1, content, 3, 6), hll._find_nodes_for_pos(3))
-        self.assertEqual((0, 1, 2, content, 3, 6), hll._find_nodes_for_pos(4))
-        self.assertEqual((1, 2, 0, content, 8, 9), hll._find_nodes_for_pos(5))
+        self.assertEqual((None, 0, 0, 0, 2, content), hll._find_nodes_for_pos(0))
+        self.assertEqual((None, 0, 1, 0, 2, content), hll._find_nodes_for_pos(1))
+        self.assertEqual((0, 1, 0, 3, 6, content), hll._find_nodes_for_pos(2))
+        self.assertEqual((0, 1, 1, 3, 6, content), hll._find_nodes_for_pos(3))
+        self.assertEqual((0, 1, 2, 3, 6, content), hll._find_nodes_for_pos(4))
+        self.assertEqual((1, 2, 0, 8, 9, content), hll._find_nodes_for_pos(5))
         self.assertEqual((2, None, 0, None, None, None),
                          hll._find_nodes_for_pos(6))
         self.assertEqual((2, None, 1, None, None, None),
@@ -62,11 +62,9 @@
     def test_insert(self):
         hll = hybrid_linked_list.HybridLinkedList([0, 1, 2, 3, 4])
         hll.insert(3, [5, 6, 7])
-        # self.assertEqual([[0, 1, 2], [5, 6, 7], [3, 4]], hll._nodes)
         self.assertEqual([0, 1, 2, 5, 6, 7, 3, 4], list(hll))
         self.assertEqual(8, len(hll))
         hll.flatten()
-        # self.assertEqual([[0, 1, 2, 5, 6, 7, 3, 4]], hll._nodes)
 
     def test_insert_beginning(self):
         hll = hybrid_linked_list.HybridLinkedList([0, 1, 2, 3, 4])
@@ -93,10 +91,10 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:1, 1:2, 2:3, 3:None}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 0, 3),
-                          1:([3, 4], 0, 2),
-                          2:([5, 6, 7], 0, 3),
-                          3:([8], 0, 1),
+        self.assertEqual({0:(0, 3, [0, 1, 2]),
+                          1:(0, 2, [3, 4]),
+                          2:(0, 3, [5, 6, 7]),
+                          3:(0, 1, [8]),
                          }, hll._range_map)
 
     def test_delete(self):
@@ -116,9 +114,9 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(1, hll._head)
         self.assertEqual({1:2, 2:3, 3:None}, hll._links)
-        self.assertEqual({1:([3, 4], 0, 2),
-                          2:([5, 6, 7], 0, 3),
-                          3:([8], 0, 1),
+        self.assertEqual({1:(0, 2, [3, 4]),
+                          2:(0, 3, [5, 6, 7]),
+                          3:(0, 1, [8]),
                          }, hll._range_map)
 
     def test_delete_middle_range(self):
@@ -128,9 +126,9 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:2, 2:3, 3:None}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 0, 3),
-                          2:([5, 6, 7], 0, 3),
-                          3:([8], 0, 1),
+        self.assertEqual({0:(0, 3, [0, 1, 2]),
+                          2:(0, 3, [5, 6, 7]),
+                          3:(0, 1, [8]),
                          }, hll._range_map)
 
     def test_delete_last_range(self):
@@ -140,9 +138,9 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:1, 1:2, 2:None}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 0, 3),
-                          1:([3, 4], 0, 2),
-                          2:([5, 6, 7], 0, 3),
+        self.assertEqual({0:(0, 3, [0, 1, 2]),
+                          1:(0, 2, [3, 4]),
+                          2:(0, 3, [5, 6, 7]),
                          }, hll._range_map)
 
     def test_delete_partial_beginning(self):
@@ -152,10 +150,10 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:1, 1:2, 2:3, 3:None}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 2, 3),
-                          1:([3, 4], 0, 2),
-                          2:([5, 6, 7], 0, 3),
-                          3:([8], 0, 1),
+        self.assertEqual({0:(2, 3, [0, 1, 2]),
+                          1:(0, 2, [3, 4]),
+                          2:(0, 3, [5, 6, 7]),
+                          3:(0, 1, [8]),
                          }, hll._range_map)
 
     def test_delete_partial_ending(self):
@@ -165,10 +163,10 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:1, 1:2, 2:3, 3:None}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 0, 1),
-                          1:([3, 4], 0, 2),
-                          2:([5, 6, 7], 0, 3),
-                          3:([8], 0, 1),
+        self.assertEqual({0:(0, 1, [0, 1, 2]),
+                          1:(0, 2, [3, 4]),
+                          2:(0, 3, [5, 6, 7]),
+                          3:(0, 1, [8]),
                          }, hll._range_map)
 
     def test_delete_middle_section(self):
@@ -178,15 +176,15 @@
         self.assertEqual(4, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:4, 1:2, 2:3, 3:None, 4:1}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 0, 1),
-                          1:([3, 4], 0, 2),
-                          2:([5, 6, 7], 0, 3),
-                          3:([8], 0, 1),
-                          4:([0, 1, 2], 2, 3),
+        self.assertEqual({0:(0, 1, [0, 1, 2]),
+                          1:(0, 2, [3, 4]),
+                          2:(0, 3, [5, 6, 7]),
+                          3:(0, 1, [8]),
+                          4:(2, 3, [0, 1, 2]),
                          }, hll._range_map)
         # Make sure that even though we have 2 entries with the same content,
         # it just copied a reference, not the actual content.
-        self.assertEqual(id(hll._range_map[0][0]), id(hll._range_map[4][0]))
+        self.assertEqual(id(hll._range_map[0][2]), id(hll._range_map[4][2]))
 
     def test_delete_middle(self):
         hll = self.get_sectioned_hll()
@@ -195,10 +193,10 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:1, 1:2, 2:3, 3:None}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 0, 3),
-                          1:([3, 4], 1, 2),
-                          2:([5, 6, 7], 0, 3),
-                          3:([8], 0, 1),
+        self.assertEqual({0:(0, 3, [0, 1, 2]),
+                          1:(1, 2, [3, 4]),
+                          2:(0, 3, [5, 6, 7]),
+                          3:(0, 1, [8]),
                          }, hll._range_map)
 
     def test_delete_across_sections(self):
@@ -208,9 +206,9 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:2, 2:3, 3:None}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 0, 1),
-                          2:([5, 6, 7], 2, 3),
-                          3:([8], 0, 1),
+        self.assertEqual({0:(0, 1, [0, 1, 2]),
+                          2:(2, 3, [5, 6, 7]),
+                          3:(0, 1, [8]),
                          }, hll._range_map)
 
     def test_delete_off_end(self):
@@ -220,7 +218,7 @@
         self.assertEqual(3, hll._ranges_counter)
         self.assertEqual(0, hll._head)
         self.assertEqual({0:None}, hll._links)
-        self.assertEqual({0:([0, 1, 2], 0, 1),
+        self.assertEqual({0:(0, 1, [0, 1, 2]),
                          }, hll._range_map)
 
     def test_delete_all(self):



More information about the bazaar-commits mailing list