← 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: John Arbash Meinel
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/_dirstate_helpers_py.py
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
 
from __future__ import absolute_import
20
 
 
21
 
import binascii
22
19
import os
23
 
import struct
24
20
 
25
21
# We cannot import the dirstate module, because it loads this module
26
22
# All we really need is the IN_MEMORY_MODIFIED constant
28
24
from bzrlib.dirstate import DirState
29
25
 
30
26
 
31
 
def pack_stat(st, _b64=binascii.b2a_base64, _pack=struct.Struct('>6L').pack):
32
 
    """Convert stat values into a packed representation
33
 
 
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.
37
 
    """
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]
42
 
 
43
 
 
44
 
def _unpack_stat(packed_stat):
45
 
    """Turn a packed_stat back into the stat fields.
46
 
 
47
 
    This is meant as a debugging tool, should not be used in real code.
48
 
    """
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)
53
 
 
54
 
 
55
 
def _bisect_path_left(paths, path):
 
27
def _bisect_path_left_py(paths, path):
56
28
    """Return the index where to insert path into paths.
57
29
 
58
30
    This uses the dirblock sorting. So all children in a directory come before
91
63
        mid = (lo + hi) // 2
92
64
        # Grab the dirname for the current dirblock
93
65
        cur = paths[mid]
94
 
        if _cmp_path_by_dirblock(cur, path) < 0:
 
66
        if _cmp_path_by_dirblock_py(cur, path) < 0:
95
67
            lo = mid + 1
96
68
        else:
97
69
            hi = mid
98
70
    return lo
99
71
 
100
72
 
101
 
def _bisect_path_right(paths, path):
 
73
def _bisect_path_right_py(paths, path):
102
74
    """Return the index where to insert path into paths.
103
75
 
104
76
    This uses a path-wise comparison so we get::
122
94
        mid = (lo+hi)//2
123
95
        # Grab the dirname for the current dirblock
124
96
        cur = paths[mid]
125
 
        if _cmp_path_by_dirblock(path, cur) < 0:
 
97
        if _cmp_path_by_dirblock_py(path, cur) < 0:
126
98
            hi = mid
127
99
        else:
128
100
            lo = mid + 1
129
101
    return lo
130
102
 
131
103
 
132
 
def bisect_dirblock(dirblocks, dirname, lo=0, hi=None, cache={}):
 
104
def bisect_dirblock_py(dirblocks, dirname, lo=0, hi=None, cache={}):
133
105
    """Return the index where to insert dirname into the dirblocks.
134
106
 
135
107
    The return value idx is such that all directories blocks in dirblock[:idx]
160
132
    return lo
161
133
 
162
134
 
163
 
def cmp_by_dirs(path1, path2):
 
135
def cmp_by_dirs_py(path1, path2):
164
136
    """Compare two paths directory by directory.
165
137
 
166
138
    This is equivalent to doing::
186
158
    return cmp(path1.split('/'), path2.split('/'))
187
159
 
188
160
 
189
 
def _cmp_path_by_dirblock(path1, path2):
 
161
def _cmp_path_by_dirblock_py(path1, path2):
190
162
    """Compare two paths based on what directory they are in.
191
163
 
192
164
    This generates a sort order, such that all children of a directory are
212
184
    return cmp(key1, key2)
213
185
 
214
186
 
215
 
def _read_dirblocks(state):
 
187
def _read_dirblocks_py(state):
216
188
    """Read in the dirblocks for the given DirState object.
217
189
 
218
190
    This is tightly bound to the DirState internal representation. It should be
317
289
    # To convert from format 3 => format 2
318
290
    # state._dirblocks = sorted(state._dirblocks)
319
291
    state._dirblock_state = DirState.IN_MEMORY_UNMODIFIED
 
292