← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: John Arbash Meinel
  • Date: 2009-07-31 19:56:19 UTC
  • mto: This revision was merged to the branch mainline in revision 4592.
  • Revision ID: john@arbash-meinel.com-20090731195619-xabumey07q2w1fge
Change the Makefile to stage things into a build directory
rather than building inside the tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
51
51
    )
52
52
from bzrlib.symbol_versioning import deprecated_in, deprecated_method
53
53
from bzrlib.trace import mutter
54
 
from bzrlib.static_tuple import StaticTuple
55
54
 
56
55
 
57
56
class InventoryEntry(object):
261
260
    def versionable_kind(kind):
262
261
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
263
262
 
264
 
    def check(self, checker, rev_id, inv):
 
263
    def check(self, checker, rev_id, inv, tree):
265
264
        """Check this inventory entry is intact.
266
265
 
267
266
        This is a template method, override _check for kind specific
273
272
        :param rev_id: Revision id from which this InventoryEntry was loaded.
274
273
             Not necessarily the last-changed revision for this file.
275
274
        :param inv: Inventory from which the entry was loaded.
 
275
        :param tree: RevisionTree for this entry.
276
276
        """
277
277
        if self.parent_id is not None:
278
278
            if not inv.has_id(self.parent_id):
279
279
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
280
280
                        % (self.parent_id, rev_id))
281
 
        checker._add_entry_to_text_key_references(inv, self)
282
 
        self._check(checker, rev_id)
 
281
        self._check(checker, rev_id, tree)
283
282
 
284
 
    def _check(self, checker, rev_id):
 
283
    def _check(self, checker, rev_id, tree):
285
284
        """Check this inventory entry for kind specific errors."""
286
 
        checker._report_items.append(
287
 
            'unknown entry kind %r in revision {%s}' % (self.kind, rev_id))
 
285
        raise BzrCheckError('unknown entry kind %r in revision {%s}' %
 
286
                            (self.kind, rev_id))
288
287
 
289
288
    def copy(self):
290
289
        """Clone this inventory entry."""
403
402
                 'text_id', 'parent_id', 'children', 'executable',
404
403
                 'revision', 'symlink_target', 'reference_revision']
405
404
 
406
 
    def _check(self, checker, rev_id):
 
405
    def _check(self, checker, rev_id, tree):
407
406
        """See InventoryEntry._check"""
408
407
 
409
408
    def __init__(self, file_id):
432
431
                 'text_id', 'parent_id', 'children', 'executable',
433
432
                 'revision', 'symlink_target', 'reference_revision']
434
433
 
435
 
    def _check(self, checker, rev_id):
 
434
    def _check(self, checker, rev_id, tree):
436
435
        """See InventoryEntry._check"""
437
 
        if (self.text_sha1 is not None or self.text_size is not None or
438
 
            self.text_id is not None):
439
 
            checker._report_items.append('directory {%s} has text in revision {%s}'
 
436
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
437
            raise BzrCheckError('directory {%s} has text in revision {%s}'
440
438
                                % (self.file_id, rev_id))
441
 
        # In non rich root repositories we do not expect a file graph for the
442
 
        # root.
443
 
        if self.name == '' and not checker.rich_roots:
444
 
            return
445
 
        # Directories are stored as an empty file, but the file should exist
446
 
        # to provide a per-fileid log. The hash of every directory content is
447
 
        # "da..." below (the sha1sum of '').
448
 
        checker.add_pending_item(rev_id,
449
 
            ('texts', self.file_id, self.revision), 'text',
450
 
             'da39a3ee5e6b4b0d3255bfef95601890afd80709')
451
439
 
452
440
    def copy(self):
453
441
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
486
474
                 'text_id', 'parent_id', 'children', 'executable',
487
475
                 'revision', 'symlink_target', 'reference_revision']
488
476
 
489
 
    def _check(self, checker, tree_revision_id):
 
477
    def _check(self, checker, tree_revision_id, tree):
490
478
        """See InventoryEntry._check"""
