~bzr-pqm/bzr/bzr.dev

from copy import deepcopy

 

    workingtree,

    def check(self, checker, rev_id, inv, tree):

        :param tree: RevisionTree for this entry.

        self._check(checker, rev_id, tree)

    def _check(self, checker, rev_id, tree):

        raise BzrCheckError('unknown entry kind %r in revision {%s}' %

                            (self.kind, rev_id))

    def _check(self, checker, rev_id, tree):

    def _check(self, checker, rev_id, tree):

        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:

            raise BzrCheckError('directory {%s} has text in revision {%s}'

    def _check(self, checker, tree_revision_id, tree):

        key = (self.file_id, self.revision)

        if key in checker.checked_texts:

            prev_sha = checker.checked_texts[key]

            if prev_sha != self.text_sha1:

                raise BzrCheckError(

                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %

                    (self.file_id, tree_revision_id, prev_sha, self.text_sha1,

                     t))

            else:

                checker.repeated_text_cnt += 1

                return

 

        checker.checked_text_cnt += 1

        # We can't check the length, because Weave doesn't store that

        # information, and the whole point of looking at the weave's

        # sha1sum is that we don't have to extract the text.

        if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):

            raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)

        checker.checked_texts[key] = self.text_sha1

    def _check(self, checker, rev_id, tree):

            raise BzrCheckError('symlink {%s} has text in revision {%s}'

                    % (self.file_id, rev_id))

            raise BzrCheckError('symlink {%s} has no target in revision {%s}'

                    % (self.file_id, rev_id))

    """Basic inventory logic, defined in terms of primitives like has_id."""

    def iter_entries(self, from_dir=None):

        """Return (path, entry) pairs, in order by name."""

    """Inventory of versioned files in a tree.

 

    This describes which file_id is present at each point in the tree,

    and possibly the SHA-1 or other information about the file.

    Entries can be looked up either by path or by file_id.

 

    The inventory represents a typical unix file tree, with

    directories containing files and subdirectories.  We never store

    the full path to a file, because renaming a directory implicitly

    moves all of its contents.  This class internally maintains a

    InventoryEntry objects must not be modified after they are

    inserted, other than through the Inventory API.

 

    May be treated as an iterator or set to look up file ids:

    >>> bool(inv.path2id('hello.c'))

    True

    May also look up by name:

    >>> [x[0] for x in inv.iter_entries()]

    >>> inv = Inventory('TREE_ROOT-12345678-12345678')

    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))

    Traceback (most recent call last):

    BzrError: parent_id {TREE_ROOT} not in inventory

    >>> inv.add(InventoryFile('123-123', 'hello.c', 'TREE_ROOT-12345678-12345678'))

    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None, revision=None)

        # before starting to mutate the inventory.

        unique_file_ids = set([f for _, _, f, _ in delta])

        if len(unique_file_ids) != len(delta):

            raise AssertionError("a file-id appears multiple times in %r"

                    % (delta,))

        del unique_file_ids

            if file_id not in self:

                # adds come later

                continue

        for new_path, new_entry in sorted((np, e) for op, np, f, e in

            self.add(new_entry)

        return deepcopy(self)

        Returns the new entry object.

 

                raise BzrError("parent_id {%s} not in inventory" %

                               entry.parent_id)

 

                raise BzrError("%s is already versioned" %

                        osutils.pathjoin(self.id2path(parent.file_id),

                        entry.name).encode('utf-8'))

        if self.root_id is not None:

            entries.next()

        inv = Inventory(self.root_id, self.revision_id)

            inv.add(inv_entry)

        parent_id_basename_delta = []

                    # If the two keys are the same, the value will be unchanged

                    # as its always the file id.

                    parent_id_basename_delta.append((old_key, new_key, new_value))

            result.parent_id_basename_to_file_id.apply_delta(parent_id_basename_delta)

        result = CHKInventory(search_key_name)

        search_key_func = chk_map.search_key_registry.get(search_key_name)

        result.id_to_entry = chk_map.CHKMap(chk_store, None, search_key_func)

        result.id_to_entry._root_node.set_maximum_size(maximum_size)

        file_id_delta = []

        result.parent_id_basename_to_file_id = chk_map.CHKMap(chk_store,

            None, search_key_func)

        result.parent_id_basename_to_file_id._root_node.set_maximum_size(

            maximum_size)

        result.parent_id_basename_to_file_id._root_node._key_width = 2

        parent_id_delta = []

            file_id_delta.append((None, (entry.file_id,),

                result._entry_to_bytes(entry)))

            parent_id_delta.append(

                (None, result._parent_id_basename_key(entry),

                 entry.file_id))

        result.id_to_entry.apply_delta(file_id_delta)

        result.parent_id_basename_to_file_id.apply_delta(parent_id_delta)

        if result is None:

            result = CommonInventory.path2id(self, name)

            self._path_to_fileid_cache[name] = result

        return result