← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-02-23 17:00:36 UTC
  • mfrom: (4032.1.4 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090223170036-3q1v68ewdt8i0to5
(Marius Kruger) Remove all trailing whitespace and add tests to
        enforce this.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
68
68
 
69
69
class ContentFactory(object):
70
70
    """Abstract interface for insertion and retrieval from a VersionedFile.
71
 
    
 
71
 
72
72
    :ivar sha1: None, or the sha1 of the content fulltext.
73
73
    :ivar storage_kind: The native storage kind of this factory. One of
74
74
        'mpdiff', 'knit-annotated-ft', 'knit-annotated-delta', 'knit-ft',
158
158
 
159
159
class AbsentContentFactory(ContentFactory):
160
160
    """A placeholder content factory for unavailable texts.
161
 
    
 
161
 
162
162
    :ivar sha1: None.
163
163
    :ivar storage_kind: 'absent'.
164
164
    :ivar key: The key of this content. Each key is a tuple with a single
200
200
 
201
201
class VersionedFile(object):
202
202
    """Versioned text file storage.
203
 
    
 
203
 
204
204
    A versioned file manages versions of line-based text files,
205
205
    keeping track of the originating version for each line.
206
206
 
244
244
    def insert_record_stream(self, stream):
245
245
        """Insert a record stream into this versioned file.
246
246
 
247
 
        :param stream: A stream of records to insert. 
 
247
        :param stream: A stream of records to insert.
248
248
        :return: None
249
249
        :seealso VersionedFile.get_record_stream:
250
250
        """
269
269
            the data back accurately. (Checking the lines have been split
270
270
            correctly is expensive and extremely unlikely to catch bugs so it
271
271
            is not done at runtime unless check_content is True.)
272
 
        :param parent_texts: An optional dictionary containing the opaque 
 
272
        :param parent_texts: An optional dictionary containing the opaque
273
273
            representations of some or all of the parents of version_id to
274
274
            allow delta optimisations.  VERY IMPORTANT: the texts must be those
275
275
            returned by add_lines or data corruption can be caused.
303
303
        parent_texts=None, nostore_sha=None, random_id=False,
304
304
        check_content=True, left_matching_blocks=None):
305
305
        """Add lines to the versioned file, allowing ghosts to be present.
306
 
        
 
306
 
307
307
        This takes the same parameters as add_lines and returns the same.
308
308
        """
309
309
        self._check_write_ok()
333
333
 
334
334
    def get_format_signature(self):
335
335
        """Get a text description of the data encoding in this file.
336
 
        
 
336
 
337
337
        :since: 0.90
338
338
        """
339
339
        raise NotImplementedError(self.get_format_signature)
460
460
        if isinstance(version_ids, basestring):
461
461
            version_ids = [version_ids]
462
462
        raise NotImplementedError(self.get_ancestry)
463
 
        
 
463
 
464
464
    def get_ancestry_with_ghosts(self, version_ids):
465
465
        """Return a list of all ancestors of given version(s). This
466
466
        will not include the null revision.
467
467
 
468
468
        Must raise RevisionNotPresent if any of the given versions are
469
469
        not present in file history.
470
 
        
 
470
 
471
471
        Ghosts that are known about will be included in ancestry list,
472
472
        but are not explicitly marked.
473
473
        """
474
474
        raise NotImplementedError(self.get_ancestry_with_ghosts)
475
 
    
 
475
 
476
476
    def get_parent_map(self, version_ids):
477
477
        """Get a map of the parents of version_ids.
478
478
 
541
541
        unchanged   Alive in both a and b (possibly created in both)
542
542
        new-a       Created in a
543
543
        new-b       Created in b
544
 
        ghost-a     Killed in a, unborn in b    
 
544
        ghost-a     Killed in a, unborn in b
545
545
        ghost-b     Killed in b, unborn in a
546
546
        irrelevant  Not in either revision
547
547
        """
548
548
        raise NotImplementedError(VersionedFile.plan_merge)
549
 
        
 
549
 
550
550
    def weave_merge(self, plan, a_marker=TextMerge.A_MARKER,
551
551
                    b_marker=TextMerge.B_MARKER):
552
552
        return PlanWeaveMerge(plan, a_marker, b_marker).merge_lines()[0]
554
554
 
555
555
class RecordingVersionedFilesDecorator(object):
556
556
    """A minimal versioned files that records calls made on it.
557
 
    
 
557
 
558
558
    Only enough methods have been added to support tests using it to date.
559
559
 
560
560
    :ivar calls: A list of the calls made; can be reset at any time by
563
563
 
564
564
    def __init__(self, backing_vf):
565
565
        """Create a RecordingVersionedFilesDecorator decorating backing_vf.
566
 
        
 
566
 
567
567
        :param backing_vf: The versioned file to answer all methods.
568
568
        """
569
569
        self._backing_vf = backing_vf
655
655
 
656
656
    def unmap(self, partition_id):
657
657
        """Map a partitioned storage id back to a key prefix.
658
 
        
 
658
 
659
659
        :param partition_id: The underlying partition id.
660
660
        :return: As much of a key (or prefix) as is derivable from the partition
661
661
            id.
693
693
 
694
694
class PrefixMapper(URLEscapeMapper):
695
695
    """A key mapper that extracts the first component of a key.
696
 
    
 
696
 
697
697
    This mapper is for use with a transport based backend.
698
698
    """
699
699
 
732
732
 
733
733
class HashEscapedPrefixMapper(HashPrefixMapper):
734
734
    """Combines the escaped first component of a key with a hash.
735
 
    
 
735
 
736
736
    This mapper is for use with a transport based backend.
737
737
    """
738
738
 
804
804
            the data back accurately. (Checking the lines have been split
805
805
            correctly is expensive and extremely unlikely to catch bugs so it
806
806
            is not done at runtime unless check_content is True.)
807
 
        :param parent_texts: An optional dictionary containing the opaque 
 
807
        :param parent_texts: An optional dictionary containing the opaque
808
808
            representations of some or all of the parents of version_id to
809
809
            allow delta optimisations.  VERY IMPORTANT: the texts must be those
810
810
            returned by add_lines or data corruption can be caused.
943
943
    def insert_record_stream(self, stream):
944
944
        """Insert a record stream into this container.
945
945
 
946
 
        :param stream: A stream of records to insert. 
 
946
        :param stream: A stream of records to insert.
947
947
        :return: None
948
948
        :seealso VersionedFile.get_record_stream:
949
949
        """
1177
1177
    def insert_record_stream(self, stream):
1178
1178
        """Insert a record stream into this container.
1179
1179
 
1180
 
        :param stream: A stream of records to insert. 
 
1180
        :param stream: A stream of records to insert.
1181
1181
        :return: None
1182
1182
        :seealso VersionedFile.get_record_stream:
1183
1183
        """
1340
1340
 
1341
1341
class PlanWeaveMerge(TextMerge):
1342
1342
    """Weave merge that takes a plan as its input.
1343
 
    
 
1343
 
1344
1344
    This exists so that VersionedFile.plan_merge is implementable.
1345
1345
    Most callers will want to use WeaveMerge instead.
1346
1346
    """
1367
1367
                yield(lines_a,)
1368
1368
            else:
1369
1369
                yield (lines_a, lines_b)
1370
 
       
 
1370
 
1371
1371
        # We previously considered either 'unchanged' or 'killed-both' lines
1372
1372
        # to be possible places to resynchronize.  However, assuming agreement
1373
1373
        # on killed-both lines may be too aggressive. -- mbp 20060324
1379
1379
                lines_a = []
1380
1380
                lines_b = []
1381
1381
                ch_a = ch_b = False
1382
 
                
 
1382
 
1383
1383
            if state == 'unchanged':
1384
1384
                if line:
1385
1385
                    yield ([line],)
1412
1412
class WeaveMerge(PlanWeaveMerge):
1413
1413
    """Weave merge that takes a VersionedFile and two versions as its input."""
1414
1414
 
1415
 
    def __init__(self, versionedfile, ver_a, ver_b, 
 
1415
    def __init__(self, versionedfile, ver_a, ver_b,
1416
1416
        a_marker=PlanWeaveMerge.A_MARKER, b_marker=PlanWeaveMerge.B_MARKER):
1417
1417
        plan = versionedfile.plan_merge(ver_a, ver_b)
1418
1418
        PlanWeaveMerge.__init__(self, plan, a_marker, b_marker)
1419
1419
 
1420
1420
 
1421
1421
class VirtualVersionedFiles(VersionedFiles):
1422
 
    """Dummy implementation for VersionedFiles that uses other functions for 
 
1422
    """Dummy implementation for VersionedFiles that uses other functions for
1423
1423
    obtaining fulltexts and parent maps.
1424
1424
 
1425
 
    This is always on the bottom of the stack and uses string keys 
 
1425
    This is always on the bottom of the stack and uses string keys
1426
1426
    (rather than tuples) internally.
1427
1427
    """
1428
1428
 
1430
1430
        """Create a VirtualVersionedFiles.
1431
1431
 
1432
1432
        :param get_parent_map: Same signature as Repository.get_parent_map.
1433
 
        :param get_lines: Should return lines for specified key or None if 
 
1433
        :param get_lines: Should return lines for specified key or None if
1434
1434
                          not available.
1435
1435
        """
1436
1436
        super(VirtualVersionedFiles, self).__init__()
1437
1437
        self._get_parent_map = get_parent_map
1438
1438
        self._get_lines = get_lines
1439
 
        
 
1439
 
1440
1440
    def check(self, progressbar=None):
1441
1441
        """See VersionedFiles.check.
1442
1442