← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/chk_map.py

Merge 2.1-export-c-api branch, and bring back the static_tuple code.

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)