~bzr-pqm/bzr/bzr.dev : revision 2592.3.64

1386

if self._parents:

1387

for node in self._graph_index.iter_entries(keys):

1388

yield node

1389

found_keys.add(node[0])

1389

found_keys.add(node[1])

1390

else:

1391

# adapt parentless index to the rest of the code.

1392

for node in self._graph_index.iter_entries(keys):

1393

yield node[0], node[1], ()

1394

found_keys.add(node[0])

1393

yield node[0], node[1], node[2], ()

1394

found_keys.add(node[1])

1395

if check_present:

1396

missing_keys = keys.difference(found_keys)

1397

if missing_keys:

1399

1400

def _present_keys(self, version_ids):

1401

return set([

1402

node[0] for node in self._get_entries(version_ids)])

1402

node[1] for node in self._get_entries(version_ids)])

1403

1404

def _parentless_ancestry(self, versions):

1405

"""Honour the get_ancestry API for parentless knit indices."""

1427

new_nodes = self._get_entries(this_iteration)

1428

found = set()

1429

pending = set()

1430

for (key, value, node_refs) in new_nodes:

1430

for (index, key, value, node_refs) in new_nodes:

1431

# dont ask for ghosties - otherwise

1432

# we we can end up looping with pending

1433

# being entirely ghosted.

1464

this_iteration = pending

1465

new_nodes = self._get_entries(this_iteration)

1466

pending = set()

1467

for (key, value, node_refs) in new_nodes:

1467

for (index, key, value, node_refs) in new_nodes:

1468

graph[key] = node_refs[0]

1469

# queue parents

1470

for parent in graph[key]:

1488

if not self._parents:

1489

return [(key, ()) for key in self.get_versions()]

1490

result = []

1491

for key, value, refs in self._graph_index.iter_all_entries():

1491

for index, key, value, refs in self._graph_index.iter_all_entries():

1492

result.append((key[0], tuple([ref[0] for ref in refs[0]])))

1493

return result

1494

1506

all_parents = set()

1507

present_parents = set()

1508

for node in all_nodes:

1509

all_parents.update(node[2][0])

1509

all_parents.update(node[3][0])

1510

# any node we are querying must be present

1511

present_parents.add(node[0])

1511

present_parents.add(node[1])

1512

unknown_parents = all_parents.difference(present_parents)

1513

present_parents.update(self._present_keys(unknown_parents))

1514

for node in all_nodes:

1515

parents = []

1516

for parent in node[2][0]:

1516

for parent in node[3][0]:

1517

if parent in present_parents:

1518

parents.append(parent[0])

1519

yield node[0][0], tuple(parents)

1519

yield node[1][0], tuple(parents)

1520

else:

1521

for node in self._get_entries(self._version_ids_to_keys(version_ids)):

1522

yield node[0][0], ()

1522

yield node[1][0], ()

1523

1524

def num_versions(self):

1525

return len(list(self._graph_index.iter_all_entries()))

1528

1529

def get_versions(self):

1530

"""Get all the versions in the file. not topologically sorted."""

1531

return [node[0][0] for node in self._graph_index.iter_all_entries()]

1531

return [node[1][0] for node in self._graph_index.iter_all_entries()]

1532

1533

def has_version(self, version_id):

1534

"""True if the version is in the index."""

1539

1540

def get_position(self, version_id):

1541

"""Return data position and size of specified version."""

1542

bits = self._get_node(version_id)[1][1:].split(' ')

1542

bits = self._get_node(version_id)[2][1:].split(' ')

1543

return int(bits[0]), int(bits[1])

1544

1545

def get_method(self, version_id):

1546

"""Return compression method of specified version."""

1547

if not self._deltas:

1548

return 'fulltext'

1549

return self._parent_compression(self._get_node(version_id)[2][1])

1549

return self._parent_compression(self._get_node(version_id)[3][1])

1550

1551

def _parent_compression(self, reference_list):

1552

# use the second reference list to decide if this is delta'd or not.

1567

if not self._deltas:

1568

options = ['fulltext']

1569

else:

1570

options = [self._parent_compression(node[2][1])]

1571

if node[1][0] == 'N':

1570

options = [self._parent_compression(node[3][1])]

1571

if node[2][0] == 'N':

1572

options.append('no-eol')

1573

return options

1574

1586

check_present=True))

1587

if not self._parents:

1588

return ()

1589

return self._keys_to_version_ids(nodes[0][2][0])

1589

return self._keys_to_version_ids(nodes[0][3][0])

1590

1591

def check_versions_present(self, version_ids):

1592

"""Check that all specified versions are present."""

1645

node_refs = ()

1646

keys[key] = (value, node_refs)

1647

present_nodes = self._get_entries(keys)

1648

for (key, value, node_refs) in present_nodes:

1648

for (index, key, value, node_refs) in present_nodes:

1649

if (value, node_refs) != keys[key]:

1650

raise KnitCorrupt(self, "inconsistent details in add_versions"

1651

": %s %s" % ((value, node_refs), keys[key]))