← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/dirstate.py

  • Committer: Vincent Ladeuil
  • Date: 2007-10-23 07:15:13 UTC
  • mfrom: (2926 +trunk)
  • mto: (2961.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 2962.
  • Revision ID: v.ladeuil+lp@free.fr-20071023071513-elryt6g2at34d2ur
merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/dirstate.py
345
345
            self._sha1_file = self._sha1_file_and_mutter
346
346
        else:
347
347
            self._sha1_file = osutils.sha_file_by_name
 
348
        # These two attributes provide a simple cache for lookups into the
 
349
        # dirstate in-memory vectors. By probing respectively for the last
 
350
        # block, and for the next entry, we save nearly 2 bisections per path
 
351
        # during commit.
 
352
        self._last_block_index = None
 
353
        self._last_entry_index = None
348
354
 
349
355
    def __repr__(self):
350
356
        return "%s(%r)" % \
1042
1048
        """
1043
1049
        if key[0:2] == ('', ''):
1044
1050
            return 0, True
 
1051
        try:
 
1052
            if (self._last_block_index is not None and
 
1053
                self._dirblocks[self._last_block_index][0] == key[0]):
 
1054
                return self._last_block_index, True
 
1055
        except IndexError:
 
1056
            pass
1045
1057
        block_index = bisect_dirblock(self._dirblocks, key[0], 1,
1046
1058
                                      cache=self._split_path_cache)
1047
1059
        # _right returns one-past-where-key is so we have to subtract
1052
1064
        # simple and correct:
1053
1065
        present = (block_index < len(self._dirblocks) and
1054
1066
            self._dirblocks[block_index][0] == key[0])
 
1067
        self._last_block_index = block_index
 
1068
        # Reset the entry index cache to the beginning of the block.
 
1069
        self._last_entry_index = -1
1055
1070
        return block_index, present
1056
1071
 
1057
1072
    def _find_entry_index(self, key, block):
1059
1074
 
1060
1075
        :return: The entry index, True if the entry for the key is present.
1061
1076
        """
 
1077
        len_block = len(block)
 
1078
        try:
 
1079
            if self._last_entry_index is not None:
 
1080
                # mini-bisect here.
 
1081
                entry_index = self._last_entry_index + 1
 
1082
                # A hit is when the key is after the last slot, and before or
 
1083
                # equal to the next slot.
 
1084
                if ((entry_index > 0 and block[entry_index - 1][0] < key) and
 
1085
                    key <= block[entry_index][0]):
 
1086
                    self._last_entry_index = entry_index
 
1087
                    present = (block[entry_index][0] == key)
 
1088
                    return entry_index, present
 
1089
        except IndexError:
 
1090
            pass
1062
1091
        entry_index = bisect.bisect_left(block, (key, []))
1063
 
        present = (entry_index < len(block) and
 
1092
        present = (entry_index < len_block and
1064
1093
            block[entry_index][0] == key)
 
1094
        self._last_entry_index = entry_index
1065
1095
        return entry_index, present
1066
1096
 
1067
1097
    @staticmethod
1353
1383
            return block_index, 0, False, False
1354
1384
        block = self._dirblocks[block_index][1] # access the entries only
1355
1385
        entry_index, present = self._find_entry_index(key, block)
1356
 
        # linear search through present entries at this path to find the one
 
1386
        # linear search through entries at this path to find the one
1357
1387
        # requested.
1358
1388
        while entry_index < len(block) and block[entry_index][0][1] == basename:
1359
1389
            if block[entry_index][1][tree_index][0] not in \
1380
1410
        """
1381
1411
        self._read_dirblocks_if_needed()
1382
1412
        if path_utf8 is not None:
1383
 
            assert path_utf8.__class__ == str, 'path_utf8 is not a str: %s %s' % (type(path_utf8), path_utf8)
 
1413
            assert path_utf8.__class__ == str, ('path_utf8 is not a str: %s %s'
 
1414
                % (type(path_utf8), path_utf8))
1384
1415
            # path lookups are faster
1385
1416
            dirname, basename = osutils.split(path_utf8)
1386
1417
            block_index, entry_index, dir_present, file_present = \