← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/chk_map.py

  • Committer: John Arbash Meinel
  • Date: 2009-10-20 22:13:23 UTC
  • mto: This revision was merged to the branch mainline in revision 4771.
  • Revision ID: john@arbash-meinel.com-20091020221323-vvukgazqxkicb70n
A bit broken, but getting there.

Start being much stricter about requiring StaticTuples everywhere.
I may go back and loosen this restriction, but getting the code base
StaticTuple pure is probably a good idea. The main reason to be 'looser'
is so that things don't fail 'in the wild' just because someone
calls an api with a tuple rather than a StaticTuple.
However, I'd like the internals to be 'pure' if possible.
We'll see.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/chk_map.py
52
52
    registry,
53
53
    trace,
54
54
    )
 
55
from bzrlib.static_tuple import StaticTuple
55
56
 
56
57
# approx 4MB
57
58
# If each line is 50 bytes, and you have 255 internal pages, with 255-way fan
100
101
        if root_key is None:
101
102
            self._root_node = LeafNode(search_key_func=search_key_func)
102
103
        else:
 
104
            _check_key(root_key)
103
105
            self._root_node = self._node_key(root_key)
104
106
 
105
107
    def apply_delta(self, delta):
133
135
 
134
136
    def _ensure_root(self):
135
137
        """Ensure that the root node is an object not a key."""
136
 
        if type(self._root_node) in (_key_type, tuple):
 
138
        if type(self._root_node) is StaticTuple:
137
139
            # Demand-load the root
138
140
            self._root_node = self._get_node(self._root_node)
139
141
 
147
149
        :param node: A tuple key or node object.
148
150
        :return: A node object.
149
151
        """
150
 
        if type(node) in (tuple, _key_type):
 
152
        if type(node) is StaticTuple:
151
153
            bytes = self._read_bytes(node)
152
154
            return _deserialise(bytes, node,
153
155
                search_key_func=self._search_key_func)
218
220
        root_key = klass._create_directly(store, initial_value,
219
221
            maximum_size=maximum_size, key_width=key_width,
220
222
            search_key_func=search_key_func)
 
223
        assert type(root_key) is StaticTuple
221
224
        return root_key
222
225
 
223
226
    @classmethod
256
259
            for split, subnode in node_details:
257
260
                node.add_node(split, subnode)
258
261
        keys = list(node.serialise(store))
259
 
        return keys[-1]
 
262
        root_node = keys[-1]
 
263
        assert (type(root_node) is StaticTuple
 
264
                and len(root_node) == 1 and
 
265
                type(root_node[0]) is str)
 
266
        return root_node
260
267
 
261
268
    def iter_changes(self, basis):
262
269
        """Iterate over the changes between basis and self.
486
493
 
487
494
    def key(self):
488
495
        """Return the key for this map."""
489
 
        if type(self._root_node) in (tuple, _key_type):
 
496
        if type(self._root_node) is StaticTuple:
 
497
            _check_key(self._root_node)
490
498
            return self._root_node
491
499
        else:
492
500
            return self._root_node._key
516
524
 
517
525
    def _node_key(self, node):
518
526
        """Get the key for a node whether it's a tuple or node."""
519
 
        if type(node) in (tuple, _key_type):
 
527
        if type(node) is StaticTuple:
 
528
            _check_key(node)
520
529
            return node
 
530
        elif type(node) is tuple:
 
531
            raise TypeError('node %r should be a StaticTuple not tuple'
 
532
                            % (node,))
521
533
        else:
522
534
            return node._key
523
535
 
542
554
 
543
555
        :return: The key of the root node.
544
556
        """
545
 
        if type(self._root_node) in (tuple, _key_type):
 
557
        if type(self._root_node) is StaticTuple:
546
558
            # Already saved.
547
559
            return self._root_node
548
560
        keys = list(self._root_node.serialise(self._store))
873
885
            lines.append(serialized[prefix_len:])
874
886
            lines.extend(value_lines)
875
887
        sha1, _, _ = store.add_lines((None,), (), lines)
876
 
        self._key = ("sha1:" + sha1,)
 
888
        self._key = StaticTuple("sha1:" + sha1,).intern()
877
889
        bytes = ''.join(lines)
878
890
        if len(bytes) != self._current_size():
879
891
            raise AssertionError('Invalid _current_size')
994
1006
        :param key: The key that the serialised node has.
995
1007
        :return: An InternalNode instance.
996
1008
        """
 
1009
        if type(key) is not StaticTuple:
 
1010
            import pdb; pdb.set_trace()
 
1011
        key = StaticTuple.from_sequence(key).intern()
