/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/versionedfile.py

  • Committer: Neil Martinsen-Burrell
  • Date: 2011-05-19 01:42:12 UTC
  • mfrom: (5876 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5899.
  • Revision ID: nmb@wartburg.edu-20110519014212-d48xtqqeauq164al
merge bzr.dev, fix release notes conflict

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
    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
 
1428
1452
class _PlanMergeVersionedFile(VersionedFiles):
1429
1453
    """A VersionedFile for uncommitted and committed texts.
1430
1454
 
1451
1475
        # line data for locally held keys.
1452
1476
        self._lines = {}
1453
1477
        # key lookup providers
1454
 
        self._providers = [DictParentsProvider(self._parents)]
 
1478
        self._providers = [_mod_graph.DictParentsProvider(self._parents)]
1455
1479
 
1456
1480
    def plan_merge(self, ver_a, ver_b, base=None):
1457
1481
        """See VersionedFile.plan_merge"""
1464
1488
 
1465
1489
    def plan_lca_merge(self, ver_a, ver_b, base=None):
1466
1490
        from bzrlib.merge import _PlanLCAMerge
1467
 
        graph = Graph(self)
 
1491
        graph = _mod_graph.Graph(self)
1468
1492
        new_plan = _PlanLCAMerge(ver_a, ver_b, self, (self._file_id,), graph).plan_merge()
1469
1493
        if base is None:
1470
1494
            return new_plan
1522
1546
            result[revision.NULL_REVISION] = ()
1523
1547
        self._providers = self._providers[:1] + self.fallback_versionedfiles
1524
1548
        result.update(
1525
 
            StackedParentsProvider(self._providers).get_parent_map(keys))
 
1549
            _mod_graph.StackedParentsProvider(
 
1550
                self._providers).get_parent_map(keys))
1526
1551
        for key, parents in result.iteritems():
1527
1552
            if parents == ():
1528
1553
                result[key] = (revision.NULL_REVISION,)
1874
1899
    for prefix in sorted(per_prefix_map):
1875
1900
        present_keys.extend(reversed(tsort.topo_sort(per_prefix_map[prefix])))
1876
1901
    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