← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/multiparent.py

  • Committer: Aaron Bentley
  • Date: 2007-07-04 03:38:28 UTC
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: aaron.bentley@utoronto.ca-20070704033828-h1r2ppit8hrjvvtt
Add docs to multiparent.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/multiparent.py
59
59
 
60
60
 
61
61
class MultiParent(object):
 
62
    """A multi-parent diff"""
62
63
 
63
64
    def __init__(self, hunks=None):
64
65
        if hunks is not None:
163
164
 
164
165
    @classmethod
165
166
    def from_patch(cls, text):
 
167
        """Create a MultiParent from its string form"""
166
168
        return cls._from_patch(StringIO(text))
167
169
 
168
170
    @staticmethod
215
217
            start = end
216
218
 
217
219
    def num_lines(self):
 
220
        """The number of lines in the output text"""
218
221
        extra_n = 0
219
222
        for hunk in reversed(self.hunks):
220
223
            if isinstance(hunk, ParentText):
223
226
        return extra_n
224
227
 
225
228
    def is_snapshot(self):
 
229
        """Return true of this hunk is effectively a fulltext"""
226
230
        if len(self.hunks) != 1:
227
231
            return False
228
232
        return (isinstance(self.hunks[0], NewText))
273
277
 
274
278
 
275
279
class BaseVersionedFile(object):
276
 
    """VersionedFile skeleton for MultiParent"""
 
280
    """Pseudo-VersionedFile skeleton for MultiParent"""
277
281
 
278
282
    def __init__(self, snapshot_interval=25, max_snapshots=None):
279
283
        self._lines = {}
289
293
        return version in self._parents
290
294
 
291
295
    def do_snapshot(self, version_id, parent_ids):
 
296
        """Determine whether to perform a a snapshot for this version"""
292
297
        if self.snapshot_interval is None:
293
298
            return False
294
299
        if self.max_snapshots is not None and\
309
314
 
310
315
    def add_version(self, lines, version_id, parent_ids,
311
316
                    force_snapshot=None, single_parent=False):
 
317
        """Add a version to the versionedfile
 
318
 
 
319
        :param lines: The list of lines to add.  Must be split on '\n'.
 
320
        :param version_id: The version_id of the version to add
 
321
        :param force_snapshot: If true, force this version to be added as a
 
322
            snapshot version.  If false, force this version to be added as a
 
323
            diff.  If none, determine this automatically.
 
324
        :param single_parent: If true, use a single parent, rather than
 
325
            multiple parents.
 
326
        """
312
327
        if force_snapshot is None:
313
328
            do_snapshot = self.do_snapshot(version_id, parent_ids)
314
329
        else:
379
394
            pb.finished()
380
395
 
381
396
    def select_snapshots(self, vf):
 
397
        """Determine which versions to add as snapshots"""
382
398
        build_ancestors = {}
383
399
        descendants = {}
384
400
        snapshots = set()
405
421
        return [v for n, v in new_snapshots]
406
422
 
407
423
    def get_size_ranking(self):
 
424
        """Get versions ranked by size"""
408
425
        versions = []
409
426
        new_snapshots = set()
410
427
        for version_id in self.versions():
416
433
            versions.append((snapshot_len - diff_len, version_id))
417
434
        versions.sort()
418
435
        return versions
419
 
        return [v for n, v in versions]
420
436
 
421
437
    def import_diffs(self, vf):
 
438
        """Import the diffs from another pseudo-versionedfile"""
422
439
        for version_id in vf.versions():
423
440
            self.add_diff(vf.get_diff(version_id), version_id,
424
441
                          vf._parents[version_id])
425
442
 
426
443
    def get_build_ranking(self):
 
444
        """Return revisions sorted by how much they reduce build complexity"""
427
445
        could_avoid = {}
428
446
        referenced_by = {}
429
447
        for version_id in topo_iter(self):
473
491
 
474
492
 
475
493
class MultiMemoryVersionedFile(BaseVersionedFile):
 
494
    """Memory-backed pseudo-versionedfile"""
476
495
 
477
496
    def __init__(self, snapshot_interval=25, max_snapshots=None):
478
497
        BaseVersionedFile.__init__(self, snapshot_interval, max_snapshots)
490
509
 
491
510
 
492
511
class MultiVersionedFile(BaseVersionedFile):
 
512
    """Disk-backed pseudo-versionedfile"""
493
513
 
494
514
    def __init__(self, filename, snapshot_interval=25, max_snapshots=None):
495
515
        BaseVersionedFile.__init__(self, snapshot_interval, max_snapshots)