/brz/remove-bazaar

# Copyright (C) 2007-2011 Canonical Ltd

from __future__ import absolute_import

 

from . import (

from .sixish import (

    viewitems,

    viewvalues,

    )

    # Note: DictParentsProvider does not implement get_cached_parent_map

    #       Arguably, the data is clearly cached in memory. However, this class

    #       is mostly used for testing, and it keeps the tests clean to not

    #       change it.

 

        return dict([(k, ancestry[k]) for k in keys if k in ancestry])

 

 

        # This adds getattr() overhead to each get_parent_map call. However,

        # this is StackedParentsProvider, which means we're dealing with I/O

        # (either local indexes, or remote RPCs), so CPU overhead should be

        # minimal.

        for parents_provider in self._parent_providers:

            get_cached = getattr(parents_provider, 'get_cached_parent_map',

                                 None)

            if get_cached is None:

                continue

            new_found = get_cached(remaining)

            found.update(new_found)

            remaining.difference_update(new_found)

            if not remaining:

                break

        if not remaining:

            return found

        for parents_provider in self._parent_providers:

            try:

                new_found = parents_provider.get_parent_map(remaining)

            except errors.UnsupportedOperation:

                continue

 

    def get_cached_parent_map(self, keys):

        """Return items from the cache.

 

        This returns the same info as get_parent_map, but explicitly does not

        invoke the supplied ParentsProvider to search for uncached values.

        """

        cache = self._cache

        if cache is None:

            return {}

        return dict([(key, cache[key]) for key in keys if key in cache])

 

class CallableToParentsProviderAdapter(object):

    """A parents provider that adapts any callable to the parents provider API.

 

    i.e. it accepts calls to self.get_parent_map and relays them to the

    callable it was constructed with.

    """

 

    def __init__(self, a_callable):

        self.callable = a_callable

 

    def __repr__(self):

        return "%s(%r)" % (self.__class__.__name__, self.callable)

 

    def get_parent_map(self, keys):

        return self.callable(keys)

 

 

        The scaling of this operation should be proportional to:

 

    def find_descendants(self, old_key, new_key):

        """Find descendants of old_key that are ancestors of new_key."""

        child_map = self.get_child_map(self._find_descendant_ancestors(

            old_key, new_key))

        graph = Graph(DictParentsProvider(child_map))

        searcher = graph._make_breadth_first_searcher([old_key])

        list(searcher)

        return searcher.seen

 

    def _find_descendant_ancestors(self, old_key, new_key):

        """Find ancestors of new_key that may be descendants of old_key."""

        stop = self._make_breadth_first_searcher([old_key])

        descendants = self._make_breadth_first_searcher([new_key])

        for revisions in descendants:

            old_stop = stop.seen.intersection(revisions)

            descendants.stop_searching_any(old_stop)

            seen_stop = descendants.find_seen_ancestors(stop.step())

            descendants.stop_searching_any(seen_stop)

        return descendants.seen.difference(stop.seen)

 

    def get_child_map(self, keys):

        """Get a mapping from parents to children of the specified keys.

 

        This is simply the inversion of get_parent_map.  Only supplied keys

        will be discovered as children.

        :return: a dict of key:child_list for keys.

        """

        parent_map = self._parents_provider.get_parent_map(keys)

        parent_child = {}

        for child, parents in sorted(viewitems(parent_map)):

            for parent in parents:

                parent_child.setdefault(parent, []).append(child)

        return parent_child

 

        searching_known_tips = list(known_revnos)

            to_search = {cur_tip}

            if not parents:  # An empty list or None is a ghost

            (XXX: Would this API be better if we allowed multiple revisions on

            to be searched here?)

                                                             unique_searcher, common_searcher)

        next(unique_searcher)

                    unique_are_common_nodes)

                ancestors.update(

                    common_searcher.find_seen_ancestors(ancestors))

                                                      self.get_parent_map(unique_nodes))

            ancestor_all_unique = unique_searcher.find_seen_ancestors(

                unique_tips)

                        searcher.seen)

            ancestor_all_unique)

            all_unique_searcher.seen)

        for searchers in viewvalues(unique_search_tips):

                step_all_unique_counter == 0)

                return {revision.NULL_REVISION}

                         for c in candidate_heads)

        for searcher in viewvalues(active_searchers):

            next(searcher)

                next(common_walker)

            for candidate in list(active_searchers):

                    ancestors.update(next(searcher))

                    ancestor_set = {ancestor}

                    for searcher in viewvalues(searchers):

                    for searcher in viewvalues(searchers):

                        for searcher in viewvalues(searchers):

            if not parent_ids:  # Ghost, nothing to search here

    def find_lefthand_merger(self, merged_key, tip_key):

        """Find the first lefthand ancestor of tip_key that merged merged_key.

 

        We do this by first finding the descendants of merged_key, then

        walking through the lefthand ancestry of tip_key until we find a key

        that doesn't descend from merged_key.  Its child is the key that

        merged merged_key.

 

        :return: The first lefthand ancestor of tip_key to merge merged_key.

            merged_key if it is a lefthand ancestor of tip_key.

            None if no ancestor of tip_key merged merged_key.

        """

        descendants = self.find_descendants(merged_key, tip_key)

        candidate_iterator = self.iter_lefthand_ancestry(tip_key)

        last_candidate = None

        for candidate in candidate_iterator:

            if candidate not in descendants:

                return last_candidate

            last_candidate = candidate

 

            for item in viewitems(next_map):

    def iter_lefthand_ancestry(self, start_key, stop_keys=None):

        if stop_keys is None:

            stop_keys = ()

        next_key = start_key

 

        def get_parents(key):

            try:

                return self._parents_provider.get_parent_map([key])[key]

            except KeyError:

                raise errors.RevisionNotPresent(next_key, self)

        while True:

            if next_key in stop_keys:

                return

            parents = get_parents(next_key)

            yield next_key

            if len(parents) == 0:

                return

            else:

                next_key = parents[0]

 

        from breezy import tsort

        return {candidate_descendant} == self.heads(

                (lower_bound_revid is None or

                     self.is_ancestor(lower_bound_revid, revid)))

        if not unique:  # No unique nodes, nothing to do

                                                 self.get_parent_map(unique))

            if not revs_to_search:  # XXX: This shouldn't be possible

                    searcher.seen)

        trace.mutter('Started %d unique searchers for %d unique revisions',

        while True:  # If we have no more nodes we have nothing to do

                    newly_seen_common)

        # simple_ancestors.difference_update(r for r, p_ids in parent_map.iteritems()

        # if p_ids is not None and revisions.intersection(p_ids))

        # return simple_ancestors

        # for revision_id, parent_ids in parent_map.iteritems():

        # for p_id in parent_ids:

        # for revision in revisions.intersection(descendants):

        # simple_ancestors.difference_update(descendants[revision])

        # return simple_ancestors

        for revision, parent_ids in viewitems(parent_map):

    def get_state(self):

        """Get the current state of this searcher.

        :return: Tuple with started keys, excludes and included keys

        return self._started_keys, excludes, included_keys

            return next(self)

    def __next__(self):

    next = __next__

 

        seen = self.seen

        seen.update(revisions)

        for rev_id, parents in viewitems(parent_map):