← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

* Deprecated method ``find_previous_heads`` on
  ``bzrlib.inventory.InventoryEntry``. This has been superceded by the use
  of ``parent_candidates`` and a separate heads check via the repository
  API. (Robert Collins)

* New public method ``heads`` on the ``bzrlib.graph.Graph`` class. This is
  a simple rename of a previously internal method which implements the same
  semantics as heads(). (Robert Collins, John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
50
50
    BzrCheckError,
51
51
    BzrError,
52
52
    )
 
53
from bzrlib.symbol_versioning import deprecated_method, zero_ninetyone
53
54
from bzrlib.trace import mutter
54
55
 
55
56
 
161
162
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
162
163
             output_to, reverse=False):
163
164
        """Perform a diff between two entries of the same kind."""
164
 
 
165
 
    def find_previous_heads(self, previous_inventories,
166
 
                            versioned_file_store,
167
 
                            transaction,
168
 
                            entry_vf=None):
169
 
        """Return the revisions and entries that directly precede this.
170
 
 
171
 
        Returned as a map from revision to inventory entry.
172
 
 
173
 
        This is a map containing the file revisions in all parents
174
 
        for which the file exists, and its revision is not a parent of
175
 
        any other. If the file is new, the set will be empty.
176
 
 
177
 
        :param versioned_file_store: A store where ancestry data on this
178
 
                                     file id can be queried.
179
 
        :param transaction: The transaction that queries to the versioned 
180
 
                            file store should be completed under.
181
 
        :param entry_vf: The entry versioned file, if its already available.
 
165
    
 
166
    def parent_candidates(self, previous_inventories):
 
167
        """Find possible per-file graph parents.
 
168
 
 
169
        This is currently defined by:
 
170
         - The kind has not changed (* not sure why this is a clause *)
 
171
         - Select the last changed revision in the parent inventory.
 
172
         - Do deal with a short lived bug in bzr 0.8's development two entries
 
173
           that have the same last changed but different 'x' bit settings are
 
174
           changed in-place.
182
175
        """
183
 
        def get_ancestors(weave, entry):
184
 
            return set(weave.get_ancestry(entry.revision, topo_sorted=False))
185
176
        # revision:ie mapping for each ie found in previous_inventories.
186
177
        candidates = {}
187
 
        # revision:ie mapping with one revision for each head.
188
 
        heads = {}
189
 
        # revision: ancestor list for each head
190
 
        head_ancestors = {}
191
178
        # identify candidate head revision ids.
192
179
        for inv in previous_inventories:
193
180
            if self.file_id in inv:
212
199
                else:
213
200
                    # add this revision as a candidate.
214
201
                    candidates[ie.revision] = ie
215
 
 
 
202
        return candidates
 
203
 
 
204
    @deprecated_method(zero_ninetyone)
 
205
    def find_previous_heads(self, previous_inventories,
 
206
                            versioned_file_store,
 
207
                            transaction,
 
208
                            entry_vf=None):
 
209
        """Return the revisions and entries that directly precede this.
 
210
 
 
211
        Returned as a map from revision to inventory entry.
 
212
 
 
213
        This is a map containing the file revisions in all parents
 
214
        for which the file exists, and its revision is not a parent of
 
215
        any other. If the file is new, the set will be empty.
 
216
 
 
217
        :param versioned_file_store: A store where ancestry data on this
 
218
                                     file id can be queried.
 
219
        :param transaction: The transaction that queries to the versioned 
 
220
                            file store should be completed under.
 
221
        :param entry_vf: The entry versioned file, if its already available.
 
222
        """
 
223
        candidates = self.parent_candidates(previous_inventories)
 
224
 
 
225
        # revision:ie mapping with one revision for each head.
 
226
        heads = {}
216
227
        # common case optimisation
217
228
        if len(candidates) == 1:
218
229
            # if there is only one candidate revision found
219
 
            # then we can opening the versioned file to access ancestry:
 
230
            # then we can avoid opening the versioned file to access ancestry:
220
231
            # there cannot be any ancestors to eliminate when there is 
221
232
            # only one revision available.
222
 
            heads[ie.revision] = ie
223
 
            return heads
 
233
            return candidates
 
234
        
 
235
        # --- what follows is now encapsulated in repository.get_graph.heads(), 
 
236
        #     but that is not accessible from here as we have no repository
 
237
        #     pointer. Note that the repository.get_graph.heads() call can return
 
238
        #     different results *at the moment* because of the kind-changing check
 
239
        #     we have in parent_candidates().
224
240
 
225
241
        # eliminate ancestors amongst the available candidates:
226
242
        # heads are those that are not an ancestor of any other candidate
227
243
        # - this provides convergence at a per-file level.
 
244
        def get_ancestors(weave, entry):
 
245
            return set(weave.get_ancestry(entry.revision, topo_sorted=False))
 
246
        # revision: ancestor list for each head
 
247
        head_ancestors = {}
228
248
        for ie in candidates.values():
229
249
            # may be an ancestor of a known head:
230
250
            already_present = 0 != len(