1
# Copyright (C) 2007, 2008 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Python implementations of Dirstate Helper functions."""
19
from __future__ import absolute_import
25
# We cannot import the dirstate module, because it loads this module
26
# All we really need is the IN_MEMORY_MODIFIED constant
27
from bzrlib import errors
28
from bzrlib.dirstate import DirState
31
def pack_stat(st, _b64=binascii.b2a_base64, _pack=struct.Struct('>6L').pack):
32
"""Convert stat values into a packed representation
34
Not all of the fields from the stat included are strictly needed, and by
35
just encoding the mtime and mode a slight speed increase could be gained.
36
However, using the pyrex version instead is a bigger win.
38
# base64 encoding always adds a final newline, so strip it off
39
return _b64(_pack(st.st_size & 0xFFFFFFFF, int(st.st_mtime) & 0xFFFFFFFF,
40
int(st.st_ctime) & 0xFFFFFFFF, st.st_dev & 0xFFFFFFFF,
41
st.st_ino & 0xFFFFFFFF, st.st_mode))[:-1]
44
def _unpack_stat(packed_stat):
45
"""Turn a packed_stat back into the stat fields.
47
This is meant as a debugging tool, should not be used in real code.
49
(st_size, st_mtime, st_ctime, st_dev, st_ino,
50
st_mode) = struct.unpack('>6L', binascii.a2b_base64(packed_stat))
51
return dict(st_size=st_size, st_mtime=st_mtime, st_ctime=st_ctime,
52
st_dev=st_dev, st_ino=st_ino, st_mode=st_mode)
55
def _bisect_path_left(paths, path):
56
"""Return the index where to insert path into paths.
58
This uses the dirblock sorting. So all children in a directory come before
59
the children of children. For example::
83
:param paths: A list of paths to search through
84
:param path: A single path to insert
85
:return: An offset where 'path' can be inserted.
86
:seealso: bisect.bisect_left
92
# Grab the dirname for the current dirblock
94
if _cmp_path_by_dirblock(cur, path) < 0:
101
def _bisect_path_right(paths, path):
102
"""Return the index where to insert path into paths.
104
This uses a path-wise comparison so we get::
114
:param paths: A list of paths to search through
115
:param path: A single path to insert
116
:return: An offset where 'path' can be inserted.
117
:seealso: bisect.bisect_right
123
# Grab the dirname for the current dirblock
125
if _cmp_path_by_dirblock(path, cur) < 0:
132
def bisect_dirblock(dirblocks, dirname, lo=0, hi=None, cache={}):
133
"""Return the index where to insert dirname into the dirblocks.
135
The return value idx is such that all directories blocks in dirblock[:idx]
136
have names < dirname, and all blocks in dirblock[idx:] have names >=
139
Optional args lo (default 0) and hi (default len(dirblocks)) bound the
140
slice of a to be searched.
145
dirname_split = cache[dirname]
147
dirname_split = dirname.split('/')
148
cache[dirname] = dirname_split
151
# Grab the dirname for the current dirblock
152
cur = dirblocks[mid][0]
154
cur_split = cache[cur]
156
cur_split = cur.split('/')
157
cache[cur] = cur_split
158
if cur_split < dirname_split: lo = mid + 1
163
def cmp_by_dirs(path1, path2):
164
"""Compare two paths directory by directory.
166
This is equivalent to doing::
168
cmp(path1.split('/'), path2.split('/'))
170
The idea is that you should compare path components separately. This
171
differs from plain ``cmp(path1, path2)`` for paths like ``'a-b'`` and
172
``a/b``. "a-b" comes after "a" but would come before "a/b" lexically.
174
:param path1: first path
175
:param path2: second path
176
:return: negative number if ``path1`` comes first,
177
0 if paths are equal,
178
and positive number if ``path2`` sorts first
180
if not isinstance(path1, str):
181
raise TypeError("'path1' must be a plain string, not %s: %r"
182
% (type(path1), path1))
183
if not isinstance(path2, str):
184
raise TypeError("'path2' must be a plain string, not %s: %r"
185
% (type(path2), path2))
186
return cmp(path1.split('/'), path2.split('/'))
189
def _cmp_path_by_dirblock(path1, path2):
190
"""Compare two paths based on what directory they are in.
192
This generates a sort order, such that all children of a directory are
193
sorted together, and grandchildren are in the same order as the
194
children appear. But all grandchildren come after all children.
196
:param path1: first path
197
:param path2: the second path
198
:return: negative number if ``path1`` comes first,
200
and a positive number if ``path2`` sorts first
202
if not isinstance(path1, str):
203
raise TypeError("'path1' must be a plain string, not %s: %r"
204
% (type(path1), path1))
205
if not isinstance(path2, str):
206
raise TypeError("'path2' must be a plain string, not %s: %r"
207
% (type(path2), path2))
208
dirname1, basename1 = os.path.split(path1)
209
key1 = (dirname1.split('/'), basename1)
210
dirname2, basename2 = os.path.split(path2)
211
key2 = (dirname2.split('/'), basename2)
212
return cmp(key1, key2)
215
def _read_dirblocks(state):
216
"""Read in the dirblocks for the given DirState object.
218
This is tightly bound to the DirState internal representation. It should be
219
thought of as a member function, which is only separated out so that we can
220
re-write it in pyrex.
222
:param state: A DirState object.
225
state._state_file.seek(state._end_of_header)
226
text = state._state_file.read()
227
# TODO: check the crc checksums. crc_measured = zlib.crc32(text)
229
fields = text.split('\0')
230
# Remove the last blank entry
231
trailing = fields.pop()
233
raise errors.DirstateCorrupt(state,
234
'trailing garbage: %r' % (trailing,))
235
# consider turning fields into a tuple.
237
# skip the first field which is the trailing null from the header.
239
# Each line now has an extra '\n' field which is not used
240
# so we just skip over it
242
# 3 fields for the key
243
# + number of fields per tree_data (5) * tree count
245
num_present_parents = state._num_present_parents()
246
tree_count = 1 + num_present_parents
247
entry_size = state._fields_per_entry()
248
expected_field_count = entry_size * state._num_entries
249
field_count = len(fields)
250
# this checks our adjustment, and also catches file too short.
251
if field_count - cur != expected_field_count:
252
raise errors.DirstateCorrupt(state,
253
'field count incorrect %s != %s, entry_size=%s, '\
254
'num_entries=%s fields=%r' % (
255
field_count - cur, expected_field_count, entry_size,
256
state._num_entries, fields))
258
if num_present_parents == 1:
259
# Bind external functions to local names
261
# We access all fields in order, so we can just iterate over
262
# them. Grab an straight iterator over the fields. (We use an
263
# iterator because we don't want to do a lot of additions, nor
264
# do we want to do a lot of slicing)
265
next = iter(fields).next
266
# Move the iterator to the current position
267
for x in xrange(cur):
269
# The two blocks here are deliberate: the root block and the
270
# contents-of-root block.
271
state._dirblocks = [('', []), ('', [])]
272
current_block = state._dirblocks[0][1]
274
append_entry = current_block.append
275
for count in xrange(state._num_entries):
279
if dirname != current_dirname:
280
# new block - different dirname
282
current_dirname = dirname
283
state._dirblocks.append((current_dirname, current_block))
284
append_entry = current_block.append
285
# we know current_dirname == dirname, so re-use it to avoid
286
# creating new strings
287
entry = ((current_dirname, name, file_id),
290
next(), # fingerprint
292
next() == 'y', # executable
293
next(), # packed_stat or revision_id
297
next(), # fingerprint
299
next() == 'y', # executable
300
next(), # packed_stat or revision_id
305
raise ValueError("trailing garbage in dirstate: %r" % trailing)
306
# append the entry to the current block
308
state._split_root_dirblock_into_contents()
310
fields_to_entry = state._get_fields_to_entry()
311
entries = [fields_to_entry(fields[pos:pos+entry_size])
312
for pos in xrange(cur, field_count, entry_size)]
313
state._entries_to_current_state(entries)
314
# To convert from format 2 => format 3
315
# state._dirblocks = sorted(state._dirblocks,
316
# key=lambda blk:blk[0].split('/'))
317
# To convert from format 3 => format 2
318
# state._dirblocks = sorted(state._dirblocks)
319
state._dirblock_state = DirState.IN_MEMORY_UNMODIFIED
added
removed
bzrlib/_dirstate_helpers_py.py
