← 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-21 18:50:08 UTC
  • mto: This revision was merged to the branch mainline in revision 4771.
  • Revision ID: john@arbash-meinel.com-20091021185008-8t37d9j69t0yo2vg
Create a Barrier at the CHKMap interface.

Basically, everything above CHKMap can work in either tuples or StaticTuples.
Everything *below* CHKMap should be working in StaticTuples.
I need to fix .iteritems() but apply_delta, map, unmap, from_dict, etc are
all handled.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/chk_map.py
115
115
        """
116
116
        delete_count = 0
117
117
        # Check preconditions first.
118
 
        new_items = set([key for (old, key, value) in delta if key is not None
119
 
            and old is None])
 
118
        as_st = StaticTuple.from_sequence
 
119
        new_items = set([as_st(key) for (old, key, value) in delta
 
120
                         if key is not None and old is None])
120
121
        existing_new = list(self.iteritems(key_filter=new_items))
121
122
        if existing_new:
122
123
            raise errors.InconsistentDeltaDelta(delta,
242
243
        node = LeafNode(search_key_func=search_key_func)
243
244
        node.set_maximum_size(maximum_size)
244
245
        node._key_width = key_width
245
 
        node._items = dict(initial_value)
 
246
        as_st = StaticTuple.from_sequence
 
247
        node._items = dict([(as_st(key), val) for key, val
 
248
                                               in initial_value.iteritems()])
246
249
        node._raw_size = sum([node._key_value_len(key, value)
247
 
                              for key,value in initial_value.iteritems()])
 
250
                              for key,value in node._items.iteritems()])
248
251
        node._len = len(node._items)
249
252
        node._compute_search_prefix()
250
253
        node._compute_serialised_prefix()
490
493
    def iteritems(self, key_filter=None):
491
494
        """Iterate over the entire CHKMap's contents."""
492
495
        self._ensure_root()
 
496
        # TODO: StaticTuple Barrier here
493
497
        return self._root_node.iteritems(self._store, key_filter=key_filter)
494
498
 
495
499
    def key(self):
510
514
        :param key: A key to map.
511
515
        :param value: The value to assign to key.
512
516
        """
 
517
        key = StaticTuple.from_sequence(key)
513
518
        # Need a root object.
514
519
        self._ensure_root()
515
520
        prefix, node_details = self._root_node.map(self._store, key, value)
525
530
 
526
531
    def _node_key(self, node):
527
532
        """Get the key for a node whether it's a tuple or node."""
 
533
        if type(node) is tuple:
 
534
            node = StaticTuple.from_sequence(node)
528
535
        if type(node) is StaticTuple:
529
536
            _check_key(node)
530
537
            return node
531
 
        elif type(node) is tuple:
532
 
            raise TypeError('node %r should be a StaticTuple not tuple'
533
 
                            % (node,))
534
538
        else:
535
539
            return node._key
536
540
 
537
541
    def unmap(self, key, check_remap=True):
538
542
        """remove key from the map."""
 
543
        key = StaticTuple.from_sequence(key)
539
544
        self._ensure_root()
540
545
        if type(self._root_node) is InternalNode:
541
546
            unmapped = self._root_node.unmap(self._store, key,
559
564
            # Already saved.
560
565
            return self._root_node
561
566
        keys = list(self._root_node.serialise(self._store))
 
567
        assert type(keys[-1]) is StaticTuple
562
568
        return keys[-1]
563
569
 
564
570