491
 
        # TODO: check size too.
492
 
        checker.add_pending_item(tree_revision_id,
493
 
            ('texts', self.file_id, self.revision), 'text',
494
 
             self.text_sha1)
495
 
        if self.text_size is None:
496
 
            checker._report_items.append(
497
 
                'fileid {%s} in {%s} has None for text_size' % (self.file_id,
498
 
                tree_revision_id))
 
479
        key = (self.file_id, self.revision)
 
480
        if key in checker.checked_texts:
 
481
            prev_sha = checker.checked_texts[key]
 
482
            if prev_sha != self.text_sha1:
 
483
                raise BzrCheckError(
 
484
                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
 
485
                    (self.file_id, tree_revision_id, prev_sha, self.text_sha1,
 
486
                     t))
 
487
            else:
 
488
                checker.repeated_text_cnt += 1
 
489
                return
 
490
 
 
491
        checker.checked_text_cnt += 1
 
492
        # We can't check the length, because Weave doesn't store that
 
493
        # information, and the whole point of looking at the weave's
 
494
        # sha1sum is that we don't have to extract the text.
 
495
        if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):
 
496
            raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)
 
497
        checker.checked_texts[key] = self.text_sha1
499
498
 
500
499
    def copy(self):
501
500
        other = InventoryFile(self.file_id, self.name, self.parent_id)
599
598
                 'text_id', 'parent_id', 'children', 'executable',
600
599
                 'revision', 'symlink_target', 'reference_revision']
601
600
 
602
 
    def _check(self, checker, tree_revision_id):
 
601
    def _check(self, checker, rev_id, tree):
603
602
        """See InventoryEntry._check"""
604
603
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
605
 
            checker._report_items.append(
606
 
               'symlink {%s} has text in revision {%s}'
607
 
                    % (self.file_id, tree_revision_id))
 
604
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
 
605
                    % (self.file_id, rev_id))
608
606
        if self.symlink_target is None:
609
 
            checker._report_items.append(
610
 
                'symlink {%s} has no target in revision {%s}'
611
 
                    % (self.file_id, tree_revision_id))
612
 
        # Symlinks are stored as ''
613
 
        checker.add_pending_item(tree_revision_id,
614
 
            ('texts', self.file_id, self.revision), 'text',
615
 
             'da39a3ee5e6b4b0d3255bfef95601890afd80709')
 
607
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
 
608
                    % (self.file_id, rev_id))
616
609
 
617
610
    def copy(self):
618
611
        other = InventoryLink(self.file_id, self.name, self.parent_id)
750
743
        """
751
744
        return self.has_id(file_id)
752
745
 
753
 
    def has_filename(self, filename):
754
 
        return bool(self.path2id(filename))
755
 
 
756
746
    def id2path(self, file_id):
757
747
        """Return as a string the path to file_id.
758
748
 
761
751
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
762
752
        >>> print i.id2path('foo-id')
763
753
        src/foo.c
764
 
 
765
 
        :raises NoSuchId: If file_id is not present in the inventory.
766
754
        """
767
755
        # get all names, skipping root
768
756
        return '/'.join(reversed(
959
947
        descend(self.root, u'')
960
948
        return accum
961
949
 
962
 
    def path2id(self, relpath):
 
950
    def path2id(self, name):
963
951
        """Walk down through directories to return entry of last component.
964
952
 
965
 
        :param relpath: may be either a list of path components, or a single
966
 
            string, in which case it is automatically split.
 
953
        names may be either a list of path components, or a single
 
954
        string, in which case it is automatically split.
967
955
 
968
956
        This returns the entry of the last component in the path,
969
957
        which may be either a file or a directory.
970
958
 
971
959
        Returns None IFF the path is not found.
