← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

Reconcile NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
55
55
    Texts are identified by a version-id string.
56
56
    """
57
57
 
58
 
    def __init__(self, access_mode):
59
 
        self.finished = False
60
 
        self._access_mode = access_mode
61
 
 
62
58
    @staticmethod
63
59
    def check_not_reserved_id(version_id):
64
60
        revision.check_not_reserved_id(version_id)
161
157
            if '\n' in line[:-1]:
162
158
                raise errors.BzrBadParameterContainsNewline("lines")
163
159
 
164
 
    def _check_write_ok(self):
165
 
        """Is the versioned file marked as 'finished' ? Raise if it is."""
166
 
        if self.finished:
167
 
            raise errors.OutSideTransaction()
168
 
        if self._access_mode != 'w':
169
 
            raise errors.ReadOnlyObjectDirtiedError(self)
170
 
 
 
160
    @deprecated_method(one_four)
171
161
    def enable_cache(self):
172
162
        """Tell this versioned file that it should cache any data it reads.
173
163
        
175
165
        """
176
166
        pass
177
167
    
 
168
    @deprecated_method(one_four)
178
169
    def clear_cache(self):
179
170
        """Remove any data cached in the versioned file object.
180
171
 
182
173
        """
183
174
        pass
184
175
 
 
176
    @deprecated_method(one_four)
185
177
    def clone_text(self, new_version_id, old_version_id, parents):
186
178
        """Add an identical text to old_version_id as new_version_id.
187
179
 
191
183
        Must raise RevisionAlreadyPresent if the new version is
192
184
        already present in file history."""
193
185
        self._check_write_ok()
194
 
        return self._clone_text(new_version_id, old_version_id, parents)
195
 
 
196
 
    def _clone_text(self, new_version_id, old_version_id, parents):
197
 
        """Helper function to do the _clone_text work."""
198
 
        raise NotImplementedError(self.clone_text)
 
186
        return self.add_lines(new_version_id, parents,
 
187
            self.get_lines(old_version_id))
199
188
 
200
189
    def get_format_signature(self):
201
190
        """Get a text description of the data encoding in this file.
282
271
            if expected_sha1 != sha1:
283
272
                raise errors.VersionedFileInvalidChecksum(version)
284
273
 
 
274
    @deprecated_method(one_four)
285
275
    def get_sha1(self, version_id):
286
276
        """Get the stored sha1 sum for the given revision.
287
277
        
288
278
        :param version_id: The name of the version to lookup
289
279
        """
290
 
        raise NotImplementedError(self.get_sha1)
 
280
        return self.get_sha1s([version_id])[0]
291
281
 
292
282
    def get_sha1s(self, version_ids):
293
283
        """Get the stored sha1 sums for the given revisions.
297
287
        """
298
288
        raise NotImplementedError(self.get_sha1s)
299
289
 
300
 
    def get_suffixes(self):
301
 
        """Return the file suffixes associated with this versioned file."""
302
 
        raise NotImplementedError(self.get_suffixes)
303
 
    
304
290
    def get_text(self, version_id):
305
291
        """Return version contents as a text string.
306
292
 
353
339
        but are not explicitly marked.
354
340
        """
355
341
        raise NotImplementedError(self.get_ancestry_with_ghosts)
356
 
        
 
342
    
 
343
    @deprecated_method(one_four)
357
344
    def get_graph(self, version_ids=None):
358
345
        """Return a graph from the versioned file. 
359
346
        
362
349
                            None means retrieve all versions.
363
350
        """
364
351
        if version_ids is None:
365
 
            return dict(self.iter_parents(self.versions()))
366
 
        result = {}
367
 
        pending = set(version_ids)
368
 
        while pending:
369
 
            this_iteration = pending
370
 
            pending = set()
371
 
            for version, parents in self.iter_parents(this_iteration):
372
 
                result[version] = parents
373
 
                for parent in parents:
374
 
                    if parent in result:
375
 
                        continue
376
 
                    pending.add(parent)
 
352
            result = self.get_parent_map(self.versions())
 
353
        else:
 
354
            result = {}
 
355
            pending = set(version_ids)
 
356
            while pending:
 
357
                this_iteration = pending
 
358
                pending = set()
 
359
                parents = self.get_parent_map(this_iteration)
 
360
                for version, parents in parents.iteritems():
 
361
                    result[version] = parents
 
362
                    for parent in parents:
 
363
                        if parent in result:
 
364
                            continue
 
365
                        pending.add(parent)
 
366
        references = set()
 
367
        for parents in result.itervalues():
 
368
            references.update(parents)
 
369
        existing_parents = self.get_parent_map(references)
 
370
        for key, parents in result.iteritems():
 
371
            present_parents = [parent for parent in parents if parent in
 
372
                existing_parents]
 
373
            result[key] = tuple(present_parents)
377
374
        return result
378
375
 
379
376
    @deprecated_method(one_four)
425
422
        except KeyError:
426
423
            raise errors.RevisionNotPresent(version_id, self)
427
424
 
 
425
    @deprecated_method(one_four)
428
426
    def annotate_iter(self, version_id):
429
427
        """Yield list of (version-id, line) pairs for the specified
430
428
        version.
432
430
        Must raise RevisionNotPresent if the given version is
433
431
        not present in file history.
434
432
        """
435
 
        raise NotImplementedError(self.annotate_iter)
 
433
        return iter(self.annotate(version_id))
436
434
 
437
435
    def annotate(self, version_id):
438
 
        return list(self.annotate_iter(version_id))
 
436
        """Return a list of (version-id, line) tuples for version_id.
 
437
 
 
438
        :raise RevisionNotPresent: If the given version is
 
439
        not present in file history.
 
440
        """
 
441
        raise NotImplementedError(self.annotate)
439
442
 
440
443
    def join(self, other, pb=None, msg=None, version_ids=None,
441
444
             ignore_missing=False):
477
480
        """
478
481
        raise NotImplementedError(self.iter_lines_added_or_present_in_versions)
479
482
 
 
483
    @deprecated_method(one_four)
480
484
    def iter_parents(self, version_ids):
481
485
        """Iterate through the parents for many version ids.
482
486
 
488
492
        """
489
493
        return self.get_parent_map(version_ids).iteritems()
490
494
 
491
 
    def transaction_finished(self):
492
 
        """The transaction that this file was opened in has finished.
493
 
 
494
 
        This records self.finished = True and should cause all mutating
495
 
        operations to error.
496
 
        """
497
 
        self.finished = True
498
 
 
499
495
    def plan_merge(self, ver_a, ver_b):
500
496
        """Return pseudo-annotation indicating how the two versions merge.
501
497