~bzr-pqm/bzr/bzr.dev

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

the file on disk, and then immediately discard, the overhead of object creation

becomes a significant cost.

 

microseconds, whereas creating a object which is subclassed from tuple was

0.500 microseconds, and creating an object with 3 elements and slots was 3

microseconds long. 0.1 milliseconds is 100 microseconds, and ideally we'll get

import bisect

import binascii

import errno

import os

from stat import S_IEXEC

import stat

    inventory,

    lock,

    osutils,

    trace,

    )

 

    """An interface for getting sha1s of a file."""

 

    def sha1(self, abspath):

        raise NotImplementedError(self.sha1)

 

    def stat_and_sha1(self, abspath):

        """Return the stat and sha1 of a file given its absolute path.

        

        Note: the stat should be the stat of the physical file

        while the sha may be the sha of its canonical content.

        """

           self._ensure_block(block_index, entry_index, utf8path)

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

        if self._id_index:

 

    def _bisect(self, paths):

        """Bisect through the disk structure for specific rows.

    def update_by_delta(self, delta):

        """Apply an inventory delta to the dirstate for tree 0

 

        :param delta: An inventory delta.  See Inventory.apply_delta for

            details.

        """

        self._read_dirblocks_if_needed()

        insertions = {}

        removals = {}

            if (file_id in insertions) or (file_id in removals):

            if old_path is not None:

                old_path = old_path.encode('utf-8')

                removals[file_id] = old_path

            if new_path is not None:

                new_path = new_path.encode('utf-8')

                minikind = DirState._kind_to_minikind[inv_entry.kind]

                if minikind == 't':

                else:

                    fingerprint = ''

                insertions[file_id] = (key, minikind, inv_entry.executable,

                    minikind = child[1][0][0]

                    fingerprint = child[1][0][4]

                    executable = child[1][0][3]

                    removals[child[0][2]] = old_child_path

                    child_suffix = child_dirname[len(old_path):]

                    new_child_dirname = (new_path + child_suffix)

                    key = (new_child_dirname, child_basename, child[0][2])

                    insertions[child[0][2]] = (key, minikind, executable,

                                               fingerprint, new_child_path)

 

    def _apply_removals(self, removals):

            dirname, basename = osutils.split(path)

            block_i, entry_i, d_present, f_present = \

                self._get_block_entry_index(dirname, basename, 0)

            self._make_absent(entry)

            # See if we have a malformed delta: deleting a directory must not

            # leave crud behind. This increases the number of bisects needed

                # be due to it being in a parent tree, or a corrupt delta.

                for child_entry in self._dirblocks[block_i][1]:

                    if child_entry[1][0][0] not in ('r', 'a'):

                        raise errors.InconsistentDelta(path, entry[0][2],

                            "The file id was deleted but its children were "

                            "not deleted.")

 

    def _apply_insertions(self, adds):

 

    def update_basis_by_delta(self, delta, new_revid):

        """Update the parents of this tree after a commit.

        # At the same time, to reduce interface friction we convert the input

        # inventory entries to dirstate.

        root_only = ('', '')

        for old_path, new_path, file_id, inv_entry in delta:

            if old_path is None:

                adds.append((None, encode(new_path), file_id,

                    inv_to_entry(inv_entry), True))

            elif new_path is None:

                deletes.append((encode(old_path), None, file_id, None, True))

            elif (old_path, new_path) != root_only:

                # for 'r' items on every pass.

                self._update_basis_apply_deletes(deletes)

                deletes = []

                # Split into an add/delete pair recursively.

                adds.append((None, new_path_utf8, file_id,

                    inv_to_entry(inv_entry), False))

                # of everything.

                changes.append((encode(old_path), encode(new_path), file_id,

                    inv_to_entry(inv_entry)))

 

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

        self._header_state = DirState.IN_MEMORY_MODIFIED

        self._id_index = None

        return

 

    def _update_basis_apply_adds(self, adds):

        """Apply a sequence of adds to tree 1 during update_basis_by_delta.

 

        null = DirState.NULL_PARENT_DETAILS

        for old_path, new_path, file_id, _, real_delete in deletes:

            if real_delete != (new_path is None):

                raise AssertionError("bad delete delta")

            # the entry for this file_id must be in tree 1.

            dirname, basename = osutils.split(old_path)

                    # it is being resurrected here, so blank it out temporarily.

                    self._dirblocks[block_index][1][entry_index][1][1] = null

 

    def _observed_sha1(self, entry, sha1, stat_value,

        _stat_to_minikind=_stat_to_minikind, _pack_stat=pack_stat):

        """Note the sha1 of a file.

        self._read_dirblocks_if_needed()

        if path_utf8 is not None:

            if type(path_utf8) is not str:

                    % (type(path_utf8), path_utf8))

            # path lookups are faster

            dirname, basename = osutils.split(path_utf8)

                                          ' tree_index, file_id and path')

            return entry

        else:

            if not possible_keys:

                return None, None

            for key in possible_keys:

                entry_index, present = self._find_entry_index(key, block)

                if present:

                    entry = self._dirblocks[block_index][1][entry_index]

                    if entry[1][tree_index][0] in 'fdlt':

                        # this is the result we are looking for: the

                        # real home of this file_id in this tree.

                yield entry

 

    def _get_id_index(self):

        if self._id_index is None:

            id_index = {}

            for key, tree_details in self._iter_entries():

            self._id_index = id_index

        return self._id_index

 

    def _get_output_lines(self, lines):

        """Format lines for final output.

 

 

    @staticmethod

    def on_file(path, sha1_provider=None):

 

        :param path: The path at which the dirstate file on disk should live.

        :param sha1_provider: an object meeting the SHA1Provider interface.

        self.update_minimal(('', '', new_id), 'd',

            path_utf8='', packed_stat=entry[1][0][4])

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

 

    def set_parent_trees(self, trees, ghosts):

        """Set the parent trees for the dirstate.

                continue

            by_path[entry[0]] = [entry[1][0]] + \

                [DirState.NULL_PARENT_DETAILS] * parent_count

 

        # now the parent trees:

        for tree_index, tree in enumerate(parent_trees):

                new_entry_key = (dirname, basename, file_id)

                # tree index consistency: All other paths for this id in this tree

                # index must point to the correct path.

                    # TODO:PROFILING: It might be faster to just update

                    # rather than checking if we need to, and then overwrite

                    # the one we are located at.

                        by_path[entry_key][tree_index] = ('r', path_utf8, 0, False, '')

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

                # add a new one with relocation pointers for the other tree indexes.

                    # there is already an entry where this data belongs, just insert it.

                    by_path[new_entry_key][tree_index] = \

                        self._inv_entry_to_details(entry)

                    new_details = []

                    for lookup_index in xrange(tree_index):

                        # boundary case: this is the first occurence of file_id

                        # the loop?

                            new_details.append(DirState.NULL_PARENT_DETAILS)

                        else:

                            # grab any one entry, use it to find the right path.

                            # TODO: optimise this to reduce memory use in highly

                            # fragmented situations by reusing the relocation

                            # records.

                            if by_path[a_key][lookup_index][0] in ('r', 'a'):

                                # its a pointer or missing statement, use it as is.

                                new_details.append(by_path[a_key][lookup_index])

                    new_details.append(self._inv_entry_to_details(entry))

                    new_details.extend(new_location_suffix)

                    by_path[new_entry_key] = new_details

        # --- end generation of full tree mappings

 

        # sort and output all the entries

        if 'evil' in debug.debug_flags:

            trace.mutter_callsite(1,

                "set_state_from_inventory called; please mutate the tree instead")

        self._read_dirblocks_if_needed()

        # sketch:

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

        new_iterator = new_inv.iter_entries_by_dir()

        # we will be modifying the dirstate, so we need a stable iterator. In

        # future we might write one, for now we just clone the state into a

        old_iterator = iter(list(self._iter_entries()))

        # both must have roots so this is safe:

        current_new = new_iterator.next()

            # we make both end conditions explicit

            if not current_old:

                # old is finished: insert current_new into the state.

                self.update_minimal(new_entry_key, current_new_minikind,

                    executable=current_new[1].executable,

                current_new = advance(new_iterator)

            elif not current_new:

                # new is finished

                self._make_absent(current_old)

                current_old = advance(old_iterator)

            elif new_entry_key == current_old[0]:

                # kind has changed.

                if (current_old[1][0][3] != current_new[1].executable or

                    current_old[1][0][0] != current_new_minikind):

                    self.update_minimal(current_old[0], current_new_minikind,

                        executable=current_new[1].executable,

                # both sides are dealt with, move on

                current_old = advance(old_iterator)

                current_new = advance(new_iterator)

                      and new_entry_key[1:] < current_old[0][1:])):

                # new comes before:

                # add a entry for this and advance new

                self.update_minimal(new_entry_key, current_new_minikind,

                    executable=current_new[1].executable,

                current_new = advance(new_iterator)

            else:

                # we've advanced past the place where the old key would be,

                # without seeing it in the new list.  so it must be gone.

                self._make_absent(current_old)

                current_old = advance(old_iterator)

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

        self._id_index = None

        self._packed_stat_index = None

 

    def _make_absent(self, current_old):

        """Mark current_old - an entry - as absent for tree 0.

            block[1].pop(entry_index)

            # if we have an id_index in use, remove this key from it for this id.

            if self._id_index is not None:

        # update all remaining keys for this id to record it as absent. The

        # existing details may either be the record we are marking as deleted

        # (if there were other trees with the id present at this path), or may

        return last_reference

 

    def update_minimal(self, key, minikind, executable=False, fingerprint='',

        """Update an entry to the state in tree 0.

 

        This will either create a new entry at 'key' or update an existing one.

        :param size: Size information for new entry

        :param path_utf8: key[0] + '/' + key[1], just passed in to avoid doing

                extra computation.

 

        If packed_stat and fingerprint are not given, they're invalidated in

        the entry.

        new_details = (minikind, fingerprint, size, executable, packed_stat)

        id_index = self._get_id_index()

        if not present:

            # new entry, synthesis cross reference here,

            if not existing_keys:

                # not currently in the state, simplest case

                new_entry = key, [new_details] + self._empty_parent_info()

                # grab one of them and use it to generate parent

                # relocation/absent entries.

                new_entry = key, [new_details]

                    # change the record at other to be a pointer to this new

                    # record. The loop looks similar to the change to

                    # relocations when updating an existing record but its not:

                    # the test for existing kinds is different: this can be

                    # factored out to a helper though.

                    if path_utf8 is None:

                        raise AssertionError('no path')

 

                num_present_parents = self._num_present_parents()

                for lookup_index in xrange(1, num_present_parents + 1):

                    # grab any one entry, use it to find the right path.

                    # TODO: optimise this to reduce memory use in highly

                    update_entry_index, present = \

                        self._find_entry_index(other_key, self._dirblocks[update_block_index][1])

                    if not present:

                    update_details = self._dirblocks[update_block_index][1][update_entry_index][1][lookup_index]

                    if update_details[0] in 'ar': # relocated, absent

                        # its a pointer or absent in lookup_index's tree, use

                        pointer_path = osutils.pathjoin(*other_key[0:2])

                        new_entry[1].append(('r', pointer_path, 0, False, ''))

            block.insert(entry_index, new_entry)

        else:

            # Does the new state matter?

            block[entry_index][1][0] = new_details

            # converted to relocated.

            if path_utf8 is None:

                raise AssertionError('no path')

                # TODO:PROFILING: It might be faster to just update

                # rather than checking if we need to, and then overwrite

                # the one we are located at.

 

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

 

    def _validate(self):

        """Check that invariants on the dirblock are correct.

 

            if absent_positions == tree_count:

                raise AssertionError(

                    "entry %r has no data for any tree." % (entry,))

 

    def _wipe_state(self):

        """Forget all state information about the dirstate."""

                           False, DirState.NULLSTAT)

    state._dirblock_state = DirState.IN_MEMORY_MODIFIED

    return link_or_sha1

 

 

class ProcessEntryPython(object):

 

        "last_source_parent", "last_target_parent", "include_unchanged",

 

    def __init__(self, include_unchanged, use_filesystem_for_exec,

        search_specific_files, state, source_index, target_index,

        want_unversioned, tree):

        self.old_dirname_to_file_id = {}

        self.new_dirname_to_file_id = {}

        # Using a list so that we can access the values and change them in

        # nested scope. Each one is [path, file_id, entry]

        self.last_source_parent = [None, None]

        self.use_filesystem_for_exec = use_filesystem_for_exec

        self.utf8_decode = cache_utf8._utf8_decode

        # for all search_indexs in each path at or under each element of

        self.searched_specific_files = set()

        self.search_specific_files = search_specific_files

        self.state = state

        self.source_index = source_index

        self.target_index = target_index

        self.want_unversioned = want_unversioned

        self.tree = tree

 

        """Compare an entry and real disk to generate delta information.

 

        :param path_info: top_relpath, basename, kind, lstat, abspath for

            Basename is returned as a utf8 string because we expect this

            tuple will be ignored, and don't want to take the time to

            decode.

        """

        if self.source_index is None:

            source_details = DirState.NULL_PARENT_DETAILS

                    if source_minikind != 'f':

                        content_change = True

                    else:

                    # Target details is updated at update_entry time

                    if self.use_filesystem_for_exec:

                        # We don't need S_ISREG here, because we are sure

                        content_change = False

                    target_exec = False

                else:

            if source_minikind == 'd':

                if path is None:

                    old_path = path = pathjoin(old_dirname, old_basename)

                self.old_dirname_to_file_id[old_path] = file_id

            # parent id is the entry for the path in the target tree

                source_parent_id = self.last_source_parent[1]

            else:

                try:

                    self.last_source_parent[0] = old_dirname

                    self.last_source_parent[1] = source_parent_id

            new_dirname = entry[0][0]

                target_parent_id = self.last_target_parent[1]

            else:

                try:

                    self.last_target_parent[1] = target_parent_id