~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2006, 2007, 2008 Canonical Ltd

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

'f' is a file entry: As for directory, but its a file. The fingerprint is a

    sha1 value.

    WHOLE NUMBER (* size *), NULL, packed stat, NULL, sha1|symlink target, 

format did not accommodate. 

   i.e. 

     root_entrie = (direntry for root, [parent_direntries_for_root]), 

      single vector, rather each individual, which tends to be limited to a 

      manageable number. Will scale badly on trees with 10K entries in a 

      we should have a net win regardless of optimality. So we are going to 

Figures: Creating a tuple from from 3 elements was profiled at 0.0625

    def __init__(self, path):

        #   of what is on disk. 

        # If true, an error has been detected while updating the dirstate, and 

            self._sha1_file = osutils.sha_file_by_name

            path foo within the root, 'foo/bar' is the path bar within foo 

        :param kind: The kind of the path, as a string like 'file', 

        :param fingerprint: The sha value of the file,

        # find the block its in. 

        # now that we've normalised, we need the correct utf8 path and 

            while (entry_index < len(block) and 

        

            ## In future, when doing partial parsing, this should load and 

        # The two blocks here are deliberate: the root block and the 

        # root-contents, and for '', we get 2 back, so this is 

    def from_tree(tree, dir_state_filename):

        result = DirState.initialize(dir_state_filename)

        for old_path, new_path, file_id, inv_entry in sorted(delta, reverse=True):

                raise AssertionError("repeated file id in delta %r" % (file_id,))

                dirname, basename = osutils.split(new_path)

                key = (dirname, basename, file_id)

                    fingerprint = inv_entry.reference_revision

                    old_child_path = osutils.pathjoin(child[0][0],

                                                      child[0][1])

                    new_child_path = os.path.join(new_child_dirname,

                                                  child_basename)

        self._apply_removals(removals.values())

        self._apply_insertions(insertions.values())

        for path in sorted(removals, reverse=True):

            entry = self._dirblocks[block_i][1][entry_i]

        for key, minikind, executable, fingerprint, path_utf8 in sorted(adds):

            self.update_minimal(key, minikind, executable, fingerprint,

                                path_utf8=path_utf8)

                new_path_utf8 = encode(new_path)

 

        # Finish expunging deletes/first half of renames.

        self._update_basis_apply_deletes(deletes)

        # Reinstate second half of renames and new paths.

        self._update_basis_apply_adds(adds)

        # Apply in-situ changes.

        self._update_basis_apply_changes(changes)

        return osutils.sha_file_by_name(abspath)

        return os.readlink(abspath)

                raise AssertionError('path_utf8 is not a str: %s %s'

                        # this is the result we are looking for: the  

    def initialize(cls, path):

        result = cls(path)

            # We don't support non-ascii targets for symlinks yet.

            fingerprint = str(inv_entry.symlink_target or '')

        This only returns entries that are present (not in 'a', 'r') in 

    

    def on_file(path):

        """Construct a DirState on the file at path path.

        result = DirState(path)

        

            tree. Each tuple contains the directory path and a list of entries 

        if self._id_index is not None:

            self._id_index.setdefault(new_id, set()).add(entry[0])

            even if the revision_id refers to a ghost: supply an empty tree in 

        """ 

        # TODO: generate a list of parent indexes to preserve to save 

        # for now: 

        # sketch: loop over all entries in the dirstate, cherry picking 

        # - find other keys containing a path 

        # We accumulate each entry via this dictionary, including the root 

        

        # how many trees do we end up with 

        

                # records where needed. 

                # by path consistency: Insert into an existing path record (trivial), or 

                            # TODO: optimise this to reduce memory use in highly 

        """Set new_inv as the current state. 

        # Two iterators: current data and new data, both in dirblock order. 

        # possibly changed.  

        # list - which is a shallow copy.

                    path_utf8=new_path_utf8, fingerprint=fingerprint)