/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/knit.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/knit.py
56
56
from itertools import izip
57
57
import operator
58
58
import os
59
 
import sys
60
59
 
61
60
from bzrlib.lazy_import import lazy_import
62
61
lazy_import(globals(), """
63
62
import gzip
64
63
 
65
64
from bzrlib import (
66
 
    annotate,
67
65
    debug,
68
66
    diff,
69
67
    graph as _mod_graph,
70
68
    index as _mod_index,
71
 
    lru_cache,
72
69
    pack,
73
70
    patiencediff,
74
 
    progress,
75
71
    static_tuple,
76
72
    trace,
77
73
    tsort,
78
74
    tuned_gzip,
79
75
    ui,
80
76
    )
 
77
 
 
78
from bzrlib.repofmt import pack_repo
81
79
""")
82
80
from bzrlib import (
 
81
    annotate,
83
82
    errors,
84
83
    osutils,
85
84
    )
98
97
    split_lines,
99
98
    )
100
99
from bzrlib.versionedfile import (
 
100
    _KeyRefs,
101
101
    AbsentContentFactory,
102
102
    adapter_registry,
103
103
    ConstantMapper,
104
104
    ContentFactory,
105
105
    sort_groupcompress,
106
 
    VersionedFiles,
 
106
    VersionedFilesWithFallbacks,
107
107
    )
108
108
 
109
109
 
801
801
        writer.begin()
802
802
        index = _KnitGraphIndex(graph_index, lambda:True, parents=parents,
803
803
            deltas=delta, add_callback=graph_index.add_nodes)
804
 
        access = _DirectPackAccess({})
 
804
        access = pack_repo._DirectPackAccess({})
805
805
        access.set_writer(writer, graph_index, (transport, 'newpack'))
806
806
        result = KnitVersionedFiles(index, access,
807
807
            max_delta_chain=max_delta_chain)
845
845
                in all_build_index_memos.itervalues()])
846
846
 
847
847
 
848
 
class KnitVersionedFiles(VersionedFiles):
 
848
class KnitVersionedFiles(VersionedFilesWithFallbacks):
849
849
    """Storage for many versioned files using knit compression.
850
850
 
851
851
    Backend storage is managed by indices and data objects.
887
887
            self._index,
888
888
            self._access)
889
889
 
 
890
    def without_fallbacks(self):
 
891
        """Return a clone of this object without any fallbacks configured."""
 
892
        return KnitVersionedFiles(self._index, self._access,
 
893
            self._max_delta_chain, self._factory.annotated,
 
894
            self._reload_func)
 
895
 
890
896
    def add_fallback_versioned_files(self, a_versioned_files):
891
897
        """Add a source of texts for texts not present in this knit.
892
898
 
1188
1194
        generator = _VFContentMapGenerator(self, [key])
1189
1195
        return generator._get_content(key)
1190
1196
 
1191
 
    def get_known_graph_ancestry(self, keys):
1192
 
        """Get a KnownGraph instance with the ancestry of keys."""
1193
 
        parent_map, missing_keys = self._index.find_ancestry(keys)
1194
 
        for fallback in self._transitive_fallbacks():
1195
 
            if not missing_keys:
1196
 
                break
1197
 
            (f_parent_map, f_missing_keys) = fallback._index.find_ancestry(
1198
 
                                                missing_keys)
1199
 
            parent_map.update(f_parent_map)
1200
 
            missing_keys = f_missing_keys
1201
 
        kg = _mod_graph.KnownGraph(parent_map)
1202
 
        return kg
1203
 
 
1204
1197
    def get_parent_map(self, keys):
1205
1198
        """Get a map of the graph parents of keys.
1206
1199
 
2782
2775
        return key[:-1], key[-1]
2783
2776
 
2784
2777
 
2785
 
class _KeyRefs(object):
2786
 
 
2787
 
    def __init__(self, track_new_keys=False):
2788
 
        # dict mapping 'key' to 'set of keys referring to that key'
2789
 
        self.refs = {}
2790
 
        if track_new_keys:
2791
 
            # set remembering all new keys
2792
 
            self.new_keys = set()
2793
 
        else:
2794
 
            self.new_keys = None
2795
 
 
2796
 
    def clear(self):
2797
 
        if self.refs:
2798
 
            self.refs.clear()
2799
 
        if self.new_keys:
2800
 
            self.new_keys.clear()
2801
 
 
2802
 
    def add_references(self, key, refs):
2803
 
        # Record the new references
2804
 
        for referenced in refs:
2805
 
            try:
2806
 
                needed_by = self.refs[referenced]
2807
 
            except KeyError:
2808
 
                needed_by = self.refs[referenced] = set()
2809
 
            needed_by.add(key)
2810
 
        # Discard references satisfied by the new key
2811
 
        self.add_key(key)
2812
 
 
2813
 
    def get_new_keys(self):
2814
 
        return self.new_keys
2815
 
    
2816
 
    def get_unsatisfied_refs(self):
2817
 
        return self.refs.iterkeys()
2818
 
 
2819
 
    def _satisfy_refs_for_key(self, key):
2820
 
        try:
2821
 
            del self.refs[key]
2822
 
        except KeyError:
2823
 
            # No keys depended on this key.  That's ok.
2824
 
            pass
2825
 
 
2826
 
    def add_key(self, key):
2827
 
        # satisfy refs for key, and remember that we've seen this key.
2828
 
        self._satisfy_refs_for_key(key)
2829
 
        if self.new_keys is not None:
2830
 
            self.new_keys.add(key)
2831
 
 
2832
 
    def satisfy_refs_for_keys(self, keys):
2833
 
        for key in keys:
2834
 
            self._satisfy_refs_for_key(key)
2835
 
 
2836
 
    def get_referrers(self):
2837
 
        result = set()
2838
 
        for referrers in self.refs.itervalues():
2839
 
            result.update(referrers)
2840
 
        return result
2841
 
 
2842
 
 
2843
2778
class _KnitGraphIndex(object):
2844
2779
    """A KnitVersionedFiles index layered on GraphIndex."""
2845
2780