972
960
        """
973
 
        if isinstance(relpath, basestring):
974
 
            names = osutils.splitpath(relpath)
975
 
        else:
976
 
            names = relpath
 
961
        if isinstance(name, basestring):
 
962
            name = osutils.splitpath(name)
 
963
 
 
964
        # mutter("lookup path %r" % name)
977
965
 
978
966
        try:
979
967
            parent = self.root
982
970
            return None
983
971
        if parent is None:
984
972
            return None
985
 
        for f in names:
 
973
        for f in name:
986
974
            try:
987
975
                children = getattr(parent, 'children', None)
988
976
                if children is None:
1198
1186
            raise errors.InconsistentDelta("<deleted>", parent_id,
1199
1187
                "The file id was deleted but its children were not deleted.")
1200
1188
 
1201
 
    def create_by_apply_delta(self, inventory_delta, new_revision_id,
1202
 
                              propagate_caches=False):
1203
 
        """See CHKInventory.create_by_apply_delta()"""
1204
 
        new_inv = self.copy()
1205
 
        new_inv.apply_delta(inventory_delta)
1206
 
        new_inv.revision_id = new_revision_id
1207
 
        return new_inv
1208
 
 
1209
1189
    def _set_root(self, ie):
1210
1190
        self.root = ie
1211
1191
        self._byid = {self.root.file_id: self.root}
1383
1363
            yield ie
1384
1364
            file_id = ie.parent_id
1385
1365
 
 
1366
    def has_filename(self, filename):
 
1367
        return bool(self.path2id(filename))
 
1368
 
1386
1369
    def has_id(self, file_id):
1387
1370
        return (file_id in self._byid)
1388
1371
 
1555
1538
        else:
1556
1539
            raise ValueError("unknown kind %r" % entry.kind)
1557
1540
 
1558
 
    def _expand_fileids_to_parents_and_children(self, file_ids):
1559
 
        """Give a more wholistic view starting with the given file_ids.
1560
 
 
1561
 
        For any file_id which maps to a directory, we will include all children
1562
 
        of that directory. We will also include all directories which are
1563
 
        parents of the given file_ids, but we will not include their children.
1564
 
 
1565
 
        eg:
1566
 
          /     # TREE_ROOT
1567
 
          foo/  # foo-id
1568
 
            baz # baz-id
1569
 
            frob/ # frob-id
1570
 
              fringle # fringle-id
1571
 
          bar/  # bar-id
1572
 
            bing # bing-id
1573
 
 
1574
 
        if given [foo-id] we will include
1575
 
            TREE_ROOT as interesting parents
1576
 
        and 
1577
 
            foo-id, baz-id, frob-id, fringle-id
1578
 
        As interesting ids.
1579
 
        """
1580
 
        interesting = set()
1581
 
        # TODO: Pre-pass over the list of fileids to see if anything is already
1582
 
        #       deserialized in self._fileid_to_entry_cache
1583
 
 
1584
 
        directories_to_expand = set()
1585
 
        children_of_parent_id = {}
1586
 
        # It is okay if some of the fileids are missing
1587
 
        for entry in self._getitems(file_ids):
1588
 
            if entry.kind == 'directory':
1589
 
                directories_to_expand.add(entry.file_id)
1590
 
            interesting.add(entry.parent_id)
1591
 
            children_of_parent_id.setdefault(entry.parent_id, []
1592
 
                                             ).append(entry.file_id)
1593
 
 
1594
 
        # Now, interesting has all of the direct parents, but not the
1595
 
        # parents of those parents. It also may have some duplicates with
1596
 
        # specific_fileids
1597
 
        remaining_parents = interesting.difference(file_ids)
1598
 
        # When we hit the TREE_ROOT, we'll get an interesting parent of None,
1599
 
        # but we don't actually want to recurse into that
1600
 
        interesting.add(None) # this will auto-filter it in the loop
1601
 
        remaining_parents.discard(None) 
1602
 
        while remaining_parents:
1603
 
            next_parents = set()
1604
 
            for entry in self._getitems(remaining_parents):
1605
 
                next_parents.add(entry.parent_id)
1606
 
                children_of_parent_id.setdefault(entry.parent_id, []
1607
 
                                                 ).append(entry.file_id)
1608
 
            # Remove any search tips we've already processed
1609
 
            remaining_parents = next_parents.difference(interesting)
1610
 
            interesting.update(remaining_parents)
1611
 
            # We should probably also .difference(directories_to_expand)
1612
 
        interesting.update(file_ids)
1613
 
        interesting.discard(None)
1614
 
        while directories_to_expand:
1615
 
            # Expand directories by looking in the
1616
 
            # parent_id_basename_to_file_id map
1617
 
            keys = [StaticTuple(f,).intern() for f in directories_to_expand]
1618
 
            directories_to_expand = set()
1619
 
            items = self.parent_id_basename_to_file_id.iteritems(keys)
1620
 
            next_file_ids = set([item[1] for item in items])
1621
 
            next_file_ids = next_file_ids.difference(interesting)
1622
 
            interesting.update(next_file_ids)
1623
 
            for entry in self._getitems(next_file_ids):
1624
 
                if entry.kind == 'directory':
1625
 
                    directories_to_expand.add(entry.file_id)
1626
 
                children_of_parent_id.setdefault(entry.parent_id, []
1627
 
                                                 ).append(entry.file_id)
1628
 
        return interesting, children_of_parent_id
1629
 
 
1630
 
    def filter(self, specific_fileids):
1631
 
        """Get an inventory view filtered against a set of file-ids.
