← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: Jelmer Vernooij
  • Date: 2011-05-10 07:46:15 UTC
  • mfrom: (5844 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5845.
  • Revision ID: jelmer@samba.org-20110510074615-eptod049ndjxc4i7
Merge bzr.dev.

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,
31
32
    errors,
32
33
    graph as _mod_graph,
33
34
    groupcompress,
37
38
    multiparent,
38
39
    tsort,
39
40
    revision,
40
 
    ui,
41
41
    )
42
 
from bzrlib.graph import DictParentsProvider, Graph, StackedParentsProvider
43
 
from bzrlib.transport.memory import MemoryTransport
44
42
""")
45
43
from bzrlib.registry import Registry
46
44
from bzrlib.textmerge import TextMerge
47
 
from bzrlib import bencode
48
45
 
49
46
 
50
47
adapter_registry = Registry()
975
972
    def _add_text(self, key, parents, text, nostore_sha=None, random_id=False):
976
973
        """Add a text to the store.
977
974
 
978
 
        This is a private function for use by CommitBuilder.
 
975
        This is a private function for use by VersionedFileCommitBuilder.
979
976
 
980
977
        :param key: The key tuple of the text to add. If the last element is
981
978
            None, a CHK string will be generated during the addition.
1425
1422
        return result
1426
1423
 
1427
1424
 
 
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
 
1428
1439
class _PlanMergeVersionedFile(VersionedFiles):
1429
1440
    """A VersionedFile for uncommitted and committed texts.
1430
1441
 
1451
1462
        # line data for locally held keys.
1452
1463
        self._lines = {}
1453
1464
        # key lookup providers
1454
 
        self._providers = [DictParentsProvider(self._parents)]
 
1465
        self._providers = [_mod_graph.DictParentsProvider(self._parents)]
1455
1466
 
1456
1467
    def plan_merge(self, ver_a, ver_b, base=None):
1457
1468
        """See VersionedFile.plan_merge"""
1464
1475
 
1465
1476
    def plan_lca_merge(self, ver_a, ver_b, base=None):
1466
1477
        from bzrlib.merge import _PlanLCAMerge
1467
 
        graph = Graph(self)
 
1478
        graph = _mod_graph.Graph(self)
1468
1479
        new_plan = _PlanLCAMerge(ver_a, ver_b, self, (self._file_id,), graph).plan_merge()
1469
1480
        if base is None:
1470
1481
            return new_plan
1522
1533
            result[revision.NULL_REVISION] = ()
1523
1534
        self._providers = self._providers[:1] + self.fallback_versionedfiles
1524
1535
        result.update(
1525
 
            StackedParentsProvider(self._providers).get_parent_map(keys))
 
1536
            _mod_graph.StackedParentsProvider(
 
1537
                self._providers).get_parent_map(keys))
1526
1538
        for key, parents in result.iteritems():
1527
1539
            if parents == ():
1528
1540
                result[key] = (revision.NULL_REVISION,)
1874
1886
    for prefix in sorted(per_prefix_map):
1875
1887
        present_keys.extend(reversed(tsort.topo_sort(per_prefix_map[prefix])))
1876
1888
    return present_keys
 
1889
 
 
1890
 
 
1891
class _KeyRefs(object):
 
1892
 
 
1893
    def __init__(self, track_new_keys=False):
 
1894
        # dict mapping 'key' to 'set of keys referring to that key'
 
1895
        self.refs = {}
 
1896
        if track_new_keys:
 
1897
            # set remembering all new keys
 
1898
            self.new_keys = set()
 
1899
        else:
 
1900
            self.new_keys = None
 
1901
 
 
1902
    def clear(self):
 
1903
        if self.refs:
 
1904
            self.refs.clear()
 
1905
        if self.new_keys:
 
1906
            self.new_keys.clear()
 
1907
 
 
1908
    def add_references(self, key, refs):
 
1909
        # Record the new references
 
1910
        for referenced in refs:
 
1911
            try:
 
1912
                needed_by = self.refs[referenced]
 
1913
            except KeyError:
 
1914
                needed_by = self.refs[referenced] = set()
 
1915
            needed_by.add(key)
 
1916
        # Discard references satisfied by the new key
 
1917
        self.add_key(key)
 
1918
 
 
1919
    def get_new_keys(self):
 
1920
        return self.new_keys
 
1921
    
 
1922
    def get_unsatisfied_refs(self):
 
1923
        return self.refs.iterkeys()
 
1924
 
 
1925
    def _satisfy_refs_for_key(self, key):
 
1926
        try:
 
1927
            del self.refs[key]
 
1928
        except KeyError:
 
1929
            # No keys depended on this key.  That's ok.
 
1930
            pass
 
1931
 
 
1932
    def add_key(self, key):
 
1933
        # satisfy refs for key, and remember that we've seen this key.
 
1934
        self._satisfy_refs_for_key(key)
 
1935
        if self.new_keys is not None:
 
1936
            self.new_keys.add(key)
 
1937
 
 
1938
    def satisfy_refs_for_keys(self, keys):
 
1939
        for key in keys:
 
1940
            self._satisfy_refs_for_key(key)
 
1941
 
 
1942
    def get_referrers(self):
 
1943
        result = set()
 
1944
        for referrers in self.refs.itervalues():
 
1945
            result.update(referrers)
 
1946
        return result
 
1947
 
 
1948
 
 
1949