← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/knit.py

  • Committer: Robert Collins
  • Date: 2007-07-19 01:20:49 UTC
  • mto: (2592.5.3 pack-repository)
  • mto: This revision was merged to the branch mainline in revision 2933.
  • Revision ID: robertc@robertcollins.net-20070719012049-xgdzwfpnnmoqeqjp
A knit iter_parents API.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/knit.py
911
911
 
912
912
        pb.update('Walking content.', total, total)
913
913
        
 
914
    def iter_parents(self, version_ids):
 
915
        """Iterate through the parents for many version ids.
 
916
 
 
917
        :param version_ids: An iterable yielding version_ids.
 
918
        :return: An iterator that yields (version_id, parents). Requested 
 
919
            version_ids not present in the versioned file are simply skipped.
 
920
            The order is undefined, allowing for different optimisations in
 
921
            the underlying implementation.
 
922
        """
 
923
        version_ids = [osutils.safe_revision_id(version_id) for
 
924
            version_id in version_ids]
 
925
        return self._index.iter_parents(version_ids)
 
926
 
914
927
    def num_versions(self):
915
928
        """See VersionedFile.num_versions()."""
916
929
        return self._index.num_versions()
1210
1223
                graph[version] = parents
1211
1224
        return topo_sort(graph.items())
1212
1225
 
 
1226
    def iter_parents(self, version_ids):
 
1227
        """Iterate through the parents for many version ids.
 
1228
 
 
1229
        :param version_ids: An iterable yielding version_ids.
 
1230
        :return: An iterator that yields (version_id, parents). Requested 
 
1231
            version_ids not present in the versioned file are simply skipped.
 
1232
            The order is undefined, allowing for different optimisations in
 
1233
            the underlying implementation.
 
1234
        """
 
1235
        for version_id in version_ids:
 
1236
            try:
 
1237
                yield version_id, tuple(self.get_parents(version_id))
 
1238
            except KeyError:
 
1239
                pass
 
1240
 
1213
1241
    def num_versions(self):
1214
1242
        return len(self._history)
1215
1243
 
1339
1367
            raise KnitCorrupt(self, "Cannot do delta compression without "
1340
1368
                "parent tracking.")
1341
1369
 
1342
 
    def _get_entries(self, version_ids):
 
1370
    def _get_entries(self, version_ids, check_present=False):
1343
1371
        """Get the entries for version_ids."""
 
1372
        version_ids = set(version_ids)
 
1373
        found_keys = set()
1344
1374
        if self._parents:
1345
1375
            for node in self._graph_index.iter_entries(version_ids):
1346
1376
                yield node
 
1377
                found_keys.add(node[0])
1347
1378
        else:
1348
1379
            # adapt parentless index to the rest of the code.
1349
1380
            for node in self._graph_index.iter_entries(version_ids):
1350
1381
                yield node[0], node[1], ()
 
1382
                found_keys.add(node[0])
 
1383
        if check_present:
 
1384
            missing_keys = version_ids.difference(found_keys)
 
1385
            if missing_keys:
 
1386
                raise RevisionNotPresent(missing_keys.pop(), self)
1351
1387
 
1352
1388
    def _present_keys(self, version_ids):
1353
1389
        return set([
1431
1467
        return [(key, refs[0]) for (key, value, refs) in 
1432
1468
            self._graph_index.iter_all_entries()]
1433
1469
 
 
1470
    def iter_parents(self, version_ids):
 
1471
        """Iterate through the parents for many version ids.
 
1472
 
 
1473
        :param version_ids: An iterable yielding version_ids.
 
1474
        :return: An iterator that yields (version_id, parents). Requested 
 
1475
            version_ids not present in the versioned file are simply skipped.
 
1476
            The order is undefined, allowing for different optimisations in
 
1477
            the underlying implementation.
 
1478
        """
 
1479
        if self._parents:
 
1480
            all_nodes = set(self._get_entries(version_ids))
 
1481
            all_parents = set()
 
1482
            present_parents = set()
 
1483
            for node in all_nodes:
 
1484
                all_parents.update(node[2][0])
 
1485
                # any node we are querying must be present
 
1486
                present_parents.add(node[0])
 
1487
            unknown_parents = all_parents.difference(present_parents)
 
1488
            present_parents.update(self._present_keys(unknown_parents))
 
1489
            for node in all_nodes:
 
1490
                parents = []
 
1491
                for parent in node[2][0]:
 
1492
                    if parent in present_parents:
 
1493
                        parents.append(parent)
 
1494
                yield node[0], tuple(parents)
 
1495
        else:
 
1496
            for node in self._get_entries(version_ids):
 
1497
                yield node[0], ()
 
1498
 
1434
1499
    def num_versions(self):
1435
1500
        return len(list(self._graph_index.iter_all_entries()))
1436
1501
 
1442
1507
    
1443
1508
    def has_version(self, version_id):
1444
1509
        """True if the version is in the index."""
1445
 
        return len(list(self._get_entries([version_id]))) == 1
 
1510
        return len(self._present_keys([version_id])) == 1
1446
1511
 
1447
1512
    def get_position(self, version_id):
1448
1513
        """Return data position and size of specified version."""
1481
1546
 
1482
1547
    def get_parents(self, version_id):
1483
1548
        """Return parents of specified version ignoring ghosts."""
1484
 
        if not self._parents:
1485
 
            return ()
1486
 
        parents = self.get_parents_with_ghosts(version_id)
1487
 
        present_parents = self._present_keys(parents)
1488
 
        return [key for key in parents if key in present_parents]
 
1549
        parents = list(self.iter_parents([version_id]))
 
1550
        if not parents:
 
1551
            # missing key
 
1552
            raise errors.RevisionNotPresent(version_id, self)
 
1553
        return parents[0][1]
1489
1554
 
1490
1555
    def get_parents_with_ghosts(self, version_id):
1491
1556
        """Return parents of specified version with ghosts."""
 
1557
        nodes = list(self._get_entries([version_id], check_present=True))
1492
1558
        if not self._parents:
1493
1559
            return ()
1494
 
        return self._get_node(version_id)[2][0]
 
1560
        return nodes[0][2][0]
1495
1561
 
1496
1562
    def check_versions_present(self, version_ids):
1497
1563
        """Check that all specified versions are present."""