1632
 
 
1633
 
        Children of directories and parents are included.
1634
 
 
1635
 
        The result may or may not reference the underlying inventory
1636
 
        so it should be treated as immutable.
1637
 
        """
1638
 
        (interesting,
1639
 
         parent_to_children) = self._expand_fileids_to_parents_and_children(
1640
 
                                specific_fileids)
1641
 
        # There is some overlap here, but we assume that all interesting items
1642
 
        # are in the _fileid_to_entry_cache because we had to read them to
1643
 
        # determine if they were a dir we wanted to recurse, or just a file
1644
 
        # This should give us all the entries we'll want to add, so start
1645
 
        # adding
1646
 
        other = Inventory(self.root_id)
1647
 
        other.root.revision = self.root.revision
1648
 
        other.revision_id = self.revision_id
1649
 
        if not interesting or not parent_to_children:
1650
 
            # empty filter, or filtering entrys that don't exist
1651
 
            # (if even 1 existed, then we would have populated
1652
 
            # parent_to_children with at least the tree root.)
1653
 
            return other
1654
 
        cache = self._fileid_to_entry_cache
1655
 
        remaining_children = collections.deque(parent_to_children[self.root_id])
1656
 
        while remaining_children:
1657
 
            file_id = remaining_children.popleft()
1658
 
            ie = cache[file_id]
1659
 
            if ie.kind == 'directory':
1660
 
                ie = ie.copy() # We create a copy to depopulate the .children attribute
1661
 
            # TODO: depending on the uses of 'other' we should probably alwyas
1662
 
            #       '.copy()' to prevent someone from mutating other and
1663
 
            #       invaliding our internal cache
1664
 
            other.add(ie)
1665
 
            if file_id in parent_to_children:
1666
 
                remaining_children.extend(parent_to_children[file_id])
1667
 
        return other
1668
 
 
1669
1541
    @staticmethod
1670
1542
    def _bytes_to_utf8name_key(bytes):
1671
1543
        """Get the file_id, revision_id key out of bytes."""
1673
1545
        # to filter out empty names because of non rich-root...
1674
1546
        sections = bytes.split('\n')
1675
1547
        kind, file_id = sections[0].split(': ')
1676
 
        return (sections[2], intern(file_id), intern(sections[3]))
 
1548
        return (sections[2], file_id, sections[3])
1677
1549
 
1678
1550
    def _bytes_to_entry(self, bytes):
1679
1551
        """Deserialise a serialised entry."""
1701
1573
            result.reference_revision = sections[4]
1702
1574
        else:
1703
1575
            raise ValueError("Not a serialised entry %r" % bytes)
1704
 
        result.file_id = intern(result.file_id)
1705
 
        result.revision = intern(sections[3])
 
1576
        result.revision = sections[3]
1706
1577
        if result.parent_id == '':
1707
1578
            result.parent_id = None
1708
1579
        self._fileid_to_entry_cache[result.file_id] = result
1806
1677
                        pass
1807
1678
                deletes.add(file_id)
1808
1679
            else:
1809
 
                new_key = StaticTuple(file_id,)
 
1680
                new_key = (file_id,)
1810
1681
                new_value = result._entry_to_bytes(entry)
1811
1682
                # Update caches. It's worth doing this whether
1812
1683
                # we're propagating the old caches or not.
1815
1686
            if old_path is None:
1816
1687
                old_key = None
1817
1688
            else:
1818
 
                old_key = StaticTuple(file_id,)
 
1689
                old_key = (file_id,)
1819
1690
                if self.id2path(file_id) != old_path:
1820
1691
                    raise errors.InconsistentDelta(old_path, file_id,
1821
1692
                        "Entry was at wrong other path %r." %
1822
1693
                        self.id2path(file_id))
1823
1694
                altered.add(file_id)
1824
 
            id_to_entry_delta.append(StaticTuple(old_key, new_key, new_value))
 
1695
            id_to_entry_delta.append((old_key, new_key, new_value))
1825
1696
            if result.parent_id_basename_to_file_id is not None:
1826
1697
                # parent_id, basename changes
1827
1698
                if old_path is None:
1914
1785
                raise errors.BzrError('Duplicate key in inventory: %r\n%r'
1915
1786
                                      % (key, bytes))
1916
1787
            info[key] = value
1917
 
        revision_id = intern(info['revision_id'])
1918
 
        root_id = intern(info['root_id'])
1919
 
        search_key_name = intern(info.get('search_key_name', 'plain'))
1920
 
        parent_id_basename_to_file_id = intern(info.get(
1921
 
            'parent_id_basename_to_file_id', None))
1922
 
        if not parent_id_basename_to_file_id.startswith('sha1:'):
1923
 
            raise ValueError('parent_id_basename_to_file_id should be a sha1'
1924
 
                             ' key not %r' % (parent_id_basename_to_file_id,))
 
1788
        revision_id = info['revision_id']
 
1789
        root_id = info['root_id']
 
1790
        search_key_name = info.get('search_key_name', 'plain')
 
1791
        parent_id_basename_to_file_id = info.get(
 
1792
            'parent_id_basename_to_file_id', None)
1925
1793
        id_to_entry = info['id_to_entry']
1926
 
        if not id_to_entry.startswith('sha1:'):
1927
 
            raise ValueError('id_to_entry should be a sha1'
1928
 
                             ' key not %r' % (id_to_entry,))
1929
1794
 
1930
1795
        result = CHKInventory(search_key_name)
1931
1796
        result.revision_id = revision_id
1934
1799
                            result._search_key_name)
1935
1800
        if parent_id_basename_to_file_id is not None:
1936
1801
            result.parent_id_basename_to_file_id = chk_map.CHKMap(
1937
 
                chk_store, StaticTuple(parent_id_basename_to_file_id,),
 
1802
                chk_store, (parent_id_basename_to_file_id,),
1938
1803
                search_key_func=search_key_func)
1939
1804
        else:
1940
1805
            result.parent_id_basename_to_file_id = None
1941
1806
 
1942
 
        result.id_to_entry = chk_map.CHKMap(chk_store,
1943
 
                                            StaticTuple(id_to_entry,),
 
1807
        result.id_to_entry = chk_map.CHKMap(chk_store, (id_to_entry,),
1944
1808
                                            search_key_func=search_key_func)
1945
1809
        if (result.revision_id,) != expected_revision_id:
1946
1810
            raise ValueError("Mismatched revision id and expected: %r, %r" %
1968
1832
        id_to_entry_dict = {}
1969
1833
        parent_id_basename_dict = {}
1970
1834
        for path, entry in inventory.iter_entries():
1971
 
            key = StaticTuple(entry.file_id,).intern()
1972
 
            id_to_entry_dict[key] = entry_to_bytes(entry)
 
1835
            id_to_entry_dict[(entry.file_id,)] = entry_to_bytes(entry)
1973
1836
            p_id_key = parent_id_basename_key(entry)
1974
1837
            parent_id_basename_dict[p_id_key] = entry.file_id
1975
1838
 
1998
1861
            parent_id = entry.parent_id
1999
1862
        else:
2000
1863
            parent_id = ''
2001
 
        return StaticTuple(parent_id, entry.name.encode('utf8')).intern()
 
1864
        return parent_id, entry.name.encode('utf8')
2002
1865
 
2003
1866
    def __getitem__(self, file_id):
2004
1867
        """map a single file_id -> InventoryEntry."""
2009
1872
            return result
2010
1873
        try:
2011
1874
            return self._bytes_to_entry(
2012
 
                self.id_to_entry.iteritems([StaticTuple(file_id,)]).next()[1])
 
1875
                self.id_to_entry.iteritems([(file_id,)]).next()[1])
2013
1876
        except StopIteration:
2014
1877
            # really we're passing an inventory, not a tree...
2015
1878
            raise errors.NoSuchId(self, file_id)
2016
1879
 
2017
 
    def _getitems(self, file_ids):
2018
 
        """Similar to __getitem__, but lets you query for multiple.
