← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/chk_map.py

Merge the 2.1-static-tuple-no-use branch, but restore the
functionality to btree that involves using StaticTuple instead of tuple().
At this point, I'm leaving out the changes to string interning, as that
can easily be considered a separate patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/chk_map.py
133
133
 
134
134
    def _ensure_root(self):
135
135
        """Ensure that the root node is an object not a key."""
136
 
        if type(self._root_node) in (_key_type, tuple):
 
136
        if type(self._root_node) is tuple:
137
137
            # Demand-load the root
138
138
            self._root_node = self._get_node(self._root_node)
139
139
 
147
147
        :param node: A tuple key or node object.
148
148
        :return: A node object.
149
149
        """
150
 
        if type(node) in (tuple, _key_type):
 
150
        if type(node) is tuple:
151
151
            bytes = self._read_bytes(node)
152
152
            return _deserialise(bytes, node,
153
153
                search_key_func=self._search_key_func)
194
194
            for key, value in sorted(node._items.iteritems()):
195
195
                # Don't use prefix nor indent here to line up when used in
196
196
                # tests in conjunction with assertEqualDiff
197
 
                result.append('      %r %r' % (tuple(key), value))
 
197
                result.append('      %r %r' % (key, value))
198
198
        return result
199
199
 
200
200
    @classmethod
486
486
 
487
487
    def key(self):
488
488
        """Return the key for this map."""
489
 
        if type(self._root_node) in (tuple, _key_type):
 
489
        if type(self._root_node) is tuple:
490
490
            return self._root_node
491
491
        else:
492
492
            return self._root_node._key
516
516
 
517
517
    def _node_key(self, node):
518
518
        """Get the key for a node whether it's a tuple or node."""
519
 
        if type(node) in (tuple, _key_type):
 
519
        if type(node) is tuple:
520
520
            return node
521
521
        else:
522
522
            return node._key
542
542
 
543
543
        :return: The key of the root node.
544
544
        """
545
 
        if type(self._root_node) in (tuple, _key_type):
 
545
        if type(self._root_node) is tuple:
546
546
            # Already saved.
547
547
            return self._root_node
548
548
        keys = list(self._root_node.serialise(self._store))
1024
1024
            # for whatever we are missing
1025
1025
            shortcut = True
1026
1026
            for prefix, node in self._items.iteritems():
1027
 
                if node.__class__ in (tuple, _key_type):
 
1027
                if node.__class__ is tuple:
1028
1028
                    keys[node] = (prefix, None)
1029
1029
                else:
1030
1030
                    yield node, None
1059
1059
                    # A given key can only match 1 child node, if it isn't
1060
1060
                    # there, then we can just return nothing
1061
1061
                    return
1062
 
                if node.__class__ in (tuple, _key_type):
 
1062
                if node.__class__ is tuple:
1063
1063
                    keys[node] = (search_prefix, [key])
1064
1064
                else:
1065
1065
                    # This is loaded, and the only thing that can match,
1092
1092
                        # We can ignore this one
1093
1093
                        continue
1094
1094
                    node_key_filter = prefix_to_keys[search_prefix]
1095
 
                    if node.__class__ in (tuple, _key_type):
 
1095
                    if node.__class__ is tuple:
1096
1096
                        keys[node] = (search_prefix, node_key_filter)
1097
1097
                    else:
1098
1098
                        yield node, node_key_filter
1107
1107
                        if sub_prefix in length_filter:
1108
1108
                            node_key_filter.extend(prefix_to_keys[sub_prefix])
1109
1109
                    if node_key_filter: # this key matched something, yield it
1110
 
                        if node.__class__ in (tuple, _key_type):
 
1110
                        if node.__class__ is tuple:
1111
1111
                            keys[node] = (prefix, node_key_filter)
1112
1112
                        else:
1113
1113
                            yield node, node_key_filter
1245
1245
        :return: An iterable of the keys inserted by this operation.
1246
1246
        """
1247
1247
        for node in self._items.itervalues():
1248
 
            if type(node) in (tuple, _key_type):
 
1248
            if type(node) is tuple:
1249
1249
                # Never deserialised.
1250
1250
                continue
1251
1251
            if node._key is not None:
1262
1262
        lines.append('%s\n' % (self._search_prefix,))
1263
1263
        prefix_len = len(self._search_prefix)
1264
1264
        for prefix, node in sorted(self._items.items()):
1265
 
            if type(node) in (tuple, _key_type):
 
1265
            if type(node) is tuple:
1266
1266
                key = node[0]
1267
1267
            else:
1268
1268
                key = node._key[0]
1307
1307
            raise AssertionError("unserialised nodes have no refs.")
1308
1308
        refs = []
1309
1309
        for value in self._items.itervalues():
1310
 
            if type(value) in (tuple, _key_type):
 
1310
            if type(value) is tuple:
1311
1311
                refs.append(value)
1312
1312
            else:
1313
1313
                refs.append(value.key())
1639
1639
        _search_key_255,
1640
1640
        _deserialise_leaf_node,
1641
1641
        _deserialise_internal_node,
1642
 
        _key_type,
1643
1642
        )
1644
1643
except ImportError, e:
1645
1644
    osutils.failed_to_load_extension(e)
1648
1647
        _search_key_255,
1649
1648
        _deserialise_leaf_node,
1650
1649
        _deserialise_internal_node,
1651
 
        _key_type,
1652
1650
        )
1653
1651
search_key_registry.register('hash-16-way', _search_key_16)
1654
1652
search_key_registry.register('hash-255-way', _search_key_255)