/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/index.py

  • Committer: Andrew Bennetts
  • Date: 2008-10-27 06:14:45 UTC
  • mfrom: (3793 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3795.
  • Revision ID: andrew.bennetts@canonical.com-20081027061445-eqt9lz6uw1mbvq4g
Merge from bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/index.py
84
84
        self._nodes = {}
85
85
        self._nodes_by_key = None
86
86
        self._key_length = key_elements
 
87
        self._optimize_for_size = False
87
88
 
88
89
    def _check_key(self, key):
89
90
        """Raise BadIndexKey if key is not a valid key for this index."""
278
279
                (len(result.getvalue()), expected_bytes))
279
280
        return result
280
281
 
 
282
    def set_optimize(self, for_size=True):
 
283
        """Change how the builder tries to optimize the result.
 
284
 
 
285
        :param for_size: Tell the builder to try and make the index as small as
 
286
            possible.
 
287
        :return: None
 
288
        """
 
289
        # GraphIndexBuilder itself doesn't pay attention to the flag yet, but
 
290
        # other builders do.
 
291
        self._optimize_for_size = for_size
 
292
 
281
293
 
282
294
class GraphIndex(object):
283
295
    """An index for data with embedded graphs.
366
378
        self._keys_by_offset = {}
367
379
        # ready-to-return key:value or key:value, node_ref_lists
368
380
        self._nodes = {}
369
 
        self._nodes_by_key = {}
 
381
        self._nodes_by_key = None
370
382
        trailers = 0
371
383
        pos = stream.tell()
372
384
        lines = stream.read().split('\n')
381
393
            else:
382
394
                node_value = value
383
395
            self._nodes[key] = node_value
384
 
            if self._key_length > 1:
385
 
                # TODO: We may want to do this lazily, but if we are calling
386
 
                #       _buffer_all, we are likely to be doing
387
 
                #       iter_entries_prefix
388
 
                key_dict = self._nodes_by_key
389
 
                if self.node_ref_lists:
390
 
                    key_value = key, node_value[0], node_value[1]
391
 
                else:
392
 
                    key_value = key, node_value
393
 
                # For a key of (foo, bar, baz) create
394
 
                # _nodes_by_key[foo][bar][baz] = key_value
395
 
                for subkey in key[:-1]:
396
 
                    key_dict = key_dict.setdefault(subkey, {})
397
 
                key_dict[key[-1]] = key_value
398
396
        # cache the keys for quick set intersections
399
397
        self._keys = set(self._nodes)
400
398
        if trailers != 1:
401
399
            # there must be one line - the empty trailer line.
402
400
            raise errors.BadIndexData(self)
403
401
 
 
402
    def _get_nodes_by_key(self):
 
403
        if self._nodes_by_key is None:
 
404
            nodes_by_key = {}
 
405
            if self.node_ref_lists:
 
406
                for key, (value, references) in self._nodes.iteritems():
 
407
                    key_dict = nodes_by_key
 
408
                    for subkey in key[:-1]:
 
409
                        key_dict = key_dict.setdefault(subkey, {})
 
410
                    key_dict[key[-1]] = key, value, references
 
411
            else:
 
412
                for key, value in self._nodes.iteritems():
 
413
                    key_dict = nodes_by_key
 
414
                    for subkey in key[:-1]:
 
415
                        key_dict = key_dict.setdefault(subkey, {})
 
416
                    key_dict[key[-1]] = key, value
 
417
            self._nodes_by_key = nodes_by_key
 
418
        return self._nodes_by_key
 
419
 
404
420
    def iter_all_entries(self):
405
421
        """Iterate over all keys within the index.
406
422
 
593
609
                else:
594
610
                    yield self, key, self._nodes[key]
595
611
            return
 
612
        nodes_by_key = self._get_nodes_by_key()
596
613
        for key in keys:
597
614
            # sanity check
598
615
            if key[0] is None:
600
617
            if len(key) != self._key_length:
601
618
                raise errors.BadIndexKey(key)
602
619
            # find what it refers to:
603
 
            key_dict = self._nodes_by_key
 
620
            key_dict = nodes_by_key
604
621
            elements = list(key)
605
622
            # find the subdict whose contents should be returned.
606
623
            try:
973
990
                raise errors.BadIndexData(self)
974
991
            # keys are tuples. Each element is a string that may occur many
975
992
            # times, so we intern them to save space. AB, RC, 200807
976
 
            key = tuple(intern(element) for element in elements[:self._key_length])
 
993
            key = tuple([intern(element) for element in elements[:self._key_length]])
977
994
            if first_key is None:
978
995
                first_key = key
979
996
            absent, references, value = elements[-3:]