← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: John Arbash Meinel
  • Date: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
2
 
#
3
 
# Authors:
4
 
#   Johan Rydberg <jrydberg@gnu.org>
 
1
# Copyright (C) 2006-2011 Canonical Ltd
5
2
#
6
3
# This program is free software; you can redistribute it and/or modify
7
4
# it under the terms of the GNU General Public License as published by
31
28
 
32
29
from bzrlib import (
33
30
    annotate,
 
31
    bencode,
34
32
    errors,
35
33
    graph as _mod_graph,
36
34
    groupcompress,
40
38
    multiparent,
41
39
    tsort,
42
40
    revision,
43
 
    ui,
44
41
    )
45
 
from bzrlib.graph import DictParentsProvider, Graph, StackedParentsProvider
46
 
from bzrlib.transport.memory import MemoryTransport
47
42
""")
48
43
from bzrlib.registry import Registry
49
44
from bzrlib.textmerge import TextMerge
50
 
from bzrlib import bencode
51
45
 
52
46
 
53
47
adapter_registry = Registry()
930
924
 
931
925
    The use of tuples allows a single code base to support several different
932
926
    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.
933
931
    """
934
932
 
935
933
    def add_lines(self, key, parents, lines, parent_texts=None,
974
972
    def _add_text(self, key, parents, text, nostore_sha=None, random_id=False):
975
973
        """Add a text to the store.
976
974
 
977
 
        This is a private function for use by CommitBuilder.
 
975
        This is a private function for use by VersionedFileCommitBuilder.
978
976
 
979
977
        :param key: The key tuple of the text to add. If the last element is
980
978
            None, a CHK string will be generated during the addition.
1193
1191
    def _extract_blocks(self, version_id, source, target):
1194
1192
        return None
1195
1193
 
 
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
 
1196
1207
 
1197
1208
class ThunkedVersionedFiles(VersionedFiles):
1198
1209
    """Storage for many versioned files thunked onto a 'VersionedFile' class.
1411
1422
        return result
1412
1423
 
1413
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
 
1414
1439
class _PlanMergeVersionedFile(VersionedFiles):
1415
1440
    """A VersionedFile for uncommitted and committed texts.
1416
1441
 
1437
1462
        # line data for locally held keys.
1438
1463
        self._lines = {}
1439
1464
        # key lookup providers
1440
 
        self._providers = [DictParentsProvider(self._parents)]
 
1465
        self._providers = [_mod_graph.DictParentsProvider(self._parents)]
1441
1466
 
1442
1467
    def plan_merge(self, ver_a, ver_b, base=None):
1443
1468
        """See VersionedFile.plan_merge"""
1450
1475
 
1451
1476
    def plan_lca_merge(self, ver_a, ver_b, base=None):
1452
1477
        from bzrlib.merge import _PlanLCAMerge
1453
 
        graph = Graph(self)
 
1478
        graph = _mod_graph.Graph(self)
1454
1479
        new_plan = _PlanLCAMerge(ver_a, ver_b, self, (self._file_id,), graph).plan_merge()
1455
1480
        if base is None:
1456
1481
            return new_plan
1508
1533
            result[revision.NULL_REVISION] = ()
1509
1534
        self._providers = self._providers[:1] + self.fallback_versionedfiles
1510
1535
        result.update(
1511
 
            StackedParentsProvider(self._providers).get_parent_map(keys))
 
1536
            _mod_graph.StackedParentsProvider(
 
1537
                self._providers).get_parent_map(keys))
1512
1538
        for key, parents in result.iteritems():
1513
1539
            if parents == ():
1514
1540
                result[key] = (revision.NULL_REVISION,)
1860
1886
    for prefix in sorted(per_prefix_map):
1861
1887
        present_keys.extend(reversed(tsort.topo_sort(per_prefix_map[prefix])))
1862
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