2019
 
        
2020
 
        The returned order is undefined. And currently if an item doesn't
2021
 
        exist, it isn't included in the output.
2022
 
        """
2023
 
        result = []
2024
 
        remaining = []
2025
 
        for file_id in file_ids:
2026
 
            entry = self._fileid_to_entry_cache.get(file_id, None)
2027
 
            if entry is None:
2028
 
                remaining.append(file_id)
2029
 
            else:
2030
 
                result.append(entry)
2031
 
        file_keys = [StaticTuple(f,).intern() for f in remaining]
2032
 
        for file_key, value in self.id_to_entry.iteritems(file_keys):
2033
 
            entry = self._bytes_to_entry(value)
2034
 
            result.append(entry)
2035
 
            self._fileid_to_entry_cache[entry.file_id] = entry
2036
 
        return result
2037
 
 
2038
1880
    def has_id(self, file_id):
2039
1881
        # Perhaps have an explicit 'contains' method on CHKMap ?
2040
1882
        if self._fileid_to_entry_cache.get(file_id, None) is not None:
2041
1883
            return True
2042
 
        return len(list(
2043
 
            self.id_to_entry.iteritems([StaticTuple(file_id,)]))) == 1
 
1884
        return len(list(self.id_to_entry.iteritems([(file_id,)]))) == 1
2044
1885
 
2045
1886
    def is_root(self, file_id):
2046
1887
        return file_id == self.root_id
2175
2016
            delta.append((old_path, new_path, file_id, entry))
2176
2017
        return delta
2177
2018
 
2178
 
    def path2id(self, relpath):
 
2019
    def path2id(self, name):
2179
2020
        """See CommonInventory.path2id()."""
2180
2021
        # TODO: perhaps support negative hits?
2181
 
        result = self._path_to_fileid_cache.get(relpath, None)
 
2022
        result = self._path_to_fileid_cache.get(name, None)
2182
2023
        if result is not None:
2183
2024
            return result
2184
 
        if isinstance(relpath, basestring):
2185
 
            names = osutils.splitpath(relpath)
 
2025
        if isinstance(name, basestring):
 
2026
            names = osutils.splitpath(name)
2186
2027
        else:
2187
 
            names = relpath
 
2028
            names = name
2188
2029
        current_id = self.root_id
2189
2030
        if current_id is None:
2190
2031
            return None
2191
2032
        parent_id_index = self.parent_id_basename_to_file_id
2192
 
        cur_path = None
2193
2033
        for basename in names:
2194
 
            if cur_path is None:
2195
 
                cur_path = basename
2196
 
            else:
2197
 
                cur_path = cur_path + '/' + basename
 
2034
            # TODO: Cache each path we figure out in this function.
2198
2035
            basename_utf8 = basename.encode('utf8')
2199
 
            file_id = self._path_to_fileid_cache.get(cur_path, None)
 
2036
            key_filter = [(current_id, basename_utf8)]
 
2037
            file_id = None
 
2038
            for (parent_id, name_utf8), file_id in parent_id_index.iteritems(
 
2039
                key_filter=key_filter):
 
2040
                if parent_id != current_id or name_utf8 != basename_utf8:
 
2041
                    raise errors.BzrError("corrupt inventory lookup! "
 
2042
                        "%r %r %r %r" % (parent_id, current_id, name_utf8,
 
2043
                        basename_utf8))
2200
2044
            if file_id is None:
2201
 
                key_filter = [StaticTuple(current_id, basename_utf8)]
2202
 
                items = parent_id_index.iteritems(key_filter)
2203
 
                for (parent_id, name_utf8), file_id in items:
2204
 
                    if parent_id != current_id or name_utf8 != basename_utf8:
2205
 
                        raise errors.BzrError("corrupt inventory lookup! "
2206
 
                            "%r %r %r %r" % (parent_id, current_id, name_utf8,
2207
 
                            basename_utf8))
2208
 
                if file_id is None:
2209
 
                    return None
2210
 
                else:
2211
 
                    self._path_to_fileid_cache[cur_path] = file_id
 
2045
                return None
2212
2046
            current_id = file_id
 
2047
        self._path_to_fileid_cache[name] = current_id
2213
2048
        return current_id
2214
2049
 
2215
2050
    def to_lines(self):
2220
2055
            lines.append('search_key_name: %s\n' % (self._search_key_name,))
2221
2056
            lines.append("root_id: %s\n" % self.root_id)
2222
2057
            lines.append('parent_id_basename_to_file_id: %s\n' %
2223
 
                (self.parent_id_basename_to_file_id.key()[0],))
 
2058
                self.parent_id_basename_to_file_id.key())
2224
2059
            lines.append("revision_id: %s\n" % self.revision_id)
2225
 
            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
 
2060
            lines.append("id_to_entry: %s\n" % self.id_to_entry.key())
2226
2061
        else:
2227
2062
            lines.append("revision_id: %s\n" % self.revision_id)
2228
2063
            lines.append("root_id: %s\n" % self.root_id)
2229
2064
            if self.parent_id_basename_to_file_id is not None:
2230
2065
                lines.append('parent_id_basename_to_file_id: %s\n' %
2231
 
                    (self.parent_id_basename_to_file_id.key()[0],))
2232
 
            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
 
2066
                    self.parent_id_basename_to_file_id.key())
 
2067
            lines.append("id_to_entry: %s\n" % self.id_to_entry.key())
2233
2068
        return lines
2234
2069
 
2235
2070
    @property
2276
2111
        parent_id_index = self._chk_inventory.parent_id_basename_to_file_id
2277
2112
        child_keys = set()
2278
2113
        for (parent_id, name_utf8), file_id in parent_id_index.iteritems(
2279
 
            key_filter=[StaticTuple(self.file_id,)]):
2280
 
            child_keys.add(StaticTuple(file_id,))
 
2114
            key_filter=[(self.file_id,)]):
 
2115
            child_keys.add((file_id,))
2281
2116
        cached = set()
2282
2117
        for file_id_key in child_keys:
2283
2118
            entry = self._chk_inventory._fileid_to_entry_cache.get(
2316
2151
    try:
2317
2152
        factory = entry_factory[kind]
2318
2153
    except KeyError:
2319
 
        raise errors.BadFileKindError(name, kind)
 
2154
        raise BzrError("unknown kind %r" % kind)
2320
2155
    return factory(file_id, name, parent_id)
2321
2156
 
2322
2157