← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/groupcompress.py

Abbreviate pack_stat struct format to '>6L'

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/groupcompress.py
39
39
    )
40
40
 
41
41
from bzrlib.repofmt import pack_repo
 
42
from bzrlib.i18n import gettext
42
43
""")
43
44
 
44
45
from bzrlib.btree_index import BTreeBuilder
466
467
                # Grab and cache the raw bytes for this entry
467
468
                # and break the ref-cycle with _manager since we don't need it
468
469
                # anymore
469
 
                self._manager._prepare_for_extract()
 
470
                try:
 
471
                    self._manager._prepare_for_extract()
 
472
                except zlib.error as value:
 
473
                    raise errors.DecompressCorruption("zlib: " + str(value))
470
474
                block = self._manager._block
471
475
                self._bytes = block.extract(self.key, self._start, self._end)
472
476
                # There are code paths that first extract as fulltext, and then
985
989
 
986
990
    It contains code very similar to SequenceMatcher because of having a similar
987
991
    task. However some key differences apply:
988
 
     - there is no junk, we want a minimal edit not a human readable diff.
989
 
     - we don't filter very common lines (because we don't know where a good
990
 
       range will start, and after the first text we want to be emitting minmal
991
 
       edits only.
992
 
     - we chain the left side, not the right side
993
 
     - we incrementally update the adjacency matrix as new lines are provided.
994
 
     - we look for matches in all of the left side, so the routine which does
995
 
       the analagous task of find_longest_match does not need to filter on the
996
 
       left side.
 
992
 
 
993
    * there is no junk, we want a minimal edit not a human readable diff.
 
994
    * we don't filter very common lines (because we don't know where a good
 
995
      range will start, and after the first text we want to be emitting minmal
 
996
      edits only.
 
997
    * we chain the left side, not the right side
 
998
    * we incrementally update the adjacency matrix as new lines are provided.
 
999
    * we look for matches in all of the left side, so the routine which does
 
1000
      the analagous task of find_longest_match does not need to filter on the
 
1001
      left side.
997
1002
    """
998
1003
 
999
1004
    def __init__(self, settings=None):
1255
1260
        :param key: The key tuple of the text to add.
1256
1261
        :param parents: The parents key tuples of the text to add.
1257
1262
        :param lines: A list of lines. Each line must be a bytestring. And all
1258
 
            of them except the last must be terminated with \n and contain no
1259
 
            other \n's. The last line may either contain no \n's or a single
1260
 
            terminating \n. If the lines list does meet this constraint the add
1261
 
            routine may error or may succeed - but you will be unable to read
1262
 
            the data back accurately. (Checking the lines have been split
 
1263
            of them except the last must be terminated with \\n and contain no
 
1264
            other \\n's. The last line may either contain no \\n's or a single
 
1265
            terminating \\n. If the lines list does meet this constraint the
 
1266
            add routine may error or may succeed - but you will be unable to
 
1267
            read the data back accurately. (Checking the lines have been split
1263
1268
            correctly is expensive and extremely unlikely to catch bugs so it
1264
1269
            is not done at runtime unless check_content is True.)
1265
1270
        :param parent_texts: An optional dictionary containing the opaque
1360
1365
            self._check_lines_not_unicode(lines)
1361
1366
            self._check_lines_are_lines(lines)
1362
1367
 
1363
 
    def get_known_graph_ancestry(self, keys):
1364
 
        """Get a KnownGraph instance with the ancestry of keys."""
1365
 
        # Note that this is identical to
1366
 
        # KnitVersionedFiles.get_known_graph_ancestry, but they don't share
1367
 
        # ancestry.
1368
 
        parent_map, missing_keys = self._index.find_ancestry(keys)
1369
 
        for fallback in self._transitive_fallbacks():
1370
 
            if not missing_keys:
1371
 
                break
1372
 
            (f_parent_map, f_missing_keys) = fallback._index.find_ancestry(
1373
 
                                                missing_keys)
1374
 
            parent_map.update(f_parent_map)
1375
 
            missing_keys = f_missing_keys
1376
 
        kg = _mod_graph.KnownGraph(parent_map)
1377
 
        return kg
1378
 
 
1379
1368
    def get_parent_map(self, keys):
1380
1369
        """Get a map of the graph parents of keys.
1381
1370
 
1519
1508
 
1520
1509
        The returned objects should be in the order defined by 'ordering',
1521
1510
        which can weave between different sources.
 
1511
 
1522
1512
        :param ordering: Must be one of 'topological' or 'groupcompress'
1523
1513
        :return: List of [(source, [keys])] tuples, such that all keys are in
1524
1514
            the defined order, regardless of source.
1765
1755
                raise errors.RevisionNotPresent(record.key, self)
1766
1756
            if random_id:
1767
1757
                if record.key in inserted_keys:
1768
 
                    trace.note('Insert claimed random_id=True,'
1769
 
                               ' but then inserted %r two times', record.key)
 
1758
                    trace.note(gettext('Insert claimed random_id=True,'
 
1759
                               ' but then inserted %r two times'), record.key)
1770
1760
                    continue
1771
1761
                inserted_keys.add(record.key)
1772
1762
            if reuse_blocks:
2146
2136
        :param keys: An iterable of keys.
2147
2137
        :return: A dict of key:
2148
2138
            (index_memo, compression_parent, parents, record_details).
2149
 
            index_memo
2150
 
                opaque structure to pass to read_records to extract the raw
2151
 
                data
2152
 
            compression_parent
2153
 
                Content that this record is built upon, may be None
2154
 
            parents
2155
 
                Logical parents of this node
2156
 
            record_details
2157
 
                extra information about the content which needs to be passed to
2158
 
                Factory.parse_record
 
2139
 
 
2140
            * index_memo: opaque structure to pass to read_records to extract
 
2141
              the raw data
 
2142
            * compression_parent: Content that this record is built upon, may
 
2143
              be None
 
2144
            * parents: Logical parents of this node
 
2145
            * record_details: extra information about the content which needs
 
2146
              to be passed to Factory.parse_record
2159
2147
        """
2160
2148
        self._check_read()
2161
2149
        result = {}