← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

(gz) Fix test failure on alpha by correcting format string for
 gc_chk_sha1_record (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
28
28
 
29
29
from bzrlib import (
30
30
    annotate,
31
 
    bencode,
32
31
    errors,
33
32
    graph as _mod_graph,
34
33
    groupcompress,
38
37
    multiparent,
39
38
    tsort,
40
39
    revision,
 
40
    ui,
41
41
    )
 
42
from bzrlib.graph import DictParentsProvider, Graph, StackedParentsProvider
 
43
from bzrlib.transport.memory import MemoryTransport
42
44
""")
43
45
from bzrlib.registry import Registry
44
46
from bzrlib.textmerge import TextMerge
 
47
from bzrlib import bencode
45
48
 
46
49
 
47
50
adapter_registry = Registry()
972
975
    def _add_text(self, key, parents, text, nostore_sha=None, random_id=False):
973
976
        """Add a text to the store.
974
977
 
975
 
        This is a private function for use by VersionedFileCommitBuilder.
 
978
        This is a private function for use by CommitBuilder.
976
979
 
977
980
        :param key: The key tuple of the text to add. If the last element is
978
981
            None, a CHK string will be generated during the addition.
1422
1425
        return result
1423
1426
 
1424
1427
 
1425
 
class VersionedFilesWithFallbacks(VersionedFiles):
1426
 
 
1427
 
    def without_fallbacks(self):
1428
 
        """Return a clone of this object without any fallbacks configured."""
1429
 
        raise NotImplementedError(self.without_fallbacks)
1430
 
 
1431
 
    def add_fallback_versioned_files(self, a_versioned_files):
1432
 
        """Add a source of texts for texts not present in this knit.
1433
 
 
1434
 
        :param a_versioned_files: A VersionedFiles object.
1435
 
        """
1436
 
        raise NotImplementedError(self.add_fallback_versioned_files)
1437
 
 
1438
 
    def get_known_graph_ancestry(self, keys):
1439
 
        """Get a KnownGraph instance with the ancestry of keys."""
1440
 
        parent_map, missing_keys = self._index.find_ancestry(keys)
1441
 
        for fallback in self._transitive_fallbacks():
1442
 
            if not missing_keys:
1443
 
                break
1444
 
            (f_parent_map, f_missing_keys) = fallback._index.find_ancestry(
1445
 
                                                missing_keys)
1446
 
            parent_map.update(f_parent_map)
1447
 
            missing_keys = f_missing_keys
1448
 
        kg = _mod_graph.KnownGraph(parent_map)
1449
 
        return kg
1450
 
 
1451
 
 
1452
1428
class _PlanMergeVersionedFile(VersionedFiles):
1453
1429
    """A VersionedFile for uncommitted and committed texts.
1454
1430
 
1475
1451
        # line data for locally held keys.
1476
1452
        self._lines = {}
1477
1453
        # key lookup providers
1478
 
        self._providers = [_mod_graph.DictParentsProvider(self._parents)]
 
1454
        self._providers = [DictParentsProvider(self._parents)]
1479
1455
 
1480
1456
    def plan_merge(self, ver_a, ver_b, base=None):
1481
1457
        """See VersionedFile.plan_merge"""
1488
1464
 
1489
1465
    def plan_lca_merge(self, ver_a, ver_b, base=None):
1490
1466
        from bzrlib.merge import _PlanLCAMerge
1491
 
        graph = _mod_graph.Graph(self)
 
1467
        graph = Graph(self)
1492
1468
        new_plan = _PlanLCAMerge(ver_a, ver_b, self, (self._file_id,), graph).plan_merge()
1493
1469
        if base is None:
1494
1470
            return new_plan
1546
1522
            result[revision.NULL_REVISION] = ()
1547
1523
        self._providers = self._providers[:1] + self.fallback_versionedfiles
1548
1524
        result.update(
1549
 
            _mod_graph.StackedParentsProvider(
1550
 
                self._providers).get_parent_map(keys))
 
1525
            StackedParentsProvider(self._providers).get_parent_map(keys))
1551
1526
        for key, parents in result.iteritems():
1552
1527
            if parents == ():
1553
1528
                result[key] = (revision.NULL_REVISION,)
1899
1874
    for prefix in sorted(per_prefix_map):
1900
1875
        present_keys.extend(reversed(tsort.topo_sort(per_prefix_map[prefix])))
1901
1876
    return present_keys
1902
 
 
1903
 
 
1904
 
class _KeyRefs(object):
1905
 
 
1906
 
    def __init__(self, track_new_keys=False):
1907
 
        # dict mapping 'key' to 'set of keys referring to that key'
1908
 
        self.refs = {}
1909
 
        if track_new_keys:
1910
 
            # set remembering all new keys
1911
 
            self.new_keys = set()
1912
 
        else:
1913
 
            self.new_keys = None
1914
 
 
1915
 
    def clear(self):
1916
 
        if self.refs:
1917
 
            self.refs.clear()
1918
 
        if self.new_keys:
1919
 
            self.new_keys.clear()
1920
 
 
1921
 
    def add_references(self, key, refs):
1922
 
        # Record the new references
1923
 
        for referenced in refs:
1924
 
            try:
1925
 
                needed_by = self.refs[referenced]
1926
 
            except KeyError:
1927
 
                needed_by = self.refs[referenced] = set()
1928
 
            needed_by.add(key)
1929
 
        # Discard references satisfied by the new key
1930
 
        self.add_key(key)
1931
 
 
1932
 
    def get_new_keys(self):
1933
 
        return self.new_keys
1934
 
    
1935
 
    def get_unsatisfied_refs(self):
1936
 
        return self.refs.iterkeys()
1937
 
 
1938
 
    def _satisfy_refs_for_key(self, key):
1939
 
        try:
1940
 
            del self.refs[key]
1941
 
        except KeyError:
1942
 
            # No keys depended on this key.  That's ok.
1943
 
            pass
1944
 
 
1945
 
    def add_key(self, key):
1946
 
        # satisfy refs for key, and remember that we've seen this key.
1947
 
        self._satisfy_refs_for_key(key)
1948
 
        if self.new_keys is not None:
1949
 
            self.new_keys.add(key)
1950
 
 
1951
 
    def satisfy_refs_for_keys(self, keys):
1952
 
        for key in keys:
1953
 
            self._satisfy_refs_for_key(key)
1954
 
 
1955
 
    def get_referrers(self):
1956
 
        result = set()
1957
 
        for referrers in self.refs.itervalues():
1958
 
            result.update(referrers)
1959
 
        return result
1960
 
 
1961
 
 
1962