← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/knit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-26 03:06:52 UTC
  • mfrom: (3287.5.10 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080326030652-vgwdkwda9mi8s200
Deprecate VersionedFile.get_parents. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/knit.py
575
575
                fulltext_size = size
576
576
                break
577
577
            delta_size += size
578
 
            delta_parents = self._index.get_parents(parent)
 
578
            delta_parents = self._index.get_parent_map([parent])[parent]
579
579
        else:
580
580
            # We couldn't find a fulltext, so we must create a new one
581
581
            return False
720
720
    def get_delta(self, version_id):
721
721
        """Get a delta for constructing version from some other version."""
722
722
        self.check_not_reserved_id(version_id)
723
 
        parents = self.get_parents(version_id)
 
723
        parents = self.get_parent_map([version_id])[version_id]
724
724
        if len(parents):
725
725
            parent = parents[0]
726
726
        else:
977
977
        self._index.check_versions_present(version_ids)
978
978
 
979
979
    def _add_lines_with_ghosts(self, version_id, parents, lines, parent_texts,
980
 
        nostore_sha, random_id, check_content):
 
980
        nostore_sha, random_id, check_content, left_matching_blocks):
981
981
        """See VersionedFile.add_lines_with_ghosts()."""
982
982
        self._check_add(version_id, lines, random_id, check_content)
983
983
        return self._add(version_id, lines, parents, self.delta,
984
 
            parent_texts, None, nostore_sha, random_id)
 
984
            parent_texts, left_matching_blocks, nostore_sha, random_id)
985
985
 
986
986
    def _add_lines(self, version_id, parents, lines, parent_texts,
987
987
        left_matching_blocks, nostore_sha, random_id, check_content):
1258
1258
        """See VersionedFile.annotate_iter."""
1259
1259
        return self.factory.annotate_iter(self, version_id)
1260
1260
 
1261
 
    def get_parents(self, version_id):
1262
 
        """See VersionedFile.get_parents."""
1263
 
        # perf notes:
1264
 
        # optimism counts!
1265
 
        # 52554 calls in 1264 872 internal down from 3674
1266
 
        try:
1267
 
            return self._index.get_parents(version_id)
1268
 
        except KeyError:
1269
 
            raise RevisionNotPresent(version_id, self.filename)
1270
 
 
1271
 
    def get_parents_with_ghosts(self, version_id):
1272
 
        """See VersionedFile.get_parents."""
1273
 
        try:
1274
 
            return self._index.get_parents_with_ghosts(version_id)
1275
 
        except KeyError:
1276
 
            raise RevisionNotPresent(version_id, self.filename)
 
1261
    def get_parent_map(self, version_ids):
 
1262
        """See VersionedFile.get_parent_map."""
 
1263
        return self._index.get_parent_map(version_ids)
1277
1264
 
1278
1265
    def get_ancestry(self, versions, topo_sorted=True):
1279
1266
        """See VersionedFile.get_ancestry."""
1529
1516
            The order is undefined, allowing for different optimisations in
1530
1517
            the underlying implementation.
1531
1518
        """
1532
 
        for version_id in version_ids:
1533
 
            try:
1534
 
                yield version_id, tuple(self.get_parents(version_id))
1535
 
            except KeyError:
1536
 
                pass
 
1519
        parent_map = self.get_parent_map(version_ids)
 
1520
        parent_map_set = set(parent_map)
 
1521
        unknown_existence = set()
 
1522
        for parents in parent_map.itervalues():
 
1523
            unknown_existence.update(parents)
 
1524
        unknown_existence.difference_update(parent_map_set)
 
1525
        present_parents = set(self.get_parent_map(unknown_existence))
 
1526
        present_parents.update(parent_map_set)
 
1527
        for version_id, parents in parent_map.iteritems():
 
1528
            parents = tuple(parent for parent in parents
 
1529
                if parent in present_parents)
 
1530
            yield version_id, parents
1537
1531
 
1538
1532
    def num_versions(self):
1539
1533
        return len(self._history)
1582
1576
                assert isinstance(line, str), \
1583
1577
                    'content must be utf-8 encoded: %r' % (line,)
1584
1578
                lines.append(line)
1585
 
                self._cache_version(version_id, options, pos, size, parents)
 
1579
                self._cache_version(version_id, options, pos, size, tuple(parents))
1586
1580
            if not self._need_to_create:
1587
1581
                self._transport.append_bytes(self._filename, ''.join(lines))
1588
1582
            else:
1637
1631
        """
1638
1632
        return self._cache[version_id][1]
