← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: Martin Pool
  • Date: 2009-07-27 06:28:35 UTC
  • mto: This revision was merged to the branch mainline in revision 4587.
  • Revision ID: mbp@sourcefrog.net-20090727062835-o66p8it658tq1sma
Add CountedLock.get_physical_lock_status

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
32
32
from bzrlib import (
33
33
    annotate,
34
34
    errors,
35
 
    graph as _mod_graph,
36
35
    groupcompress,
37
36
    index,
38
37
    knit,
45
44
from bzrlib.graph import DictParentsProvider, Graph, StackedParentsProvider
46
45
from bzrlib.transport.memory import MemoryTransport
47
46
""")
 
47
from bzrlib.inter import InterObject
48
48
from bzrlib.registry import Registry
49
49
from bzrlib.symbol_versioning import *
50
50
from bzrlib.textmerge import TextMerge
913
913
        raise NotImplementedError(self.annotate)
914
914
 
915
915
    def check(self, progress_bar=None):
916
 
        """Check this object for integrity.
917
 
        
918
 
        :param progress_bar: A progress bar to output as the check progresses.
919
 
        :param keys: Specific keys within the VersionedFiles to check. When
920
 
            this parameter is not None, check() becomes a generator as per
921
 
            get_record_stream. The difference to get_record_stream is that
922
 
            more or deeper checks will be performed.
923
 
        :return: None, or if keys was supplied a generator as per
924
 
            get_record_stream.
925
 
        """
 
916
        """Check this object for integrity."""
926
917
        raise NotImplementedError(self.check)
927
918
 
928
919
    @staticmethod
929
920
    def check_not_reserved_id(version_id):
930
921
        revision.check_not_reserved_id(version_id)
931
922
 
932
 
    def clear_cache(self):
933
 
        """Clear whatever caches this VersionedFile holds.
934
 
 
935
 
        This is generally called after an operation has been performed, when we
936
 
        don't expect to be using this versioned file again soon.
937
 
        """
938
 
 
939
923
    def _check_lines_not_unicode(self, lines):
940
924
        """Check that lines being added to a versioned file are not unicode."""
941
925
        for line in lines:
948
932
            if '\n' in line[:-1]:
949
933
                raise errors.BzrBadParameterContainsNewline("lines")
950
934
 
951
 
    def get_known_graph_ancestry(self, keys):
952
 
        """Get a KnownGraph instance with the ancestry of keys."""
953
 
        # most basic implementation is a loop around get_parent_map
954
 
        pending = set(keys)
955
 
        parent_map = {}
956
 
        while pending:
957
 
            this_parent_map = self.get_parent_map(pending)
958
 
            parent_map.update(this_parent_map)
959
 
            pending = set()
960
 
            map(pending.update, this_parent_map.itervalues())
961
 
            pending = pending.difference(parent_map)
962
 
        kg = _mod_graph.KnownGraph(parent_map)
963
 
        return kg
964
 
 
965
935
    def get_parent_map(self, keys):
966
936
        """Get a map of the parents of keys.
967
937
 
1162
1132
    def get_annotator(self):
1163
1133
        return annotate.Annotator(self)
1164
1134
 
1165
 
    def check(self, progress_bar=None, keys=None):
 
1135
    def check(self, progress_bar=None):
1166
1136
        """See VersionedFiles.check()."""
1167
 
        # XXX: This is over-enthusiastic but as we only thunk for Weaves today
1168
 
        # this is tolerable. Ideally we'd pass keys down to check() and 
1169
 
        # have the older VersiondFile interface updated too.
1170
1137
        for prefix, vf in self._iter_all_components():
1171
1138
            vf.check()
1172
 
        if keys is not None:
1173
 
            return self.get_record_stream(keys, 'unordered', True)
1174
1139
 
1175
1140
    def get_parent_map(self, keys):
1176
1141
        """Get a map of the parents of keys.
1425
1390
    def __init__(self, plan, a_marker=TextMerge.A_MARKER,
1426
1391
                 b_marker=TextMerge.B_MARKER):
1427
1392
        TextMerge.__init__(self, a_marker, b_marker)
1428
 
        self.plan = list(plan)
 
1393
        self.plan = plan
1429
1394
 
1430
1395
    def _merge_struct(self):
1431
1396
        lines_a = []
1489
1454
        for struct in outstanding_struct():
1490
1455
            yield struct
1491
1456
 
1492
 
    def base_from_plan(self):
1493
 
        """Construct a BASE file from the plan text."""
1494
 
        base_lines = []
1495
 
        for state, line in self.plan:
1496
 
            if state in ('killed-a', 'killed-b', 'killed-both', 'unchanged'):
1497
 
                # If unchanged, then this line is straight from base. If a or b
1498
 
                # or both killed the line, then it *used* to be in base.
1499
 
                base_lines.append(line)
1500
 
            else:
1501
 
                if state not in ('killed-base', 'irrelevant',
1502
 
                                 'ghost-a', 'ghost-b',
1503
 
                                 'new-a', 'new-b',
1504
 
                                 'conflicted-a', 'conflicted-b'):
1505
 
                    # killed-base, irrelevant means it doesn't apply
1506
 
                    # ghost-a/ghost-b are harder to say for sure, but they
1507
 
                    # aren't in the 'inc_c' which means they aren't in the
1508
 
                    # shared base of a & b. So we don't include them.  And
1509
 
                    # obviously if the line is newly inserted, it isn't in base
1510
 
 
1511
 
                    # If 'conflicted-a' or b, then it is new vs one base, but
1512
 
                    # old versus another base. However, if we make it present
1513
 
                    # in the base, it will be deleted from the target, and it
1514
 
                    # seems better to get a line doubled in the merge result,
1515
 
                    # rather than have it deleted entirely.
1516
 
                    # Example, each node is the 'text' at that point:
1517
 
                    #           MN
1518
 
                    #          /   \
1519
 
                    #        MaN   MbN
1520
 
                    #         |  X  |
1521
 
                    #        MabN MbaN
1522
 
                    #          \   /
1523
 
                    #           ???
1524
 
                    # There was a criss-cross conflict merge. Both sides
1525
 
                    # include the other, but put themselves first.
1526
 
                    # Weave marks this as a 'clean' merge, picking OTHER over
1527
 
                    # THIS. (Though the details depend on order inserted into
1528
 
                    # weave, etc.)
1529
 
                    # LCA generates a plan:
1530
 
                    # [('unchanged', M),
1531
 
                    #  ('conflicted-b', b),
1532
 
                    #  ('unchanged', a),
1533
 
                    #  ('conflicted-a', b),
1534
 
                    #  ('unchanged', N)]
1535
 
                    # If you mark 'conflicted-*' as part of BASE, then a 3-way
1536
 
                    # merge tool will cleanly generate "MaN" (as BASE vs THIS
1537
 
                    # removes one 'b', and BASE vs OTHER removes the other)
1538
 
                    # If you include neither, 3-way creates a clean "MbabN" as
1539
 
                    # THIS adds one 'b', and OTHER does too.
1540
 
                    # It seems that having the line 2 times is better than
1541
 
                    # having it omitted. (Easier to manually delete than notice
1542
 
                    # it needs to be added.)
1543
 
                    raise AssertionError('Unknown state: %s' % (state,))
1544
 
        return base_lines
1545
 
 
1546
1457
 
1547
1458
class WeaveMerge(PlanWeaveMerge):
1548
1459
    """Weave merge that takes a VersionedFile and two versions as its input."""
1646
1557
            record.get_bytes_as(record.storage_kind) call.
1647
1558
        """
1648
1559
        self._bytes_iterator = bytes_iterator
1649
 
        self._kind_factory = {
1650
 
            'fulltext': fulltext_network_to_record,
1651
 
            'groupcompress-block': groupcompress.network_block_to_records,
1652
 
            'knit-ft-gz': knit.knit_network_to_record,
1653
 
            'knit-delta-gz': knit.knit_network_to_record,
1654
 
            'knit-annotated-ft-gz': knit.knit_network_to_record,
1655
 
            'knit-annotated-delta-gz': knit.knit_network_to_record,
1656
 
            'knit-delta-closure': knit.knit_delta_closure_to_records,
 
1560
        self._kind_factory = {'knit-ft-gz':knit.knit_network_to_record,
 
1561
            'knit-delta-gz':knit.knit_network_to_record,
 
1562
            'knit-annotated-ft-gz':knit.knit_network_to_record,
 
1563
            'knit-annotated-delta-gz':knit.knit_network_to_record,
 
1564
            'knit-delta-closure':knit.knit_delta_closure_to_records,
 
1565
            'fulltext':fulltext_network_to_record,
 
1566
            'groupcompress-block':groupcompress.network_block_to_records,
1657
1567
            }
1658
1568
 
1659
1569
    def read(self):