← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/knit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-05-04 20:44:14 UTC
  • mfrom: (5807.2.2 inventory-tree-tests)
  • Revision ID: pqm@pqm.ubuntu.com-20110504204414-j893hspmx3k1rki4
(jelmer) Skip per_tree tests that are InventoryTree-specific if they're run
 against non-inventory trees. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/knit.py
103
103
    ConstantMapper,
104
104
    ContentFactory,
105
105
    sort_groupcompress,
106
 
    VersionedFilesWithFallbacks,
 
106
    VersionedFiles,
107
107
    )
108
108
 
109
109
 
408
408
class KnitContent(object):
409
409
    """Content of a knit version to which deltas can be applied.
410
410
 
411
 
    This is always stored in memory as a list of lines with \\n at the end,
 
411
    This is always stored in memory as a list of lines with \n at the end,
412
412
    plus a flag saying if the final ending is really there or not, because that
413
413
    corresponds to the on-disk knit representation.
414
414
    """
845
845
                in all_build_index_memos.itervalues()])
846
846
 
847
847
 
848
 
class KnitVersionedFiles(VersionedFilesWithFallbacks):
 
848
class KnitVersionedFiles(VersionedFiles):
849
849
    """Storage for many versioned files using knit compression.
850
850
 
851
851
    Backend storage is managed by indices and data objects.
887
887
            self._index,
888
888
            self._access)
889
889
 
890
 
    def without_fallbacks(self):
891
 
        """Return a clone of this object without any fallbacks configured."""
892
 
        return KnitVersionedFiles(self._index, self._access,
893
 
            self._max_delta_chain, self._factory.annotated,
894
 
            self._reload_func)
895
 
 
896
890
    def add_fallback_versioned_files(self, a_versioned_files):
897
891
        """Add a source of texts for texts not present in this knit.
898
892
 
1155
1149
 
1156
1150
        A dict of key to (record_details, index_memo, next, parents) is
1157
1151
        returned.
1158
 
 
1159
 
        * method is the way referenced data should be applied.
1160
 
        * index_memo is the handle to pass to the data access to actually get
1161
 
          the data
1162
 
        * next is the build-parent of the version, or None for fulltexts.
1163
 
        * parents is the version_ids of the parents of this version
1164
 
 
1165
 
        :param allow_missing: If True do not raise an error on a missing
1166
 
            component, just ignore it.
 
1152
        method is the way referenced data should be applied.
 
1153
        index_memo is the handle to pass to the data access to actually get the
 
1154
            data
 
1155
        next is the build-parent of the version, or None for fulltexts.
 
1156
        parents is the version_ids of the parents of this version
 
1157
 
 
1158
        :param allow_missing: If True do not raise an error on a missing component,
 
1159
            just ignore it.
1167
1160
        """
1168
1161
        component_data = {}
1169
1162
        pending_components = keys
1195
1188
        generator = _VFContentMapGenerator(self, [key])
1196
1189
        return generator._get_content(key)
1197
1190
 
 
1191
    def get_known_graph_ancestry(self, keys):
 
1192
        """Get a KnownGraph instance with the ancestry of keys."""
 
1193
        parent_map, missing_keys = self._index.find_ancestry(keys)
 
1194
        for fallback in self._transitive_fallbacks():
 
1195
            if not missing_keys:
 
1196
                break
 
1197
            (f_parent_map, f_missing_keys) = fallback._index.find_ancestry(
 
1198
                                                missing_keys)
 
1199
            parent_map.update(f_parent_map)
 
1200
            missing_keys = f_missing_keys
 
1201
        kg = _mod_graph.KnownGraph(parent_map)
 
1202
        return kg
 
1203
 
1198
1204
    def get_parent_map(self, keys):
1199
1205
        """Get a map of the graph parents of keys.
1200
1206
 
1231
1237
        """Produce a dictionary of knit records.
1232
1238
 
1233
1239
        :return: {key:(record, record_details, digest, next)}
1234
 
 
1235
 
            * record: data returned from read_records (a KnitContentobject)
1236
 
            * record_details: opaque information to pass to parse_record
1237
 
            * digest: SHA1 digest of the full text after all steps are done
1238
 
            * next: build-parent of the version, i.e. the leftmost ancestor.
 
1240
            record
 
1241
                data returned from read_records (a KnitContentobject)
 
1242
            record_details
 
1243
                opaque information to pass to parse_record
 
1244
            digest
 
1245
                SHA1 digest of the full text after all steps are done
 
1246
            next
 
1247
                build-parent of the version, i.e. the leftmost ancestor.
1239
1248
                Will be None if the record is not a delta.
1240
 
 
1241
1249
        :param keys: The keys to build a map for
1242
1250
        :param allow_missing: If some records are missing, rather than
1243
1251
            error, just return the data that could be generated.
1910
1918
        The result will be returned in whatever is the fastest to read.
1911
1919
        Not by the order requested. Also, multiple requests for the same
1912
1920
        record will only yield 1 response.
1913
 
 
1914
1921
        :param records: A list of (key, access_memo) entries
1915
1922
        :return: Yields (key, contents, digest) in the order
1916
1923
                 read, not the order requested
1974
1981
        :param key: The key of the record. Currently keys are always serialised
1975
1982
            using just the trailing component.
1976
1983
        :param dense_lines: The bytes of lines but in a denser form. For
1977
 
            instance, if lines is a list of 1000 bytestrings each ending in
1978
 
            \\n, dense_lines may be a list with one line in it, containing all
1979
 
            the 1000's lines and their \\n's. Using dense_lines if it is
1980
 
            already known is a win because the string join to create bytes in
1981
 
            this function spends less time resizing the final string.
 
1984
            instance, if lines is a list of 1000 bytestrings each ending in \n,
 
1985
            dense_lines may be a list with one line in it, containing all the
 
1986
            1000's lines and their \n's. Using dense_lines if it is already
 
1987
            known is a win because the string join to create bytes in this
 
1988
            function spends less time resizing the final string.
1982
1989
        :return: (len, a StringIO instance with the raw data ready to read.)
1983
1990
        """
1984
1991
        chunks = ["version %s %d %s\n" % (key[-1], len(lines), digest)]