← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/weave.py

  • Committer: Martin Pool
  • Date: 2005-07-11 04:28:44 UTC
  • Revision ID: mbp@sourcefrog.net-20050711042844-2a2dc06fedcfa77a
- weave stores only direct parents, and calculates and memoizes expansion as needed

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/weave.py
139
139
      version.
140
140
 
141
141
    _l
142
 
        Text of the weave. 
 
142
        Text of the weave.
143
143
 
144
144
    _v
145
 
        List of versions, indexed by index number.
 
145
        List of parents, indexed by version number.
 
146
        It is only necessary to store the minimal set of parents for
 
147
        each version; the parent's parents are implied.
146
148
 
147
 
        For each version we store the set (included_versions), which
148
 
        lists the previous versions also considered active; the
149
 
        versions included in those versions are included transitively.
150
 
        So new versions created from nothing list []; most versions
151
 
        have a single entry; some have more.
 
149
    _i
 
150
        Full set of inclusions for each revision.
152
151
 
153
152
    _sha1s
154
153
        List of hex SHA-1 of each version, or None if not recorded.
157
156
        self._l = []
158
157
        self._v = []
159
158
        self._sha1s = []
 
159
        self._i = {}
160
160
 
161
161
 
162
162
    def __eq__(self, other):
176
176
        Returns the index number of the newly added version.
177
177
 
178
178
        parents
179
 
            List or set of parent version numbers.  This must normally include
180
 
            the parents and the parent's parents, or wierd things might happen.
181
 
 
 
179
            List or set of direct parent version numbers.
 
180
            
182
181
        text
183
182
            Sequence of lines to be added in the new version."""
184
183
        ## self._check_versions(parents)
193
192
        del s
194
193
 
195
194
        if parents:
196
 
            delta = self._delta(self.inclusions(parents), text)
 
195
            ancestors = self.inclusions(parents)
 
196
            delta = self._delta(ancestors, text)
197
197
 
198
198
            # offset gives the number of lines that have been inserted
199
199
            # into the weave up to the current point; if the original edit instruction
238
238
        return idx
239
239
 
240
240
 
 
241
    def _expand(self, version):
 
242
        if version in self._i:
 
243
            return self._i[version]
 
244
        else:
 
245
            i = set([version])
 
246
            for pv in self._v[version]:
 
247
                i.update(self._expand(pv))
 
248
            self._i[version] = i
 
249
            return i
 
250
 
 
251
 
241
252
    def inclusions(self, versions):
242
253
        """Expand out everything included by versions."""
243
254
        i = set(versions)
244
 
        for v in versions:
245
 
            try:
246
 
                i.update(self._v[v])
247
 
            except IndexError:
248
 
                raise ValueError("version %d not present in weave" % v)
 
255
        try:
 
256
            for v in versions:
 
257
                i.update(self._expand(v))
 
258
        except IndexError:
 
259
            raise ValueError("version %d not present in weave" % v)
249
260
        return i
250
261
 
251
262
 
274
285
 
275
286
    def _addversion(self, parents):
276
287
        if parents:
277
 
            self._v.append(frozenset(parents))
 
288
            self._v.append(parents)
278
289
        else:
279
290
            self._v.append(frozenset())
280
291
 
308
319
 
309
320
        The index indicates when the line originated in the weave."""
310
321
        included = self.inclusions([version])
311
 
        for origin, lineno, text in self._extract(included):
 
322
        for origin, lineno, text in self._extract(self.inclusions(included)):
312
323
            yield origin, text
313
324
 
314
325
 
381
392
    def mash_iter(self, included):
382
393
        """Return composed version of multiple included versions."""
383
394
        included = frozenset(included)
384
 
        for origin, lineno, text in self._extract(included):
 
395
        for origin, lineno, text in self._extract(self.inclusions(included)):
385
396
            yield text
386
397
 
387
398
 
469
480
        # basis a list of (origin, lineno, line)
470
481
        basis_lineno = []
471
482
        basis_lines = []
472
 
        for origin, lineno, line in self._extract(included):
 
483
        for origin, lineno, line in self._extract(self.inclusions(included)):
473
484
            basis_lineno.append(lineno)
474
485
            basis_lines.append(line)
475
486
 
525
536
        bytes = sum((len(a) for a in text))
526
537
        sha1 = w._sha1s[i]
527
538
        print '%6d %6d %8d %40s' % (i, lines, bytes, sha1),
528
 
        print ', '.join(map(str, w.minimal_parents(i)))
 
539
        for pv in w._v[i]:
 
540
            print pv,
 
541
        print
529
542
        total += bytes
530
543
 
531
544
    print >>out, "versions total %d bytes" % total
634
647
        w = readit()
635
648
        w.check()
636
649
 
 
650
    elif cmd == 'inclusions':
 
651
        w = readit()
 
652
        print ' '.join(map(str, w.inclusions([int(argv[3])])))
 
653
 
 
654
    elif cmd == 'parents':
 
655
        w = readit()
 
656
        print ' '.join(map(str, w._v[int(argv[3])]))
 
657
 
637
658
    elif cmd == 'merge':
638
659
        if len(argv) != 5:
639
660
            usage()