← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/_dirstate_helpers_py.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-16 16:58:03 UTC
  • mfrom: (3224.3.1 news-typo)
  • Revision ID: pqm@pqm.ubuntu.com-20080316165803-tisoc9mpob9z544o
(Matt Nordhoff) Trivial NEWS typo fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_dirstate_helpers_py.py
1
 
# Copyright (C) 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Python implementations of Dirstate Helper functions."""
18
18
 
19
 
import binascii
20
19
import os
21
 
import struct
22
20
 
23
21
# We cannot import the dirstate module, because it loads this module
24
22
# All we really need is the IN_MEMORY_MODIFIED constant
25
 
from bzrlib import errors
26
23
from bzrlib.dirstate import DirState
27
24
 
28
25
 
29
 
def pack_stat(st, _b64=binascii.b2a_base64, _pack=struct.Struct('>6L').pack):
30
 
    """Convert stat values into a packed representation
31
 
 
32
 
    Not all of the fields from the stat included are strictly needed, and by
33
 
    just encoding the mtime and mode a slight speed increase could be gained.
34
 
    However, using the pyrex version instead is a bigger win.
35
 
    """
36
 
    # base64 encoding always adds a final newline, so strip it off
37
 
    return _b64(_pack(st.st_size & 0xFFFFFFFF, int(st.st_mtime) & 0xFFFFFFFF,
38
 
        int(st.st_ctime) & 0xFFFFFFFF, st.st_dev & 0xFFFFFFFF,
39
 
        st.st_ino & 0xFFFFFFFF, st.st_mode))[:-1]
40
 
 
41
 
 
42
 
def _unpack_stat(packed_stat):
43
 
    """Turn a packed_stat back into the stat fields.
44
 
 
45
 
    This is meant as a debugging tool, should not be used in real code.
46
 
    """
47
 
    (st_size, st_mtime, st_ctime, st_dev, st_ino,
48
 
     st_mode) = struct.unpack('>6L', binascii.a2b_base64(packed_stat))
49
 
    return dict(st_size=st_size, st_mtime=st_mtime, st_ctime=st_ctime,
50
 
                st_dev=st_dev, st_ino=st_ino, st_mode=st_mode)
51
 
 
52
 
 
53
 
def _bisect_path_left(paths, path):
 
26
def _bisect_path_left_py(paths, path):
54
27
    """Return the index where to insert path into paths.
55
28
 
56
29
    This uses the dirblock sorting. So all children in a directory come before
89
62
        mid = (lo + hi) // 2
90
63
        # Grab the dirname for the current dirblock
91
64
        cur = paths[mid]
92
 
        if _cmp_path_by_dirblock(cur, path) < 0:
 
65
        if _cmp_path_by_dirblock_py(cur, path) < 0:
93
66
            lo = mid + 1
94
67
        else:
95
68
            hi = mid
96
69
    return lo
97
70
 
98
71
 
99
 
def _bisect_path_right(paths, path):
 
72
def _bisect_path_right_py(paths, path):
100
73
    """Return the index where to insert path into paths.
101
74
 
102
75
    This uses a path-wise comparison so we get::
120
93
        mid = (lo+hi)//2
121
94
        # Grab the dirname for the current dirblock
122
95
        cur = paths[mid]
123
 
        if _cmp_path_by_dirblock(path, cur) < 0:
 
96
        if _cmp_path_by_dirblock_py(path, cur) < 0:
124
97
            hi = mid
125
98
        else:
126
99
            lo = mid + 1
127
100
    return lo
128
101
 
129
102
 
130
 
def bisect_dirblock(dirblocks, dirname, lo=0, hi=None, cache={}):
 
103
def bisect_dirblock_py(dirblocks, dirname, lo=0, hi=None, cache={}):
131
104
    """Return the index where to insert dirname into the dirblocks.
132
105
 
133
106
    The return value idx is such that all directories blocks in dirblock[:idx]
158
131
    return lo
159
132
 
160
133
 
161
 
def cmp_by_dirs(path1, path2):
 
134
def cmp_by_dirs_py(path1, path2):
162
135
    """Compare two paths directory by directory.
163
136
 
164
137
    This is equivalent to doing::
184
157
    return cmp(path1.split('/'), path2.split('/'))
185
158
 
186
159
 
187
 
def _cmp_path_by_dirblock(path1, path2):
 
160
def _cmp_path_by_dirblock_py(path1, path2):
188
161
    """Compare two paths based on what directory they are in.
189
162
 
190
163
    This generates a sort order, such that all children of a directory are
210
183
    return cmp(key1, key2)
211
184
 
212
185
 
213
 
def _read_dirblocks(state):
 
186
def _read_dirblocks_py(state):
214
187
    """Read in the dirblocks for the given DirState object.
215
188
 
216
189
    This is tightly bound to the DirState internal representation. It should be
227
200
    fields = text.split('\0')
228
201
    # Remove the last blank entry
229
202
    trailing = fields.pop()
230
 
    if trailing != '':
231
 
        raise errors.DirstateCorrupt(state,
232
 
            'trailing garbage: %r' % (trailing,))
 
203
    assert trailing == ''
233
204
    # consider turning fields into a tuple.
234
205
 
235
206
    # skip the first field which is the trailing null from the header.
246
217
    expected_field_count = entry_size * state._num_entries
247
218
    field_count = len(fields)
248
219
    # this checks our adjustment, and also catches file too short.
249
 
    if field_count - cur != expected_field_count:
250
 
        raise errors.DirstateCorrupt(state,
251
 
            'field count incorrect %s != %s, entry_size=%s, '\
252
 
            'num_entries=%s fields=%r' % (
 
220
    assert field_count - cur == expected_field_count, \
 
221
        'field count incorrect %s != %s, entry_size=%s, '\
 
222
        'num_entries=%s fields=%r' % (
253
223
            field_count - cur, expected_field_count, entry_size,
254
 
            state._num_entries, fields))
 
224
            state._num_entries, fields)
255
225
 
256
226
    if num_present_parents == 1:
257
227
        # Bind external functions to local names
299
269
                     ),
300
270
                     ])
301
271
            trailing = next()
302
 
            if trailing != '\n':
303
 
                raise ValueError("trailing garbage in dirstate: %r" % trailing)
 
272
            assert trailing == '\n'
304
273
            # append the entry to the current block
305
274
            append_entry(entry)
306
275
        state._split_root_dirblock_into_contents()
315
284
    # To convert from format 3 => format 2
316
285
    # state._dirblocks = sorted(state._dirblocks)
317
286
    state._dirblock_state = DirState.IN_MEMORY_UNMODIFIED
 
287