Rev 4800: Initial implementation of iter_entries. in http://bazaar.launchpad.net/~jameinel/bzr/chk-index

[John Arbash Meinel]

At http://bazaar.launchpad.net/~jameinel/bzr/chk-index

------------------------------------------------------------
revno: 4800
revision-id: john at arbash-meinel.com-20091028195226-rf8w9cjve29ourj9
parent: john at arbash-meinel.com-20091028193322-psg0tagb5xubpq51
committer: John Arbash Meinel <john at arbash-meinel.com>
branch nick: chk-index
timestamp: Wed 2009-10-28 14:52:26 -0500
message:
  Initial implementation of iter_entries.
-------------- next part --------------
=== modified file 'bzrlib/chk_index.py'
--- a/bzrlib/chk_index.py	2009-10-28 19:33:22 +0000
+++ b/bzrlib/chk_index.py	2009-10-28 19:52:26 +0000
@@ -712,6 +712,43 @@
         to_key = self._bit_key_to_key
         return [to_key(bit_key) for bit_key in self._entries]
 
+    def iter_entries(self, keys):
+        """See GraphIndex.iter_entries()"""
+        self._ensure_header()
+        k_to_b = self._key_to_bit_key
+        bit_key_to_key = dict((k_to_b(k), k) for k in keys)
+        if self._entries:
+            # find out what we already have, versus what we are missing
+            missing = []
+            for bit_key in bit_key_to_key:
+                if bit_key in self._entries:
+                    value = self._entries[bit_key]
+                    # Note: This is the string that the btree_index stuff would
+                    #       return
+                    # value_str = '%d %d %d %d' % (value[0][0], value[0][1],
+                    #                              value[1], value[1]+value[2])
+                    yield self, bit_key_to_key[bit_key], value
+                else:
+                    missing.append(bit_key)
+        else:
+            missing = list(bit_key_to_key)
+        if missing:
+            bit_key_to_offset = _bit_key_to_offset[
+                self._header.num_mini_index_entries]
+            offsets = set([bit_key_to_offset(bit_key) for bit_key in missing])
+            # TODO: Strip out offsets that have already been read
+            # offsets = [idx for idx in offsets if not self._mini_index[idx][3]]
+            self._read_entries(offsets)
+            for bit_key in missing:
+                if bit_key in self._entries:
+                    value = self._entries[bit_key]
+                    # Note: This is the string that the btree_index stuff would
+                    #       return
+                    # value_str = '%d %d %d %d' % (value[0][0], value[0][1],
+                    #                              value[1], value[1]+value[2])
+                    yield self, bit_key_to_key[bit_key], value
+                # Anything not found is genuinely missing
+
     def _read_all(self):
         """Read in all the entry records and store them in self._entries"""
         offsets = [idx for idx, info in enumerate(self._mini_index)

=== modified file 'bzrlib/tests/test_chk_index.py'
--- a/bzrlib/tests/test_chk_index.py	2009-10-28 19:33:22 +0000
+++ b/bzrlib/tests/test_chk_index.py	2009-10-28 19:52:26 +0000
@@ -809,3 +809,18 @@
                                  (k3, 0, 1000, 19, 9),
                                 ])
         self.assertEqual(sorted([k1, k2, k3]), sorted(index.keys()))
+
+    def test_iter_entries_tiny(self):
+        index = self.make_index([(k1, 0, 1000, 0, 10),
+                                 (k2, 0, 1000, 10, 9),
+                                 (k3, 0, 1000, 19, 9),
+                                ])
+        self.assertEqual(sorted([(index, k1, ((0, 1000), 0, 10)),
+                                 (index, k2, ((0, 1000), 10, 9)),
+                                 (index, k3, ((0, 1000), 19, 9))]),
+                         sorted(index.iter_entries([k1, k2, k3])))
+        # And again with everything loaded
+        self.assertEqual(sorted([(index, k1, ((0, 1000), 0, 10)),
+                                 (index, k2, ((0, 1000), 10, 9)),
+                                 (index, k3, ((0, 1000), 19, 9))]),
+                         sorted(index.iter_entries([k1, k2, k3])))