← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/index.py

  • Committer: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/index.py
64
64
        self.reference_lists = reference_lists
65
65
        self._nodes = {}
66
66
 
67
 
    def add_node(self, key, references, value):
 
67
    def add_node(self, key, value, references=()):
68
68
        """Add a node to the index.
69
69
 
70
70
        :param key: The key. keys must be whitespace-free utf8.
200
200
    def iter_all_entries(self):
201
201
        """Iterate over all keys within the index.
202
202
 
203
 
        :return: An iterable of (key, reference_lists, value). There is no
204
 
            defined order for the result iteration - it will be in the most
205
 
            efficient order for the index.
 
203
        :return: An iterable of (key, value) or (key, value, reference_lists).
 
204
            The former tuple is used when there are no reference lists in the
 
205
            index, making the API compatible with simple key:value index types.
 
206
            There is no defined order for the result iteration - it will be in
 
207
            the most efficient order for the index.
206
208
        """
207
209
        stream = self._transport.get(self._name)
208
210
        self._read_prefix(stream)
232
234
                node_refs = []
233
235
                for ref_list in references:
234
236
                    node_refs.append(tuple([self.keys_by_offset[ref][0] for ref in ref_list]))
235
 
                node_refs = tuple(node_refs)
 
237
                yield (key, value, tuple(node_refs))
236
238
            else:
237
 
                node_refs = ()
238
 
            yield (key, node_refs, value)
 
239
                yield (key, value)
239
240
        if trailers != 1:
240
241
            # there must be one line - the empty trailer line.
241
242
            raise errors.BadIndexData(self)
256
257
        """Iterate over keys within the index.
257
258
 
258
259
        :param keys: An iterable providing the keys to be retrieved.
259
 
        :return: An iterable of (key, reference_lists, value). There is no
260
 
            defined order for the result iteration - it will be in the most
261
 
            efficient order for the index.
 
260
        :return: An iterable as per iter_all_entries, but restricted to the
 
261
            keys supplied. No additional keys will be returned, and every
 
262
            key supplied that is in the index will be returned.
262
263
        """
263
264
        keys = set(keys)
264
265
        if not keys:
364
365
 
365
366
        :param nodes: An iterable of (key, node_refs, value) entries to add.
366
367
        """
367
 
        for (key, node_refs, value) in nodes:
368
 
            self.add_node(key, node_refs, value)
 
368
        for (key, value, node_refs) in nodes:
 
369
            self.add_node(key, value, node_refs)
369
370
 
370
371
    def iter_all_entries(self):
371
372
        """Iterate over all keys within the index
374
375
            defined order for the result iteration - it will be in the most
375
376
            efficient order for the index (in this case dictionary hash order).
376
377
        """
377
 
        for key, (absent, references, value) in self._nodes.iteritems():
378
 
            if not absent:
379
 
                yield key, references, value
 
378
        if self.reference_lists:
 
379
            for key, (absent, references, value) in self._nodes.iteritems():
 
380
                if not absent:
 
381
                    yield key, value, references
 
382
        else:
 
383
            for key, (absent, references, value) in self._nodes.iteritems():
 
384
                if not absent:
 
385
                    yield key, value
380
386
 
381
387
    def iter_entries(self, keys):
382
388
        """Iterate over keys within the index.
387
393
            efficient order for the index (keys iteration order in this case).
388
394
        """
389
395
        keys = set(keys)
390
 
        for key in keys.intersection(self._nodes):
391
 
            node = self._nodes[key]
392
 
            if not node[0]:
393
 
                yield key, node[1], node[2]
 
396
        if self.reference_lists:
 
397
            for key in keys.intersection(self._nodes):
 
398
                node = self._nodes[key]
 
399
                if not node[0]:
 
400
                    yield key, node[2], node[1]
 
401
        else:
 
402
            for key in keys.intersection(self._nodes):
 
403
                node = self._nodes[key]
 
404
                if not node[0]:
 
405
                    yield key, node[2]
394
406
 
395
407
    def validate(self):
396
408
        """In memory index's have no known corruption at the moment."""