1639
1633
 
1640
 
    def get_parents(self, version_id):
1641
 
        """Return parents of specified version ignoring ghosts."""
1642
 
        return [parent for parent in self._cache[version_id][4] 
1643
 
                if parent in self._cache]
 
1634
    def get_parent_map(self, version_ids):
 
1635
        """Passed through to by KnitVersionedFile.get_parent_map."""
 
1636
        result = {}
 
1637
        for version_id in version_ids:
 
1638
            try:
 
1639
                result[version_id] = tuple(self._cache[version_id][4])
 
1640
            except KeyError:
 
1641
                pass
 
1642
        return result
1644
1643
 
1645
1644
    def get_parents_with_ghosts(self, version_id):
1646
1645
        """Return parents of specified version with ghosts."""
1647
 
        return self._cache[version_id][4] 
 
1646
        try:
 
1647
            return self.get_parent_map([version_id])[version_id]
 
1648
        except KeyError:
 
1649
            raise RevisionNotPresent(version_id, self)
1648
1650
 
1649
1651
    def check_versions_present(self, version_ids):
1650
1652
        """Check that all specified versions are present."""
1935
1937
            options.append('no-eol')
1936
1938
        return options
1937
1939
 
1938
 
    def get_parents(self, version_id):
1939
 
        """Return parents of specified version ignoring ghosts."""
1940
 
        parents = list(self.iter_parents([version_id]))
1941
 
        if not parents:
1942
 
            # missing key
1943
 
            raise errors.RevisionNotPresent(version_id, self)
1944
 
        return parents[0][1]
 
1940
    def get_parent_map(self, version_ids):
 
1941
        """Passed through to by KnitVersionedFile.get_parent_map."""
 
1942
        nodes = self._get_entries(self._version_ids_to_keys(version_ids))
 
1943
        result = {}
 
1944
        if self._parents:
 
1945
            for node in nodes:
 
1946
                result[node[1][0]] = self._keys_to_version_ids(node[3][0])
 
1947
        else:
 
1948
            for node in nodes:
 
1949
                result[node[1][0]] = ()
 
1950
        return result
1945
1951
 
1946
1952
    def get_parents_with_ghosts(self, version_id):
1947
1953
        """Return parents of specified version with ghosts."""
1948
 
        nodes = list(self._get_entries(self._version_ids_to_keys([version_id]),
1949
 
            check_present=True))
1950
 
        if not self._parents:
1951
 
            return ()
1952
 
        return self._keys_to_version_ids(nodes[0][3][0])
 
1954
        try:
 
1955
            return self.get_parent_map([version_id])[version_id]
 
1956
        except KeyError:
 
1957
            raise RevisionNotPresent(version_id, self)
1953
1958
 
1954
1959
    def check_versions_present(self, version_ids):
1955
1960
        """Check that all specified versions are present."""
2373
2378
        except KeyError:
2374
2379
            return self.backing_index.get_options(version_id)
2375
2380
 
 
2381
    def get_parent_map(self, version_ids):
 
2382
        """Passed through to by KnitVersionedFile.get_parent_map."""
 
2383
        result = {}
 
2384
        pending_ids = set()
 
2385
        for version_id in version_ids:
 
2386
            try:
 
2387
                result[version_id] = self._by_version[version_id][2]
 
2388
            except KeyError:
 
2389
                pending_ids.add(version_id)
 
2390
        result.update(self.backing_index.get_parent_map(pending_ids))
 
2391
        return result
 
2392
 
2376
2393
    def get_parents_with_ghosts(self, version_id):
2377
2394
        """Return parents of specified version with ghosts."""
2378
2395
        try:
2379
 
            return self._by_version[version_id][2]
 
2396
            return self.get_parent_map([version_id])[version_id]
2380
2397
        except KeyError:
2381
 
            return self.backing_index.get_parents_with_ghosts(version_id)
 
2398
            raise RevisionNotPresent(version_id, self)
2382
2399
 
2383
2400
    def get_position(self, version_id):
2384
2401
        """Return details needed to access the version.
2834
2851
            # do the join:
2835
2852
            count = 0
2836
2853
            total = len(version_list)
 
2854
            parent_map = self.source.get_parent_map(version_list)
2837
2855
            for version_id in version_list:
2838
2856
                pb.update("Converting to knit", count, total)
2839
 
                parents = self.source.get_parents(version_id)
 
2857
                parents = parent_map[version_id]
2840
2858
                # check that its will be a consistent copy:
2841
2859
                for parent in parents:
2842
2860
                    # if source has the parent, we must already have it