← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-13 00:26:41 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101013002641-9tlh9k89mlj1666m
Keep docs-plain working.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
 
2
#
 
3
# Authors:
 
4
#   Johan Rydberg <jrydberg@gnu.org>
2
5
#
3
6
# This program is free software; you can redistribute it and/or modify
4
7
# it under the terms of the GNU General Public License as published by
28
31
 
29
32
from bzrlib import (
30
33
    annotate,
31
 
    bencode,
32
34
    errors,
33
35
    graph as _mod_graph,
34
36
    groupcompress,
38
40
    multiparent,
39
41
    tsort,
40
42
    revision,
 
43
    ui,
41
44
    )
 
45
from bzrlib.graph import DictParentsProvider, Graph, StackedParentsProvider
 
46
from bzrlib.transport.memory import MemoryTransport
42
47
""")
43
48
from bzrlib.registry import Registry
44
49
from bzrlib.textmerge import TextMerge
 
50
from bzrlib import bencode
45
51
 
46
52
 
47
53
adapter_registry = Registry()
924
930
 
925
931
    The use of tuples allows a single code base to support several different
926
932
    uses with only the mapping logic changing from instance to instance.
927
 
 
928
 
    :ivar _immediate_fallback_vfs: For subclasses that support stacking,
929
 
        this is a list of other VersionedFiles immediately underneath this
930
 
        one.  They may in turn each have further fallbacks.
931
933
    """
932
934
 
933
935
    def add_lines(self, key, parents, lines, parent_texts=None,
972
974
    def _add_text(self, key, parents, text, nostore_sha=None, random_id=False):
973
975
        """Add a text to the store.
974
976
 
975
 
        This is a private function for use by VersionedFileCommitBuilder.
 
977
        This is a private function for use by CommitBuilder.
976
978
 
977
979
        :param key: The key tuple of the text to add. If the last element is
978
980
            None, a CHK string will be generated during the addition.
1191
1193
    def _extract_blocks(self, version_id, source, target):
1192
1194
        return None
1193
1195
 
1194
 
    def _transitive_fallbacks(self):
1195
 
        """Return the whole stack of fallback versionedfiles.
1196
 
 
1197
 
        This VersionedFiles may have a list of fallbacks, but it doesn't
1198
 
        necessarily know about the whole stack going down, and it can't know
1199
 
        at open time because they may change after the objects are opened.
1200
 
        """
1201
 
        all_fallbacks = []
1202
 
        for a_vfs in self._immediate_fallback_vfs:
1203
 
            all_fallbacks.append(a_vfs)
1204
 
            all_fallbacks.extend(a_vfs._transitive_fallbacks())
1205
 
        return all_fallbacks
1206
 
 
1207
1196
 
1208
1197
class ThunkedVersionedFiles(VersionedFiles):
1209
1198
    """Storage for many versioned files thunked onto a 'VersionedFile' class.
1422
1411
        return result
1423
1412
 
1424
1413
 
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
1414
class _PlanMergeVersionedFile(VersionedFiles):
1453
1415
    """A VersionedFile for uncommitted and committed texts.
1454
1416
 
1475
1437
        # line data for locally held keys.
1476
1438
        self._lines = {}
1477
1439
        # key lookup providers
1478
 
        self._providers = [_mod_graph.DictParentsProvider(self._parents)]
 
1440
        self._providers = [DictParentsProvider(self._parents)]
1479
1441
 
1480
1442
    def plan_merge(self, ver_a, ver_b, base=None):
1481
1443
        """See VersionedFile.plan_merge"""
1488
1450
 
1489
1451
    def plan_lca_merge(self, ver_a, ver_b, base=None):
1490
1452
        from bzrlib.merge import _PlanLCAMerge
1491
 
        graph = _mod_graph.Graph(self)
 
1453
        graph = Graph(self)
1492
1454
        new_plan = _PlanLCAMerge(ver_a, ver_b, self, (self._file_id,), graph).plan_merge()
1493
1455
        if base is None:
1494
1456
            return new_plan
1546
1508
            result[revision.NULL_REVISION] = ()
1547
1509
        self._providers = self._providers[:1] + self.fallback_versionedfiles
1548
1510
        result.update(
1549
 
            _mod_graph.StackedParentsProvider(
1550
 
                self._providers).get_parent_map(keys))
 
1511
            StackedParentsProvider(self._providers).get_parent_map(keys))
1551
1512
        for key, parents in result.iteritems():
1552
1513
            if parents == ():
1553
1514
                result[key] = (revision.NULL_REVISION,)
1899
1860
    for prefix in sorted(per_prefix_map):
1900
1861
        present_keys.extend(reversed(tsort.topo_sort(per_prefix_map[prefix])))
1901
1862
    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