50
44
# 2. Since len(['D', 'E']) > 1, find_lca('D', 'E') => ['A']
53
class DictParentsProvider(object):
54
"""A parents provider for Graph objects."""
56
def __init__(self, ancestry):
57
self.ancestry = ancestry
60
return 'DictParentsProvider(%r)' % self.ancestry
62
def get_parent_map(self, keys):
63
"""See StackedParentsProvider.get_parent_map"""
64
ancestry = self.ancestry
65
return dict((k, ancestry[k]) for k in keys if k in ancestry)
67
@deprecated_function(deprecated_in((1, 16, 0)))
68
def _StackedParentsProvider(*args, **kwargs):
69
return StackedParentsProvider(*args, **kwargs)
71
class StackedParentsProvider(object):
72
"""A parents provider which stacks (or unions) multiple providers.
74
The providers are queries in the order of the provided parent_providers.
48
class _StackedParentsProvider(object):
77
50
def __init__(self, parent_providers):
78
51
self._parent_providers = parent_providers
80
53
def __repr__(self):
81
return "%s(%r)" % (self.__class__.__name__, self._parent_providers)
83
def get_parent_map(self, keys):
84
"""Get a mapping of keys => parents
86
A dictionary is returned with an entry for each key present in this
87
source. If this source doesn't have information about a key, it should
54
return "_StackedParentsProvider(%r)" % self._parent_providers
56
def get_parents(self, revision_ids):
57
"""Find revision ids of the parents of a list of revisions
59
A list is returned of the same length as the input. Each entry
60
is a list of parent ids for the corresponding input revision.
90
62
[NULL_REVISION] is used as the parent of the first user-committed
91
63
revision. Its parent list is empty.
93
:param keys: An iterable returning keys to check (eg revision_ids)
94
:return: A dictionary mapping each key to its parents
65
If the revision is not present (i.e. a ghost), None is used in place
66
of the list of parents.
98
69
for parents_provider in self._parent_providers:
99
new_found = parents_provider.get_parent_map(remaining)
70
pending_revisions = [r for r in revision_ids if r not in found]
71
parent_list = parents_provider.get_parents(pending_revisions)
72
new_found = dict((k, v) for k, v in zip(pending_revisions,
73
parent_list) if v is not None)
100
74
found.update(new_found)
101
remaining.difference_update(new_found)
75
if len(found) == len(revision_ids):
107
class CachingParentsProvider(object):
108
"""A parents provider which will cache the revision => parents as a dict.
110
This is useful for providers which have an expensive look up.
112
Either a ParentsProvider or a get_parent_map-like callback may be
113
supplied. If it provides extra un-asked-for parents, they will be cached,
114
but filtered out of get_parent_map.
116
The cache is enabled by default, but may be disabled and re-enabled.
118
def __init__(self, parent_provider=None, get_parent_map=None):
121
:param parent_provider: The ParentProvider to use. It or
122
get_parent_map must be supplied.
123
:param get_parent_map: The get_parent_map callback to use. It or
124
parent_provider must be supplied.
126
self._real_provider = parent_provider
127
if get_parent_map is None:
128
self._get_parent_map = self._real_provider.get_parent_map
130
self._get_parent_map = get_parent_map
132
self.enable_cache(True)
135
return "%s(%r)" % (self.__class__.__name__, self._real_provider)
137
def enable_cache(self, cache_misses=True):
139
if self._cache is not None:
140
raise AssertionError('Cache enabled when already enabled.')
142
self._cache_misses = cache_misses
143
self.missing_keys = set()
145
def disable_cache(self):
146
"""Disable and clear the cache."""
148
self._cache_misses = None
149
self.missing_keys = set()
151
def get_cached_map(self):
152
"""Return any cached get_parent_map values."""
153
if self._cache is None:
155
return dict(self._cache)
157
def get_parent_map(self, keys):
158
"""See StackedParentsProvider.get_parent_map."""
161
cache = self._get_parent_map(keys)
163
needed_revisions = set(key for key in keys if key not in cache)
164
# Do not ask for negatively cached keys
165
needed_revisions.difference_update(self.missing_keys)
167
parent_map = self._get_parent_map(needed_revisions)
168
cache.update(parent_map)
169
if self._cache_misses:
170
for key in needed_revisions:
171
if key not in parent_map:
172
self.note_missing_key(key)
175
value = cache.get(key)
176
if value is not None:
180
def note_missing_key(self, key):
181
"""Note that key is a missing key."""
182
if self._cache_misses:
183
self.missing_keys.add(key)
77
return [found.get(r, None) for r in revision_ids]
186
80
class Graph(object):
252
142
def find_difference(self, left_revision, right_revision):
253
143
"""Determine the graph difference between two revisions"""
254
border, common, searchers = self._find_border_ancestors(
144
border, common, (left, right) = self._find_border_ancestors(
255
145
[left_revision, right_revision])
256
self._search_for_extra_common(common, searchers)
257
left = searchers[0].seen
258
right = searchers[1].seen
259
return (left.difference(right), right.difference(left))
261
def find_distance_to_null(self, target_revision_id, known_revision_ids):
262
"""Find the left-hand distance to the NULL_REVISION.
264
(This can also be considered the revno of a branch at
267
:param target_revision_id: A revision_id which we would like to know
269
:param known_revision_ids: [(revision_id, revno)] A list of known
270
revno, revision_id tuples. We'll use this to seed the search.
272
# Map from revision_ids to a known value for their revno
273
known_revnos = dict(known_revision_ids)
274
cur_tip = target_revision_id
276
NULL_REVISION = revision.NULL_REVISION
277
known_revnos[NULL_REVISION] = 0
279
searching_known_tips = list(known_revnos.keys())
281
unknown_searched = {}
283
while cur_tip not in known_revnos:
284
unknown_searched[cur_tip] = num_steps
286
to_search = set([cur_tip])
287
to_search.update(searching_known_tips)
288
parent_map = self.get_parent_map(to_search)
289
parents = parent_map.get(cur_tip, None)
290
if not parents: # An empty list or None is a ghost
291
raise errors.GhostRevisionsHaveNoRevno(target_revision_id,
295
for revision_id in searching_known_tips:
296
parents = parent_map.get(revision_id, None)
300
next_revno = known_revnos[revision_id] - 1
301
if next in unknown_searched:
302
# We have enough information to return a value right now
303
return next_revno + unknown_searched[next]
304
if next in known_revnos:
306
known_revnos[next] = next_revno
307
next_known_tips.append(next)
308
searching_known_tips = next_known_tips
310
# We reached a known revision, so just add in how many steps it took to
312
return known_revnos[cur_tip] + num_steps
314
def find_unique_ancestors(self, unique_revision, common_revisions):
315
"""Find the unique ancestors for a revision versus others.
317
This returns the ancestry of unique_revision, excluding all revisions
318
in the ancestry of common_revisions. If unique_revision is in the
319
ancestry, then the empty set will be returned.
321
:param unique_revision: The revision_id whose ancestry we are
323
XXX: Would this API be better if we allowed multiple revisions on
325
:param common_revisions: Revision_ids of ancestries to exclude.
326
:return: A set of revisions in the ancestry of unique_revision
328
if unique_revision in common_revisions:
331
# Algorithm description
332
# 1) Walk backwards from the unique node and all common nodes.
333
# 2) When a node is seen by both sides, stop searching it in the unique
334
# walker, include it in the common walker.
335
# 3) Stop searching when there are no nodes left for the unique walker.
336
# At this point, you have a maximal set of unique nodes. Some of
337
# them may actually be common, and you haven't reached them yet.
338
# 4) Start new searchers for the unique nodes, seeded with the
339
# information you have so far.
340
# 5) Continue searching, stopping the common searches when the search
341
# tip is an ancestor of all unique nodes.
342
# 6) Aggregate together unique searchers when they are searching the
343
# same tips. When all unique searchers are searching the same node,
344
# stop move it to a single 'all_unique_searcher'.
345
# 7) The 'all_unique_searcher' represents the very 'tip' of searching.
346
# Most of the time this produces very little important information.
347
# So don't step it as quickly as the other searchers.
348
# 8) Search is done when all common searchers have completed.
350
unique_searcher, common_searcher = self._find_initial_unique_nodes(
351
[unique_revision], common_revisions)
353
unique_nodes = unique_searcher.seen.difference(common_searcher.seen)
357
(all_unique_searcher,
358
unique_tip_searchers) = self._make_unique_searchers(unique_nodes,
359
unique_searcher, common_searcher)
361
self._refine_unique_nodes(unique_searcher, all_unique_searcher,
362
unique_tip_searchers, common_searcher)
363
true_unique_nodes = unique_nodes.difference(common_searcher.seen)
364
if 'graph' in debug.debug_flags:
365
trace.mutter('Found %d truly unique nodes out of %d',
366
len(true_unique_nodes), len(unique_nodes))
367
return true_unique_nodes
369
def _find_initial_unique_nodes(self, unique_revisions, common_revisions):
370
"""Steps 1-3 of find_unique_ancestors.
372
Find the maximal set of unique nodes. Some of these might actually
373
still be common, but we are sure that there are no other unique nodes.
375
:return: (unique_searcher, common_searcher)
378
unique_searcher = self._make_breadth_first_searcher(unique_revisions)
379
# we know that unique_revisions aren't in common_revisions, so skip
381
unique_searcher.next()
382
common_searcher = self._make_breadth_first_searcher(common_revisions)
384
# As long as we are still finding unique nodes, keep searching
385
while unique_searcher._next_query:
386
next_unique_nodes = set(unique_searcher.step())
387
next_common_nodes = set(common_searcher.step())
389
# Check if either searcher encounters new nodes seen by the other
391
unique_are_common_nodes = next_unique_nodes.intersection(
392
common_searcher.seen)
393
unique_are_common_nodes.update(
394
next_common_nodes.intersection(unique_searcher.seen))
395
if unique_are_common_nodes:
396
ancestors = unique_searcher.find_seen_ancestors(
397
unique_are_common_nodes)
398
# TODO: This is a bit overboard, we only really care about
399
# the ancestors of the tips because the rest we
400
# already know. This is *correct* but causes us to
401
# search too much ancestry.
402
ancestors.update(common_searcher.find_seen_ancestors(ancestors))
403
unique_searcher.stop_searching_any(ancestors)
404
common_searcher.start_searching(ancestors)
406
return unique_searcher, common_searcher
408
def _make_unique_searchers(self, unique_nodes, unique_searcher,
410
"""Create a searcher for all the unique search tips (step 4).
412
As a side effect, the common_searcher will stop searching any nodes
413
that are ancestors of the unique searcher tips.
415
:return: (all_unique_searcher, unique_tip_searchers)
417
unique_tips = self._remove_simple_descendants(unique_nodes,
418
self.get_parent_map(unique_nodes))
420
if len(unique_tips) == 1:
421
unique_tip_searchers = []
422
ancestor_all_unique = unique_searcher.find_seen_ancestors(unique_tips)
424
unique_tip_searchers = []
425
for tip in unique_tips:
426
revs_to_search = unique_searcher.find_seen_ancestors([tip])
427
revs_to_search.update(
428
common_searcher.find_seen_ancestors(revs_to_search))
429
searcher = self._make_breadth_first_searcher(revs_to_search)
430
# We don't care about the starting nodes.
431
searcher._label = tip
433
unique_tip_searchers.append(searcher)
435
ancestor_all_unique = None
436
for searcher in unique_tip_searchers:
437
if ancestor_all_unique is None:
438
ancestor_all_unique = set(searcher.seen)
440
ancestor_all_unique = ancestor_all_unique.intersection(
442
# Collapse all the common nodes into a single searcher
443
all_unique_searcher = self._make_breadth_first_searcher(
445
if ancestor_all_unique:
446
# We've seen these nodes in all the searchers, so we'll just go to
448
all_unique_searcher.step()
450
# Stop any search tips that are already known as ancestors of the
452
stopped_common = common_searcher.stop_searching_any(
453
common_searcher.find_seen_ancestors(ancestor_all_unique))
456
for searcher in unique_tip_searchers:
457
total_stopped += len(searcher.stop_searching_any(
458
searcher.find_seen_ancestors(ancestor_all_unique)))
459
if 'graph' in debug.debug_flags:
460
trace.mutter('For %d unique nodes, created %d + 1 unique searchers'
461
' (%d stopped search tips, %d common ancestors'
462
' (%d stopped common)',
463
len(unique_nodes), len(unique_tip_searchers),
464
total_stopped, len(ancestor_all_unique),
466
return all_unique_searcher, unique_tip_searchers
468
def _step_unique_and_common_searchers(self, common_searcher,
469
unique_tip_searchers,
471
"""Step all the searchers"""
472
newly_seen_common = set(common_searcher.step())
473
newly_seen_unique = set()
474
for searcher in unique_tip_searchers:
475
next = set(searcher.step())
476
next.update(unique_searcher.find_seen_ancestors(next))
477
next.update(common_searcher.find_seen_ancestors(next))
478
for alt_searcher in unique_tip_searchers:
479
if alt_searcher is searcher:
481
next.update(alt_searcher.find_seen_ancestors(next))
482
searcher.start_searching(next)
483
newly_seen_unique.update(next)
484
return newly_seen_common, newly_seen_unique
486
def _find_nodes_common_to_all_unique(self, unique_tip_searchers,
488
newly_seen_unique, step_all_unique):
489
"""Find nodes that are common to all unique_tip_searchers.
491
If it is time, step the all_unique_searcher, and add its nodes to the
494
common_to_all_unique_nodes = newly_seen_unique.copy()
495
for searcher in unique_tip_searchers:
496
common_to_all_unique_nodes.intersection_update(searcher.seen)
497
common_to_all_unique_nodes.intersection_update(
498
all_unique_searcher.seen)
499
# Step all-unique less frequently than the other searchers.
500
# In the common case, we don't need to spider out far here, so
501
# avoid doing extra work.
503
tstart = time.clock()
504
nodes = all_unique_searcher.step()
505
common_to_all_unique_nodes.update(nodes)
506
if 'graph' in debug.debug_flags:
507
tdelta = time.clock() - tstart
508
trace.mutter('all_unique_searcher step() took %.3fs'
509
'for %d nodes (%d total), iteration: %s',
510
tdelta, len(nodes), len(all_unique_searcher.seen),
511
all_unique_searcher._iterations)
512
return common_to_all_unique_nodes
514
def _collapse_unique_searchers(self, unique_tip_searchers,
515
common_to_all_unique_nodes):
516
"""Combine searchers that are searching the same tips.
518
When two searchers are searching the same tips, we can stop one of the
519
searchers. We also know that the maximal set of common ancestors is the
520
intersection of the two original searchers.
522
:return: A list of searchers that are searching unique nodes.
524
# Filter out searchers that don't actually search different
525
# nodes. We already have the ancestry intersection for them
526
unique_search_tips = {}
527
for searcher in unique_tip_searchers:
528
stopped = searcher.stop_searching_any(common_to_all_unique_nodes)
529
will_search_set = frozenset(searcher._next_query)
530
if not will_search_set:
531
if 'graph' in debug.debug_flags:
532
trace.mutter('Unique searcher %s was stopped.'
533
' (%s iterations) %d nodes stopped',
535
searcher._iterations,
537
elif will_search_set not in unique_search_tips:
538
# This searcher is searching a unique set of nodes, let it
539
unique_search_tips[will_search_set] = [searcher]
541
unique_search_tips[will_search_set].append(searcher)
542
# TODO: it might be possible to collapse searchers faster when they
543
# only have *some* search tips in common.
544
next_unique_searchers = []
545
for searchers in unique_search_tips.itervalues():
546
if len(searchers) == 1:
547
# Searching unique tips, go for it
548
next_unique_searchers.append(searchers[0])
550
# These searchers have started searching the same tips, we
551
# don't need them to cover the same ground. The
552
# intersection of their ancestry won't change, so create a
553
# new searcher, combining their histories.
554
next_searcher = searchers[0]
555
for searcher in searchers[1:]:
556
next_searcher.seen.intersection_update(searcher.seen)
557
if 'graph' in debug.debug_flags:
558
trace.mutter('Combining %d searchers into a single'
559
' searcher searching %d nodes with'
562
len(next_searcher._next_query),
563
len(next_searcher.seen))
564
next_unique_searchers.append(next_searcher)
565
return next_unique_searchers
567
def _refine_unique_nodes(self, unique_searcher, all_unique_searcher,
568
unique_tip_searchers, common_searcher):
569
"""Steps 5-8 of find_unique_ancestors.
571
This function returns when common_searcher has stopped searching for
574
# We step the ancestor_all_unique searcher only every
575
# STEP_UNIQUE_SEARCHER_EVERY steps.
576
step_all_unique_counter = 0
577
# While we still have common nodes to search
578
while common_searcher._next_query:
580
newly_seen_unique) = self._step_unique_and_common_searchers(
581
common_searcher, unique_tip_searchers, unique_searcher)
582
# These nodes are common ancestors of all unique nodes
583
common_to_all_unique_nodes = self._find_nodes_common_to_all_unique(
584
unique_tip_searchers, all_unique_searcher, newly_seen_unique,
585
step_all_unique_counter==0)
586
step_all_unique_counter = ((step_all_unique_counter + 1)
587
% STEP_UNIQUE_SEARCHER_EVERY)
589
if newly_seen_common:
590
# If a 'common' node is an ancestor of all unique searchers, we
591
# can stop searching it.
592
common_searcher.stop_searching_any(
593
all_unique_searcher.seen.intersection(newly_seen_common))
594
if common_to_all_unique_nodes:
595
common_to_all_unique_nodes.update(
596
common_searcher.find_seen_ancestors(
597
common_to_all_unique_nodes))
598
# The all_unique searcher can start searching the common nodes
599
# but everyone else can stop.
600
# This is the sort of thing where we would like to not have it
601
# start_searching all of the nodes, but only mark all of them
602
# as seen, and have it search only the actual tips. Otherwise
603
# it is another get_parent_map() traversal for it to figure out
604
# what we already should know.
605
all_unique_searcher.start_searching(common_to_all_unique_nodes)
606
common_searcher.stop_searching_any(common_to_all_unique_nodes)
608
next_unique_searchers = self._collapse_unique_searchers(
609
unique_tip_searchers, common_to_all_unique_nodes)
610
if len(unique_tip_searchers) != len(next_unique_searchers):
611
if 'graph' in debug.debug_flags:
612
trace.mutter('Collapsed %d unique searchers => %d'
614
len(unique_tip_searchers),
615
len(next_unique_searchers),
616
all_unique_searcher._iterations)
617
unique_tip_searchers = next_unique_searchers
619
def get_parent_map(self, revisions):
620
"""Get a map of key:parent_list for revisions.
622
This implementation delegates to get_parents, for old parent_providers
623
that do not supply get_parent_map.
626
for rev, parents in self.get_parents(revisions):
627
if parents is not None:
628
result[rev] = parents
146
return (left.difference(right).difference(common),
147
right.difference(left).difference(common))
631
149
def _make_breadth_first_searcher(self, revisions):
632
150
return _BreadthFirstSearcher(revisions, self)
648
166
if None in revisions:
649
167
raise errors.InvalidRevisionId(None, self)
168
common_searcher = self._make_breadth_first_searcher([])
650
169
common_ancestors = set()
651
170
searchers = [self._make_breadth_first_searcher([r])
652
171
for r in revisions]
653
172
active_searchers = searchers[:]
654
173
border_ancestors = set()
174
def update_common(searcher, revisions):
175
w_seen_ancestors = searcher.find_seen_ancestors(
177
stopped = searcher.stop_searching_any(w_seen_ancestors)
178
common_ancestors.update(w_seen_ancestors)
179
common_searcher.start_searching(stopped)
182
if len(active_searchers) == 0:
183
return border_ancestors, common_ancestors, [s.seen for s in
186
new_common = common_searcher.next()
187
common_ancestors.update(new_common)
188
except StopIteration:
191
for searcher in active_searchers:
192
for revision in new_common.intersection(searcher.seen):
193
update_common(searcher, revision)
657
195
newly_seen = set()
658
for searcher in searchers:
659
new_ancestors = searcher.step()
661
newly_seen.update(new_ancestors)
196
new_active_searchers = []
197
for searcher in active_searchers:
199
newly_seen.update(searcher.next())
200
except StopIteration:
203
new_active_searchers.append(searcher)
204
active_searchers = new_active_searchers
663
205
for revision in newly_seen:
664
206
if revision in common_ancestors:
665
# Not a border ancestor because it was seen as common
667
new_common.add(revision)
207
for searcher in searchers:
208
update_common(searcher, revision)
669
210
for searcher in searchers:
670
211
if revision not in searcher.seen:
673
# This is a border because it is a first common that we see
674
# after walking for a while.
675
214
border_ancestors.add(revision)
676
new_common.add(revision)
678
for searcher in searchers:
679
new_common.update(searcher.find_seen_ancestors(new_common))
680
for searcher in searchers:
681
searcher.start_searching(new_common)
682
common_ancestors.update(new_common)
684
# Figure out what the searchers will be searching next, and if
685
# there is only 1 set being searched, then we are done searching,
686
# since all searchers would have to be searching the same data,
687
# thus it *must* be in common.
688
unique_search_sets = set()
689
for searcher in searchers:
690
will_search_set = frozenset(searcher._next_query)
691
if will_search_set not in unique_search_sets:
692
# This searcher is searching a unique set of nodes, let it
693
unique_search_sets.add(will_search_set)
695
if len(unique_search_sets) == 1:
696
nodes = unique_search_sets.pop()
697
uncommon_nodes = nodes.difference(common_ancestors)
699
raise AssertionError("Somehow we ended up converging"
700
" without actually marking them as"
703
"\nuncommon_nodes: %s"
704
% (revisions, uncommon_nodes))
706
return border_ancestors, common_ancestors, searchers
215
for searcher in searchers:
216
update_common(searcher, revision)
708
218
def heads(self, keys):
709
219
"""Return the heads from amongst keys.
758
249
# a descendant of another candidate.
761
ancestors.update(searcher.next())
252
ancestors = searcher.next()
762
253
except StopIteration:
763
254
del active_searchers[candidate]
765
# process found nodes
767
for ancestor in ancestors:
768
if ancestor in candidate_heads:
769
candidate_heads.remove(ancestor)
770
del searchers[ancestor]
771
if ancestor in active_searchers:
772
del active_searchers[ancestor]
773
# it may meet up with a known common node
774
if ancestor in common_walker.seen:
775
# some searcher has encountered our known common nodes:
777
ancestor_set = set([ancestor])
778
for searcher in searchers.itervalues():
779
searcher.stop_searching_any(ancestor_set)
781
# or it may have been just reached by all the searchers:
256
for ancestor in ancestors:
257
if ancestor in candidate_heads:
258
candidate_heads.remove(ancestor)
259
del searchers[ancestor]
260
if ancestor in active_searchers:
261
del active_searchers[ancestor]
782
262
for searcher in searchers.itervalues():
783
263
if ancestor not in searcher.seen:
786
# The final active searcher has just reached this node,
787
# making it be known as a descendant of all candidates,
788
# so we can stop searching it, and any seen ancestors
789
new_common.add(ancestor)
266
# if this revision was seen by all searchers, then it
267
# is a descendant of all candidates, so we can stop
268
# searching it, and any seen ancestors
790
269
for searcher in searchers.itervalues():
791
270
seen_ancestors =\
792
searcher.find_seen_ancestors([ancestor])
271
searcher.find_seen_ancestors(ancestor)
793
272
searcher.stop_searching_any(seen_ancestors)
794
common_walker.start_searching(new_common)
795
273
return candidate_heads
797
def find_merge_order(self, tip_revision_id, lca_revision_ids):
798
"""Find the order that each revision was merged into tip.
800
This basically just walks backwards with a stack, and walks left-first
801
until it finds a node to stop.
803
if len(lca_revision_ids) == 1:
804
return list(lca_revision_ids)
805
looking_for = set(lca_revision_ids)
806
# TODO: Is there a way we could do this "faster" by batching up the
807
# get_parent_map requests?
808
# TODO: Should we also be culling the ancestry search right away? We
809
# could add looking_for to the "stop" list, and walk their
810
# ancestry in batched mode. The flip side is it might mean we walk a
811
# lot of "stop" nodes, rather than only the minimum.
812
# Then again, without it we may trace back into ancestry we could have
814
stack = [tip_revision_id]
817
while stack and looking_for:
820
if next in looking_for:
822
looking_for.remove(next)
823
if len(looking_for) == 1:
824
found.append(looking_for.pop())
827
parent_ids = self.get_parent_map([next]).get(next, None)
828
if not parent_ids: # Ghost, nothing to search here
830
for parent_id in reversed(parent_ids):
831
# TODO: (performance) We see the parent at this point, but we
832
# wait to mark it until later to make sure we get left
833
# parents before right parents. However, instead of
834
# waiting until we have traversed enough parents, we
835
# could instead note that we've found it, and once all
836
# parents are in the stack, just reverse iterate the
838
if parent_id not in stop:
839
# this will need to be searched
840
stack.append(parent_id)
844
def find_unique_lca(self, left_revision, right_revision,
275
def find_unique_lca(self, left_revision, right_revision):
846
276
"""Find a unique LCA.
848
278
Find lowest common ancestors. If there is no unique common
905
300
An ancestor may sort after a descendant if the relationship is not
906
301
visible in the supplied list of revisions.
908
sorter = tsort.TopoSorter(self.get_parent_map(revisions))
303
sorter = tsort.TopoSorter(zip(revisions, self.get_parents(revisions)))
909
304
return sorter.iter_topo_order()
911
306
def is_ancestor(self, candidate_ancestor, candidate_descendant):
912
307
"""Determine whether a revision is an ancestor of another.
914
We answer this using heads() as heads() has the logic to perform the
915
smallest number of parent lookups to determine the ancestral
916
relationship between N revisions.
918
return set([candidate_descendant]) == self.heads(
919
[candidate_ancestor, candidate_descendant])
921
def is_between(self, revid, lower_bound_revid, upper_bound_revid):
922
"""Determine whether a revision is between two others.
924
returns true if and only if:
925
lower_bound_revid <= revid <= upper_bound_revid
927
return ((upper_bound_revid is None or
928
self.is_ancestor(revid, upper_bound_revid)) and
929
(lower_bound_revid is None or
930
self.is_ancestor(lower_bound_revid, revid)))
932
def _search_for_extra_common(self, common, searchers):
933
"""Make sure that unique nodes are genuinely unique.
935
After _find_border_ancestors, all nodes marked "common" are indeed
936
common. Some of the nodes considered unique are not, due to history
937
shortcuts stopping the searches early.
939
We know that we have searched enough when all common search tips are
940
descended from all unique (uncommon) nodes because we know that a node
941
cannot be an ancestor of its own ancestor.
943
:param common: A set of common nodes
944
:param searchers: The searchers returned from _find_border_ancestors
948
# A) The passed in searchers should all be on the same tips, thus
949
# they should be considered the "common" searchers.
950
# B) We find the difference between the searchers, these are the
951
# "unique" nodes for each side.
952
# C) We do a quick culling so that we only start searching from the
953
# more interesting unique nodes. (A unique ancestor is more
954
# interesting than any of its children.)
955
# D) We start searching for ancestors common to all unique nodes.
956
# E) We have the common searchers stop searching any ancestors of
958
# F) When there are no more common search tips, we stop
960
# TODO: We need a way to remove unique_searchers when they overlap with
961
# other unique searchers.
962
if len(searchers) != 2:
963
raise NotImplementedError(
964
"Algorithm not yet implemented for > 2 searchers")
965
common_searchers = searchers
966
left_searcher = searchers[0]
967
right_searcher = searchers[1]
968
unique = left_searcher.seen.symmetric_difference(right_searcher.seen)
969
if not unique: # No unique nodes, nothing to do
971
total_unique = len(unique)
972
unique = self._remove_simple_descendants(unique,
973
self.get_parent_map(unique))
974
simple_unique = len(unique)
976
unique_searchers = []
977
for revision_id in unique:
978
if revision_id in left_searcher.seen:
979
parent_searcher = left_searcher
981
parent_searcher = right_searcher
982
revs_to_search = parent_searcher.find_seen_ancestors([revision_id])
983
if not revs_to_search: # XXX: This shouldn't be possible
984
revs_to_search = [revision_id]
985
searcher = self._make_breadth_first_searcher(revs_to_search)
986
# We don't care about the starting nodes.
988
unique_searchers.append(searcher)
990
# possible todo: aggregate the common searchers into a single common
991
# searcher, just make sure that we include the nodes into the .seen
992
# properties of the original searchers
994
ancestor_all_unique = None
995
for searcher in unique_searchers:
996
if ancestor_all_unique is None:
997
ancestor_all_unique = set(searcher.seen)
999
ancestor_all_unique = ancestor_all_unique.intersection(
1002
trace.mutter('Started %s unique searchers for %s unique revisions',
1003
simple_unique, total_unique)
1005
while True: # If we have no more nodes we have nothing to do
1006
newly_seen_common = set()
1007
for searcher in common_searchers:
1008
newly_seen_common.update(searcher.step())
1009
newly_seen_unique = set()
1010
for searcher in unique_searchers:
1011
newly_seen_unique.update(searcher.step())
1012
new_common_unique = set()
1013
for revision in newly_seen_unique:
1014
for searcher in unique_searchers:
1015
if revision not in searcher.seen:
1018
# This is a border because it is a first common that we see
1019
# after walking for a while.
1020
new_common_unique.add(revision)
1021
if newly_seen_common:
1022
# These are nodes descended from one of the 'common' searchers.
1023
# Make sure all searchers are on the same page
1024
for searcher in common_searchers:
1025
newly_seen_common.update(
1026
searcher.find_seen_ancestors(newly_seen_common))
1027
# We start searching the whole ancestry. It is a bit wasteful,
1028
# though. We really just want to mark all of these nodes as
1029
# 'seen' and then start just the tips. However, it requires a
1030
# get_parent_map() call to figure out the tips anyway, and all
1031
# redundant requests should be fairly fast.
1032
for searcher in common_searchers:
1033
searcher.start_searching(newly_seen_common)
1035
# If a 'common' node is an ancestor of all unique searchers, we
1036
# can stop searching it.
1037
stop_searching_common = ancestor_all_unique.intersection(
1039
if stop_searching_common:
1040
for searcher in common_searchers:
1041
searcher.stop_searching_any(stop_searching_common)
1042
if new_common_unique:
1043
# We found some ancestors that are common
1044
for searcher in unique_searchers:
1045
new_common_unique.update(
1046
searcher.find_seen_ancestors(new_common_unique))
1047
# Since these are common, we can grab another set of ancestors
1049
for searcher in common_searchers:
1050
new_common_unique.update(
1051
searcher.find_seen_ancestors(new_common_unique))
1053
# We can tell all of the unique searchers to start at these
1054
# nodes, and tell all of the common searchers to *stop*
1055
# searching these nodes
1056
for searcher in unique_searchers:
1057
searcher.start_searching(new_common_unique)
1058
for searcher in common_searchers:
1059
searcher.stop_searching_any(new_common_unique)
1060
ancestor_all_unique.update(new_common_unique)
1062
# Filter out searchers that don't actually search different
1063
# nodes. We already have the ancestry intersection for them
1064
next_unique_searchers = []
1065
unique_search_sets = set()
1066
for searcher in unique_searchers:
1067
will_search_set = frozenset(searcher._next_query)
1068
if will_search_set not in unique_search_sets:
1069
# This searcher is searching a unique set of nodes, let it
1070
unique_search_sets.add(will_search_set)
1071
next_unique_searchers.append(searcher)
1072
unique_searchers = next_unique_searchers
1073
for searcher in common_searchers:
1074
if searcher._next_query:
1077
# All common searcher have stopped searching
1080
def _remove_simple_descendants(self, revisions, parent_map):
1081
"""remove revisions which are children of other ones in the set
1083
This doesn't do any graph searching, it just checks the immediate
1084
parent_map to find if there are any children which can be removed.
1086
:param revisions: A set of revision_ids
1087
:return: A set of revision_ids with the children removed
1089
simple_ancestors = revisions.copy()
1090
# TODO: jam 20071214 we *could* restrict it to searching only the
1091
# parent_map of revisions already present in 'revisions', but
1092
# considering the general use case, I think this is actually
1095
# This is the same as the following loop. I don't know that it is any
1097
## simple_ancestors.difference_update(r for r, p_ids in parent_map.iteritems()
1098
## if p_ids is not None and revisions.intersection(p_ids))
1099
## return simple_ancestors
1101
# Yet Another Way, invert the parent map (which can be cached)
1103
## for revision_id, parent_ids in parent_map.iteritems():
1104
## for p_id in parent_ids:
1105
## descendants.setdefault(p_id, []).append(revision_id)
1106
## for revision in revisions.intersection(descendants):
1107
## simple_ancestors.difference_update(descendants[revision])
1108
## return simple_ancestors
1109
for revision, parent_ids in parent_map.iteritems():
1110
if parent_ids is None:
1112
for parent_id in parent_ids:
1113
if parent_id in revisions:
1114
# This node has a parent present in the set, so we can
1116
simple_ancestors.discard(revision)
1118
return simple_ancestors
1121
class HeadsCache(object):
1122
"""A cache of results for graph heads calls."""
1124
def __init__(self, graph):
1128
def heads(self, keys):
1129
"""Return the heads of keys.
1131
This matches the API of Graph.heads(), specifically the return value is
1132
a set which can be mutated, and ordering of the input is not preserved
1135
:see also: Graph.heads.
1136
:param keys: The keys to calculate heads for.
1137
:return: A set containing the heads, which may be mutated without
1138
affecting future lookups.
1140
keys = frozenset(keys)
1142
return set(self._heads[keys])
1144
heads = self.graph.heads(keys)
1145
self._heads[keys] = heads
1149
class FrozenHeadsCache(object):
1150
"""Cache heads() calls, assuming the caller won't modify them."""
1152
def __init__(self, graph):
1156
def heads(self, keys):
1157
"""Return the heads of keys.
1159
Similar to Graph.heads(). The main difference is that the return value
1160
is a frozen set which cannot be mutated.
1162
:see also: Graph.heads.
1163
:param keys: The keys to calculate heads for.
1164
:return: A frozenset containing the heads.
1166
keys = frozenset(keys)
1168
return self._heads[keys]
1170
heads = frozenset(self.graph.heads(keys))
1171
self._heads[keys] = heads
1174
def cache(self, keys, heads):
1175
"""Store a known value."""
1176
self._heads[frozenset(keys)] = frozenset(heads)
309
There are two possible outcomes: True and False, but there are three
310
possible relationships:
312
a) candidate_ancestor is an ancestor of candidate_descendant
313
b) candidate_ancestor is an descendant of candidate_descendant
314
c) candidate_ancestor is an sibling of candidate_descendant
316
To check for a, we walk from candidate_descendant, looking for
319
To check for b, we walk from candidate_ancestor, looking for
320
candidate_descendant.
322
To make a and b more efficient, we can stop any searches that hit
325
If we exhaust our searches, but neither a or b is true, then c is true.
327
In order to find c efficiently, we must avoid searching from
328
candidate_descendant or candidate_ancestor into common ancestors. But
329
if we don't search common ancestors at all, we won't know if we hit
330
common ancestors. So we have a walker for common ancestors. Note that
331
its searches are not required to terminate in order to determine c to
334
ancestor_walker = self._make_breadth_first_searcher(
335
[candidate_ancestor])
336
descendant_walker = self._make_breadth_first_searcher(
337
[candidate_descendant])
338
common_walker = self._make_breadth_first_searcher([])
339
active_ancestor = True
340
active_descendant = True
341
while (active_ancestor or active_descendant):
343
if active_descendant:
345
nodes = descendant_walker.next()
346
except StopIteration:
347
active_descendant = False
349
if candidate_ancestor in nodes:
351
new_common.update(nodes.intersection(ancestor_walker.seen))
354
nodes = ancestor_walker.next()
355
except StopIteration:
356
active_ancestor = False
358
if candidate_descendant in nodes:
360
new_common.update(nodes.intersection(
361
descendant_walker.seen))
363
new_common.update(common_walker.next())
364
except StopIteration:
366
for walker in (ancestor_walker, descendant_walker):
367
for node in new_common:
368
c_ancestors = walker.find_seen_ancestors(node)
369
walker.stop_searching_any(c_ancestors)
370
common_walker.start_searching(new_common)
1179
374
class _BreadthFirstSearcher(object):
1180
"""Parallel search breadth-first the ancestry of revisions.
375
"""Parallel search the breadth-first the ancestry of revisions.
1182
377
This class implements the iterator protocol, but additionally
1183
378
1. provides a set of seen ancestors, and
1187
382
def __init__(self, revisions, parents_provider):
1188
self._iterations = 0
1189
self._next_query = set(revisions)
1191
self._started_keys = set(self._next_query)
1192
self._stopped_keys = set()
1193
self._parents_provider = parents_provider
1194
self._returning = 'next_with_ghosts'
1195
self._current_present = set()
1196
self._current_ghosts = set()
1197
self._current_parents = {}
383
self._start = set(revisions)
384
self._search_revisions = None
385
self.seen = set(revisions)
386
self._parents_provider = parents_provider
1199
388
def __repr__(self):
1200
if self._iterations:
1201
prefix = "searching"
1204
search = '%s=%r' % (prefix, list(self._next_query))
1205
return ('_BreadthFirstSearcher(iterations=%d, %s,'
1206
' seen=%r)' % (self._iterations, search, list(self.seen)))
1208
def get_result(self):
1209
"""Get a SearchResult for the current state of this searcher.
1211
:return: A SearchResult for this search so far. The SearchResult is
1212
static - the search can be advanced and the search result will not
1213
be invalidated or altered.
1215
if self._returning == 'next':
1216
# We have to know the current nodes children to be able to list the
1217
# exclude keys for them. However, while we could have a second
1218
# look-ahead result buffer and shuffle things around, this method
1219
# is typically only called once per search - when memoising the
1220
# results of the search.
1221
found, ghosts, next, parents = self._do_query(self._next_query)
1222
# pretend we didn't query: perhaps we should tweak _do_query to be
1223
# entirely stateless?
1224
self.seen.difference_update(next)
1225
next_query = next.union(ghosts)
1227
next_query = self._next_query
1228
excludes = self._stopped_keys.union(next_query)
1229
included_keys = self.seen.difference(excludes)
1230
return SearchResult(self._started_keys, excludes, len(included_keys),
1236
except StopIteration:
389
return ('_BreadthFirstSearcher(self._search_revisions=%r,'
390
' self.seen=%r)' % (self._search_revisions, self.seen))
1240
393
"""Return the next ancestors of this revision.
1242
395
Ancestors are returned in the order they are seen in a breadth-first
1243
traversal. No ancestor will be returned more than once. Ancestors are
1244
returned before their parentage is queried, so ghosts and missing
1245
revisions (including the start revisions) are included in the result.
1246
This can save a round trip in LCA style calculation by allowing
1247
convergence to be detected without reading the data for the revision
1248
the convergence occurs on.
1250
:return: A set of revision_ids.
396
traversal. No ancestor will be returned more than once.
1252
if self._returning != 'next':
1253
# switch to returning the query, not the results.
1254
self._returning = 'next'
1255
self._iterations += 1
398
if self._search_revisions is None:
399
self._search_revisions = self._start
1258
if len(self._next_query) == 0:
1259
raise StopIteration()
1260
# We have seen what we're querying at this point as we are returning
1261
# the query, not the results.
1262
self.seen.update(self._next_query)
1263
return self._next_query
1265
def next_with_ghosts(self):
1266
"""Return the next found ancestors, with ghosts split out.
1268
Ancestors are returned in the order they are seen in a breadth-first
1269
traversal. No ancestor will be returned more than once. Ancestors are
1270
returned only after asking for their parents, which allows us to detect
1271
which revisions are ghosts and which are not.
1273
:return: A tuple with (present ancestors, ghost ancestors) sets.
1275
if self._returning != 'next_with_ghosts':
1276
# switch to returning the results, not the current query.
1277
self._returning = 'next_with_ghosts'
1279
if len(self._next_query) == 0:
1280
raise StopIteration()
1282
return self._current_present, self._current_ghosts
1285
"""Advance the search.
1287
Updates self.seen, self._next_query, self._current_present,
1288
self._current_ghosts, self._current_parents and self._iterations.
1290
self._iterations += 1
1291
found, ghosts, next, parents = self._do_query(self._next_query)
1292
self._current_present = found
1293
self._current_ghosts = ghosts
1294
self._next_query = next
1295
self._current_parents = parents
1296
# ghosts are implicit stop points, otherwise the search cannot be
1297
# repeated when ghosts are filled.
1298
self._stopped_keys.update(ghosts)
1300
def _do_query(self, revisions):
1301
"""Query for revisions.
1303
Adds revisions to the seen set.
1305
:param revisions: Revisions to query.
1306
:return: A tuple: (set(found_revisions), set(ghost_revisions),
1307
set(parents_of_found_revisions), dict(found_revisions:parents)).
1309
found_revisions = set()
1310
parents_of_found = set()
1311
# revisions may contain nodes that point to other nodes in revisions:
1312
# we want to filter them out.
1313
self.seen.update(revisions)
1314
parent_map = self._parents_provider.get_parent_map(revisions)
1315
found_revisions.update(parent_map)
1316
for rev_id, parents in parent_map.iteritems():
1319
new_found_parents = [p for p in parents if p not in self.seen]
1320
if new_found_parents:
1321
# Calling set.update() with an empty generator is actually
1323
parents_of_found.update(new_found_parents)
1324
ghost_revisions = revisions - found_revisions
1325
return found_revisions, ghost_revisions, parents_of_found, parent_map
401
new_search_revisions = set()
402
for parents in self._parents_provider.get_parents(
403
self._search_revisions):
406
new_search_revisions.update(p for p in parents if
408
self._search_revisions = new_search_revisions
409
if len(self._search_revisions) == 0:
410
raise StopIteration()
411
self.seen.update(self._search_revisions)
412
return self._search_revisions
1327
414
def __iter__(self):
1330
def find_seen_ancestors(self, revisions):
1331
"""Find ancestors of these revisions that have already been seen.
1333
This function generally makes the assumption that querying for the
1334
parents of a node that has already been queried is reasonably cheap.
1335
(eg, not a round trip to a remote host).
1337
# TODO: Often we might ask one searcher for its seen ancestors, and
1338
# then ask another searcher the same question. This can result in
1339
# searching the same revisions repeatedly if the two searchers
1340
# have a lot of overlap.
1341
all_seen = self.seen
1342
pending = set(revisions).intersection(all_seen)
1343
seen_ancestors = set(pending)
1345
if self._returning == 'next':
1346
# self.seen contains what nodes have been returned, not what nodes
1347
# have been queried. We don't want to probe for nodes that haven't
1348
# been searched yet.
1349
not_searched_yet = self._next_query
1351
not_searched_yet = ()
1352
pending.difference_update(not_searched_yet)
1353
get_parent_map = self._parents_provider.get_parent_map
1355
parent_map = get_parent_map(pending)
1357
# We don't care if it is a ghost, since it can't be seen if it is
1359
for parent_ids in parent_map.itervalues():
1360
all_parents.extend(parent_ids)
1361
next_pending = all_seen.intersection(all_parents).difference(seen_ancestors)
1362
seen_ancestors.update(next_pending)
1363
next_pending.difference_update(not_searched_yet)
1364
pending = next_pending
417
def find_seen_ancestors(self, revision):
418
"""Find ancestors of this revision that have already been seen."""
419
searcher = _BreadthFirstSearcher([revision], self._parents_provider)
420
seen_ancestors = set()
421
for ancestors in searcher:
422
for ancestor in ancestors:
423
if ancestor not in self.seen:
424
searcher.stop_searching_any([ancestor])
426
seen_ancestors.add(ancestor)
1366
427
return seen_ancestors
1368
429
def stop_searching_any(self, revisions):
1370
431
Remove any of the specified revisions from the search list.
1372
433
None of the specified revisions are required to be present in the
1375
It is okay to call stop_searching_any() for revisions which were seen
1376
in previous iterations. It is the callers responsibility to call
1377
find_seen_ancestors() to make sure that current search tips that are
1378
ancestors of those revisions are also stopped. All explicitly stopped
1379
revisions will be excluded from the search result's get_keys(), though.
434
search list. In this case, the call is a no-op.
1381
# TODO: does this help performance?
1384
revisions = frozenset(revisions)
1385
if self._returning == 'next':
1386
stopped = self._next_query.intersection(revisions)
1387
self._next_query = self._next_query.difference(revisions)
1389
stopped_present = self._current_present.intersection(revisions)
1390
stopped = stopped_present.union(
1391
self._current_ghosts.intersection(revisions))
1392
self._current_present.difference_update(stopped)
1393
self._current_ghosts.difference_update(stopped)
1394
# stopping 'x' should stop returning parents of 'x', but
1395
# not if 'y' always references those same parents
1396
stop_rev_references = {}
1397
for rev in stopped_present:
1398
for parent_id in self._current_parents[rev]:
1399
if parent_id not in stop_rev_references:
1400
stop_rev_references[parent_id] = 0
1401
stop_rev_references[parent_id] += 1
1402
# if only the stopped revisions reference it, the ref count will be
1404
for parents in self._current_parents.itervalues():
1405
for parent_id in parents:
1407
stop_rev_references[parent_id] -= 1
1410
stop_parents = set()
1411
for rev_id, refs in stop_rev_references.iteritems():
1413
stop_parents.add(rev_id)
1414
self._next_query.difference_update(stop_parents)
1415
self._stopped_keys.update(stopped)
1416
self._stopped_keys.update(revisions)
436
stopped = self._search_revisions.intersection(revisions)
437
self._search_revisions = self._search_revisions.difference(revisions)
1419
440
def start_searching(self, revisions):
1420
"""Add revisions to the search.
1422
The parents of revisions will be returned from the next call to next()
1423
or next_with_ghosts(). If next_with_ghosts was the most recently used
1424
next* call then the return value is the result of looking up the
1425
ghost/not ghost status of revisions. (A tuple (present, ghosted)).
1427
revisions = frozenset(revisions)
1428
self._started_keys.update(revisions)
1429
new_revisions = revisions.difference(self.seen)
1430
if self._returning == 'next':
1431
self._next_query.update(new_revisions)
1432
self.seen.update(new_revisions)
1434
# perform a query on revisions
1435
revs, ghosts, query, parents = self._do_query(revisions)
1436
self._stopped_keys.update(ghosts)
1437
self._current_present.update(revs)
1438
self._current_ghosts.update(ghosts)
1439
self._next_query.update(query)
1440
self._current_parents.update(parents)
1444
class SearchResult(object):
1445
"""The result of a breadth first search.
1447
A SearchResult provides the ability to reconstruct the search or access a
1448
set of the keys the search found.
1451
def __init__(self, start_keys, exclude_keys, key_count, keys):
1452
"""Create a SearchResult.
1454
:param start_keys: The keys the search started at.
1455
:param exclude_keys: The keys the search excludes.
1456
:param key_count: The total number of keys (from start to but not
1458
:param keys: The keys the search found. Note that in future we may get
1459
a SearchResult from a smart server, in which case the keys list is
1460
not necessarily immediately available.
1462
self._recipe = ('search', start_keys, exclude_keys, key_count)
1463
self._keys = frozenset(keys)
1465
def get_recipe(self):
1466
"""Return a recipe that can be used to replay this search.
1468
The recipe allows reconstruction of the same results at a later date
1469
without knowing all the found keys. The essential elements are a list
1470
of keys to start and to stop at. In order to give reproducible
1471
results when ghosts are encountered by a search they are automatically
1472
added to the exclude list (or else ghost filling may alter the
1475
:return: A tuple ('search', start_keys_set, exclude_keys_set,
1476
revision_count). To recreate the results of this search, create a
1477
breadth first searcher on the same graph starting at start_keys.
1478
Then call next() (or next_with_ghosts()) repeatedly, and on every
1479
result, call stop_searching_any on any keys from the exclude_keys
1480
set. The revision_count value acts as a trivial cross-check - the
1481
found revisions of the new search should have as many elements as
1482
revision_count. If it does not, then additional revisions have been
1483
ghosted since the search was executed the first time and the second
1489
"""Return the keys found in this search.
1491
:return: A set of keys.
1496
"""Return false if the search lists 1 or more revisions."""
1497
return self._recipe[3] == 0
1499
def refine(self, seen, referenced):
1500
"""Create a new search by refining this search.
1502
:param seen: Revisions that have been satisfied.
1503
:param referenced: Revision references observed while satisfying some
1506
start = self._recipe[1]
1507
exclude = self._recipe[2]
1508
count = self._recipe[3]
1509
keys = self.get_keys()
1510
# New heads = referenced + old heads - seen things - exclude
1511
pending_refs = set(referenced)
1512
pending_refs.update(start)
1513
pending_refs.difference_update(seen)
1514
pending_refs.difference_update(exclude)
1515
# New exclude = old exclude + satisfied heads
1516
seen_heads = start.intersection(seen)
1517
exclude.update(seen_heads)
1518
# keys gets seen removed
1520
# length is reduced by len(seen)
1522
return SearchResult(pending_refs, exclude, count, keys)
1525
class PendingAncestryResult(object):
1526
"""A search result that will reconstruct the ancestry for some graph heads.
1528
Unlike SearchResult, this doesn't hold the complete search result in
1529
memory, it just holds a description of how to generate it.
1532
def __init__(self, heads, repo):
1535
:param heads: an iterable of graph heads.
1536
:param repo: a repository to use to generate the ancestry for the given
1539
self.heads = frozenset(heads)
1542
def get_recipe(self):
1543
"""Return a recipe that can be used to replay this search.
1545
The recipe allows reconstruction of the same results at a later date.
1547
:seealso SearchResult.get_recipe:
1549
:return: A tuple ('proxy-search', start_keys_set, set(), -1)
1550
To recreate this result, create a PendingAncestryResult with the
1553
return ('proxy-search', self.heads, set(), -1)
1556
"""See SearchResult.get_keys.
1558
Returns all the keys for the ancestry of the heads, excluding
1561
return self._get_keys(self.repo.get_graph())
1563
def _get_keys(self, graph):
1564
NULL_REVISION = revision.NULL_REVISION
1565
keys = [key for (key, parents) in graph.iter_ancestry(self.heads)
1566
if key != NULL_REVISION and parents is not None]
1570
"""Return false if the search lists 1 or more revisions."""
1571
if revision.NULL_REVISION in self.heads:
1572
return len(self.heads) == 1
1574
return len(self.heads) == 0
1576
def refine(self, seen, referenced):
1577
"""Create a new search by refining this search.
1579
:param seen: Revisions that have been satisfied.
1580
:param referenced: Revision references observed while satisfying some
1583
referenced = self.heads.union(referenced)
1584
return PendingAncestryResult(referenced - seen, self.repo)
1587
def collapse_linear_regions(parent_map):
1588
"""Collapse regions of the graph that are 'linear'.
1594
can be collapsed by removing B and getting::
1598
:param parent_map: A dictionary mapping children to their parents
1599
:return: Another dictionary with 'linear' chains collapsed
1601
# Note: this isn't a strictly minimal collapse. For example:
1609
# Will not have 'D' removed, even though 'E' could fit. Also:
1615
# A and C are both kept because they are edges of the graph. We *could* get
1616
# rid of A if we wanted.
1624
# Will not have any nodes removed, even though you do have an
1625
# 'uninteresting' linear D->B and E->C
1627
for child, parents in parent_map.iteritems():
1628
children.setdefault(child, [])
1630
children.setdefault(p, []).append(child)
1632
orig_children = dict(children)
1634
result = dict(parent_map)
1635
for node in parent_map:
1636
parents = result[node]
1637
if len(parents) == 1:
1638
parent_children = children[parents[0]]
1639
if len(parent_children) != 1:
1640
# This is not the only child
1642
node_children = children[node]
1643
if len(node_children) != 1:
1645
child_parents = result.get(node_children[0], None)
1646
if len(child_parents) != 1:
1647
# This is not its only parent
1649
# The child of this node only points at it, and the parent only has
1650
# this as a child. remove this node, and join the others together
1651
result[node_children[0]] = parents
1652
children[parents[0]] = node_children
1660
_counters = [0,0,0,0,0,0,0]
1662
from bzrlib._known_graph_pyx import KnownGraph
1664
from bzrlib._known_graph_py import KnownGraph
441
if self._search_revisions is None:
442
self._start = set(revisions)
444
self._search_revisions.update(revisions.difference(self.seen))
445
self.seen.update(revisions)
added
removed
bzrlib/graph.py