997
1012
        return _deserialise_internal_node(bytes, key,
998
1013
                                          search_key_func=search_key_func)
999
1014
 
1024
1039
            # for whatever we are missing
1025
1040
            shortcut = True
1026
1041
            for prefix, node in self._items.iteritems():
1027
 
                if node.__class__ in (tuple, _key_type):
 
1042
                if node.__class__ is StaticTuple:
1028
1043
                    keys[node] = (prefix, None)
1029
1044
                else:
1030
1045
                    yield node, None
1059
1074
                    # A given key can only match 1 child node, if it isn't
1060
1075
                    # there, then we can just return nothing
1061
1076
                    return
1062
 
                if node.__class__ in (tuple, _key_type):
 
1077
                if node.__class__ is StaticTuple:
1063
1078
                    keys[node] = (search_prefix, [key])
1064
1079
                else:
1065
1080
                    # This is loaded, and the only thing that can match,
1092
1107
                        # We can ignore this one
1093
1108
                        continue
1094
1109
                    node_key_filter = prefix_to_keys[search_prefix]
1095
 
                    if node.__class__ in (tuple, _key_type):
 
1110
                    if node.__class__ is StaticTuple:
1096
1111
                        keys[node] = (search_prefix, node_key_filter)
1097
1112
                    else:
1098
1113
                        yield node, node_key_filter
1107
1122
                        if sub_prefix in length_filter:
1108
1123
                            node_key_filter.extend(prefix_to_keys[sub_prefix])
1109
1124
                    if node_key_filter: # this key matched something, yield it
1110
 
                        if node.__class__ in (tuple, _key_type):
 
1125
                        if node.__class__ is StaticTuple:
1111
1126
                            keys[node] = (prefix, node_key_filter)
1112
1127
                        else:
1113
1128
                            yield node, node_key_filter
1245
1260
        :return: An iterable of the keys inserted by this operation.
1246
1261
        """
1247
1262
        for node in self._items.itervalues():
1248
 
            if type(node) in (tuple, _key_type):
 
1263
            if type(node) is StaticTuple:
1249
1264
                # Never deserialised.
1250
1265
                continue
1251
1266
            if node._key is not None:
1262
1277
        lines.append('%s\n' % (self._search_prefix,))
1263
1278
        prefix_len = len(self._search_prefix)
1264
1279
        for prefix, node in sorted(self._items.items()):
1265
 
            if type(node) in (tuple, _key_type):
 
1280
            if type(node) is StaticTuple:
1266
1281
                key = node[0]
1267
1282
            else:
1268
1283
                key = node._key[0]
1272
1287
                    % (serialised, self._search_prefix))
1273
1288
            lines.append(serialised[prefix_len:])
1274
1289
        sha1, _, _ = store.add_lines((None,), (), lines)
1275
 
        self._key = ("sha1:" + sha1,)
 
1290
        self._key = StaticTuple("sha1:" + sha1,).intern()
1276
1291
        _page_cache.add(self._key, ''.join(lines))
1277
1292
        yield self._key
1278
1293
 
1307
1322
            raise AssertionError("unserialised nodes have no refs.")
1308
1323
        refs = []
1309
1324
        for value in self._items.itervalues():
1310
 
            if type(value) in (tuple, _key_type):
 
1325
            if type(value) is StaticTuple:
1311
1326
                refs.append(value)
1312
1327
            else:
1313
1328
                refs.append(value.key())
1639
1654
        _search_key_255,
1640
1655
        _deserialise_leaf_node,
1641
1656
        _deserialise_internal_node,
1642
 
        _key_type,
1643
1657
        )
1644
1658
except ImportError, e:
1645
1659
    osutils.failed_to_load_extension(e)
1648
1662
        _search_key_255,
1649
1663
        _deserialise_leaf_node,
1650
1664
        _deserialise_internal_node,
1651
 
        _key_type,
1652
1665
        )
1653
1666
search_key_registry.register('hash-16-way', _search_key_16)
1654
1667
search_key_registry.register('hash-255-way', _search_key_255)
 
1668
 
 
1669
def _check_key(key):
 
1670
    if type(key) is not StaticTuple:
 
1671
        raise TypeError('key %r is not StaticTuple but %s' % (key, type(key)))
 
1672
    if len(key) != 1:
 
1673
        raise ValueError('key %r should have length 1, not %d' % (key, len(key),))
 
1674
    if type(key[0]) is not str:
 
1675
        raise TypeError('key %r should hold a str, not %r'
 
1676
                        % (key, type(key[0])))
 
1677
    if not key[0].startswith('sha1:'):
 
1678
        raise ValueError('key %r should point to a sha1:' % (key,))
 
1679
 
 
1680