96
89
>>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
97
90
InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
98
91
>>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
99
InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None, revision=None)
92
InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
100
93
>>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
101
94
>>> for ix, j in enumerate(i.iter_entries()):
102
95
... print (j[0] == shouldbe[ix], j[1])
104
97
(True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
105
98
(True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
106
(True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None, revision=None))
99
(True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
107
100
>>> i.add(InventoryFile('2324', 'bye.c', '123'))
108
InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None, revision=None)
101
InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
109
102
>>> i.add(InventoryDirectory('2325', 'wibble', '123'))
110
103
InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
111
104
>>> i.path2id('src/wibble')
113
108
>>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
114
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None, revision=None)
115
>>> i.get_entry('2326')
116
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None, revision=None)
109
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
111
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
117
112
>>> for path, entry in i.iter_entries():
114
... assert i.path2id(path)
125
121
src/wibble/wibble.c
126
>>> i.id2path(b'2326')
122
>>> i.id2path('2326')
127
123
'src/wibble/wibble.c'
130
126
# Constants returned by describe_change()
132
# TODO: These should probably move to some kind of FileChangeDescription
133
# class; that's like what's inside a TreeDelta but we want to be able to
128
# TODO: These should probably move to some kind of FileChangeDescription
129
# class; that's like what's inside a TreeDelta but we want to be able to
134
130
# generate them just for one file at a time.
135
131
RENAMED = 'renamed'
136
132
MODIFIED_AND_RENAMED = 'modified and renamed'
138
__slots__ = ['file_id', 'revision', 'parent_id', 'name']
140
# Attributes that all InventoryEntry instances are expected to have, but
141
# that don't vary for all kinds of entry. (e.g. symlink_target is only
142
# relevant to InventoryLink, so there's no reason to make every
143
# InventoryFile instance allocate space to hold a value for it.)
144
# Attributes that only vary for files: executable, text_sha1, text_size,
150
# Attributes that only vary for symlinks: symlink_target
151
symlink_target = None
152
# Attributes that only vary for tree-references: reference_revision
153
reference_revision = None
156
136
def detect_changes(self, old_entry):
157
137
"""Return a (text_modified, meta_modified) from this to old_entry.
159
_read_tree_state must have been called on self and old_entry prior to
139
_read_tree_state must have been called on self and old_entry prior to
160
140
calling detect_changes.
162
142
return False, False
144
def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
output_to, reverse=False):
146
"""Perform a diff from this to to_entry.
148
text_diff will be used for textual difference calculation.
149
This is a template method, override _diff in child classes.
151
self._read_tree_state(tree.id2path(self.file_id), tree)
153
# cannot diff from one kind to another - you must do a removal
154
# and an addif they do not match.
155
assert self.kind == to_entry.kind
156
to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
158
self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
164
161
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
165
162
output_to, reverse=False):
166
163
"""Perform a diff between two entries of the same kind."""
168
def parent_candidates(self, previous_inventories):
169
"""Find possible per-file graph parents.
171
This is currently defined by:
172
- Select the last changed revision in the parent inventory.
173
- Do deal with a short lived bug in bzr 0.8's development two entries
174
that have the same last changed but different 'x' bit settings are
165
def find_previous_heads(self, previous_inventories,
166
versioned_file_store,
169
"""Return the revisions and entries that directly precede this.
171
Returned as a map from revision to inventory entry.
173
This is a map containing the file revisions in all parents
174
for which the file exists, and its revision is not a parent of
175
any other. If the file is new, the set will be empty.
177
:param versioned_file_store: A store where ancestry data on this
178
file id can be queried.
179
:param transaction: The transaction that queries to the versioned
180
file store should be completed under.
181
:param entry_vf: The entry versioned file, if its already available.
183
def get_ancestors(weave, entry):
184
return set(weave.get_ancestry(entry.revision))
177
185
# revision:ie mapping for each ie found in previous_inventories.
187
# revision:ie mapping with one revision for each head.
189
# revision: ancestor list for each head
179
191
# identify candidate head revision ids.
180
192
for inv in previous_inventories:
182
ie = inv.get_entry(self.file_id)
183
except errors.NoSuchId:
193
if self.file_id in inv:
194
ie = inv[self.file_id]
195
assert ie.file_id == self.file_id
196
if ie.kind != self.kind:
197
# Can't be a candidate if the kind has changed.
186
199
if ie.revision in candidates:
187
200
# same revision value in two different inventories:
188
201
# correct possible inconsistencies:
189
# * there was a bug in revision updates with 'x' bit
202
# * there was a bug in revision updates with 'x' bit
192
205
if candidates[ie.revision].executable != ie.executable:
837
1056
def descend(dir_ie, dir_path):
838
kids = sorted(viewitems(dir_ie.children))
1057
kids = dir_ie.children.items()
839
1059
for name, ie in kids:
840
1060
child_path = osutils.pathjoin(dir_path, name)
841
1061
accum.append((child_path, ie))
842
1062
if ie.kind == 'directory':
843
1063
descend(ie, child_path)
845
if self.root is not None:
846
descend(self.root, u'')
849
def get_entry_by_path(self, relpath):
850
"""Return an inventory entry by path.
852
:param relpath: may be either a list of path components, or a single
853
string, in which case it is automatically split.
855
This returns the entry of the last component in the path,
856
which may be either a file or a directory.
858
Returns None IFF the path is not found.
860
if isinstance(relpath, (str, text_type)):
861
names = osutils.splitpath(relpath)
867
except errors.NoSuchId:
868
# root doesn't exist yet so nothing else can
874
children = getattr(parent, 'children', None)
884
def path2id(self, relpath):
885
"""Walk down through directories to return entry of last component.
887
:param relpath: may be either a list of path components, or a single
888
string, in which case it is automatically split.
890
This returns the entry of the last component in the path,
891
which may be either a file or a directory.
893
Returns None IFF the path is not found.
895
ie = self.get_entry_by_path(relpath)
900
def filter(self, specific_fileids):
901
"""Get an inventory view filtered against a set of file-ids.
903
Children of directories and parents are included.
905
The result may or may not reference the underlying inventory
906
so it should be treated as immutable.
908
interesting_parents = set()
909
for fileid in specific_fileids:
911
interesting_parents.update(self.get_idpath(fileid))
912
except errors.NoSuchId:
913
# This fileid is not in the inventory - that's ok
915
entries = self.iter_entries()
916
if self.root is None:
917
return Inventory(root_id=None)
918
other = Inventory(next(entries)[1].file_id)
919
other.root.revision = self.root.revision
920
other.revision_id = self.revision_id
921
directories_to_expand = set()
922
for path, entry in entries:
923
file_id = entry.file_id
924
if (file_id in specific_fileids
925
or entry.parent_id in directories_to_expand):
926
if entry.kind == 'directory':
927
directories_to_expand.add(file_id)
928
elif file_id not in interesting_parents:
930
other.add(entry.copy())
933
def get_idpath(self, file_id):
934
"""Return a list of file_ids for the path to an entry.
936
The list contains one element for each directory followed by
937
the id of the file itself. So the length of the returned list
938
is equal to the depth of the file in the tree, counting the
939
root directory as depth 1.
942
for parent in self._iter_file_id_parents(file_id):
943
p.insert(0, parent.file_id)
947
class Inventory(CommonInventory):
948
"""Mutable dict based in-memory inventory.
950
We never store the full path to a file, because renaming a directory
951
implicitly moves all of its contents. This class internally maintains a
952
lookup tree that allows the children under a directory to be
955
>>> inv = Inventory()
956
>>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
957
InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
958
>>> inv.get_entry('123-123').name
961
Id's may be looked up from paths:
963
>>> inv.path2id('hello.c')
965
>>> inv.has_id(b'123-123')
968
There are iterators over the contents:
970
>>> [entry[0] for entry in inv.iter_entries()]
974
def __init__(self, root_id=ROOT_ID, revision_id=None):
975
"""Create or read an inventory.
977
If a working directory is specified, the inventory is read
978
from there. If the file is specified, read from that. If not,
979
the inventory is created empty.
981
The inventory is created with a default root directory, with
984
if root_id is not None:
985
self._set_root(InventoryDirectory(root_id, u'', None))
989
self.revision_id = revision_id
992
# More than one page of ouput is not useful anymore to debug
995
contents = repr(self._byid)
996
if len(contents) > max_len:
997
contents = contents[:(max_len-len(closing))] + closing
998
return "<Inventory object at %x, contents=%r>" % (id(self), contents)
1000
def apply_delta(self, delta):
1001
"""Apply a delta to this inventory.
1003
See the inventory developers documentation for the theory behind
1006
If delta application fails the inventory is left in an indeterminate
1007
state and must not be used.
1009
:param delta: A list of changes to apply. After all the changes are
1010
applied the final inventory must be internally consistent, but it
1011
is ok to supply changes which, if only half-applied would have an
1012
invalid result - such as supplying two changes which rename two
1013
files, 'A' and 'B' with each other : [('A', 'B', b'A-id', a_entry),
1014
('B', 'A', b'B-id', b_entry)].
1016
Each change is a tuple, of the form (old_path, new_path, file_id,
1019
When new_path is None, the change indicates the removal of an entry
1020
from the inventory and new_entry will be ignored (using None is
1021
appropriate). If new_path is not None, then new_entry must be an
1022
InventoryEntry instance, which will be incorporated into the
1023
inventory (and replace any existing entry with the same file id).
1025
When old_path is None, the change indicates the addition of
1026
a new entry to the inventory.
1028
When neither new_path nor old_path are None, the change is a
1029
modification to an entry, such as a rename, reparent, kind change
1032
The children attribute of new_entry is ignored. This is because
1033
this method preserves children automatically across alterations to
1034
the parent of the children, and cases where the parent id of a
1035
child is changing require the child to be passed in as a separate
1036
change regardless. E.g. in the recursive deletion of a directory -
1037
the directory's children must be included in the delta, or the
1038
final inventory will be invalid.
1040
Note that a file_id must only appear once within a given delta.
1041
An AssertionError is raised otherwise.
1043
# Check that the delta is legal. It would be nice if this could be
1044
# done within the loops below but it's safer to validate the delta
1045
# before starting to mutate the inventory, as there isn't a rollback
1047
list(_check_delta_unique_ids(_check_delta_unique_new_paths(
1048
_check_delta_unique_old_paths(_check_delta_ids_match_entry(
1049
_check_delta_ids_are_valid(
1050
_check_delta_new_path_entry_both_or_None(
1054
# Remove all affected items which were in the original inventory,
1055
# starting with the longest paths, thus ensuring parents are examined
1056
# after their children, which means that everything we examine has no
1057
# modified children remaining by the time we examine it.
1058
for old_path, file_id in sorted(((op, f) for op, np, f, e in delta
1059
if op is not None), reverse=True):
1060
# Preserve unaltered children of file_id for later reinsertion.
1061
file_id_children = getattr(self.get_entry(file_id), 'children', {})
1062
if len(file_id_children):
1063
children[file_id] = file_id_children
1064
if self.id2path(file_id) != old_path:
1065
raise errors.InconsistentDelta(old_path, file_id,
1066
"Entry was at wrong other path %r." % self.id2path(file_id))
1067
# Remove file_id and the unaltered children. If file_id is not
1068
# being deleted it will be reinserted back later.
1069
self.remove_recursive_id(file_id)
1070
# Insert all affected which should be in the new inventory, reattaching
1071
# their children if they had any. This is done from shortest path to
1072
# longest, ensuring that items which were modified and whose parents in
1073
# the resulting inventory were also modified, are inserted after their
1075
for new_path, f, new_entry in sorted((np, f, e) for op, np, f, e in
1076
delta if np is not None):
1077
if new_entry.kind == 'directory':
1078
# Pop the child which to allow detection of children whose
1079
# parents were deleted and which were not reattached to a new
1081
replacement = InventoryDirectory(new_entry.file_id,
1082
new_entry.name, new_entry.parent_id)
1083
replacement.revision = new_entry.revision
1084
replacement.children = children.pop(replacement.file_id, {})
1085
new_entry = replacement
1088
except errors.DuplicateFileId:
1089
raise errors.InconsistentDelta(new_path, new_entry.file_id,
1090
"New id is already present in target.")
1091
except AttributeError:
1092
raise errors.InconsistentDelta(new_path, new_entry.file_id,
1093
"Parent is not a directory.")
1094
if self.id2path(new_entry.file_id) != new_path:
1095
raise errors.InconsistentDelta(new_path, new_entry.file_id,
1096
"New path is not consistent with parent path.")
1098
# Get the parent id that was deleted
1099
parent_id, children = children.popitem()
1100
raise errors.InconsistentDelta("<deleted>", parent_id,
1101
"The file id was deleted but its children were not deleted.")
1103
def create_by_apply_delta(self, inventory_delta, new_revision_id,
1104
propagate_caches=False):
1105
"""See CHKInventory.create_by_apply_delta()"""
1106
new_inv = self.copy()
1107
new_inv.apply_delta(inventory_delta)
1108
new_inv.revision_id = new_revision_id
1111
def _set_root(self, ie):
1113
self._byid = {self.root.file_id: self.root}
1116
# TODO: jam 20051218 Should copy also copy the revision_id?
1117
entries = self.iter_entries()
1118
if self.root is None:
1119
return Inventory(root_id=None)
1120
other = Inventory(next(entries)[1].file_id)
1121
other.root.revision = self.root.revision
1122
# copy recursively so we know directories will be added before
1123
# their children. There are more efficient ways than this...
1124
for path, entry in entries:
1125
other.add(entry.copy())
1128
def iter_all_ids(self):
1129
"""Iterate over all file-ids."""
1130
return iter(self._byid)
1132
def iter_just_entries(self):
1133
"""Iterate over all entries.
1065
descend(self.root, u'')
1068
def directories(self):
1069
"""Return (path, entry) pairs for all directories, including the root.
1072
def descend(parent_ie, parent_path):
1073
accum.append((parent_path, parent_ie))
1075
kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
1078
for name, child_ie in kids:
1079
child_path = osutils.pathjoin(parent_path, name)
1080
descend(child_ie, child_path)
1081
descend(self.root, u'')
1135
Unlike iter_entries(), just the entries are returned (not (path, ie))
1136
and the order of entries is undefined.
1084
def __contains__(self, file_id):
1085
"""True if this entry contains a file with given id.
1138
XXX: We may not want to merge this into bzr.dev.
1087
>>> inv = Inventory()
1088
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1089
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
1140
if self.root is None:
1142
return iter(viewvalues(self._byid))
1145
"""Returns number of entries."""
1146
return len(self._byid)
1148
def get_entry(self, file_id):
1095
file_id = osutils.safe_file_id(file_id)
1096
return (file_id in self._byid)
1098
def __getitem__(self, file_id):
1149
1099
"""Return the entry for given file_id.
1151
1101
>>> inv = Inventory()
1152
1102
>>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1153
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
1154
>>> inv.get_entry('123123').name
1103
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
1104
>>> inv['123123'].name
1157
if not isinstance(file_id, bytes):
1158
raise TypeError(file_id)
1107
file_id = osutils.safe_file_id(file_id)
1160
1109
return self._byid[file_id]
1161
1110
except KeyError:
1366
1362
del old_parent.children[file_ie.name]
1367
1363
new_parent.children[new_name] = file_ie
1369
1365
file_ie.name = new_name
1370
1366
file_ie.parent_id = new_parent_id
1372
1368
def is_root(self, file_id):
1369
file_id = osutils.safe_file_id(file_id)
1373
1370
return self.root is not None and file_id == self.root.file_id
1376
class CHKInventory(CommonInventory):
1377
"""An inventory persisted in a CHK store.
1379
By design, a CHKInventory is immutable so many of the methods
1380
supported by Inventory - add, rename, apply_delta, etc - are *not*
1381
supported. To create a new CHKInventory, use create_by_apply_delta()
1382
or from_inventory(), say.
1384
Internally, a CHKInventory has one or two CHKMaps:
1386
* id_to_entry - a map from (file_id,) => InventoryEntry as bytes
1387
* parent_id_basename_to_file_id - a map from (parent_id, basename_utf8)
1390
The second map is optional and not present in early CHkRepository's.
1392
No caching is performed: every method call or item access will perform
1393
requests to the storage layer. As such, keep references to objects you
1397
def __init__(self, search_key_name):
1398
CommonInventory.__init__(self)
1399
self._fileid_to_entry_cache = {}
1400
self._fully_cached = False
1401
self._path_to_fileid_cache = {}
1402
self._search_key_name = search_key_name
1405
def __eq__(self, other):
1406
"""Compare two sets by comparing their contents."""
1407
if not isinstance(other, CHKInventory):
1408
return NotImplemented
1410
this_key = self.id_to_entry.key()
1411
other_key = other.id_to_entry.key()
1412
this_pid_key = self.parent_id_basename_to_file_id.key()
1413
other_pid_key = other.parent_id_basename_to_file_id.key()
1414
if None in (this_key, this_pid_key, other_key, other_pid_key):
1416
return this_key == other_key and this_pid_key == other_pid_key
1418
def _entry_to_bytes(self, entry):
1419
"""Serialise entry as a single bytestring.
1421
:param Entry: An inventory entry.
1422
:return: A bytestring for the entry.
1425
ENTRY ::= FILE | DIR | SYMLINK | TREE
1426
FILE ::= "file: " COMMON SEP SHA SEP SIZE SEP EXECUTABLE
1427
DIR ::= "dir: " COMMON
1428
SYMLINK ::= "symlink: " COMMON SEP TARGET_UTF8
1429
TREE ::= "tree: " COMMON REFERENCE_REVISION
1430
COMMON ::= FILE_ID SEP PARENT_ID SEP NAME_UTF8 SEP REVISION
1433
if entry.parent_id is not None:
1434
parent_str = entry.parent_id
1437
name_str = entry.name.encode("utf8")
1438
if entry.kind == 'file':
1439
if entry.executable:
1443
return b"file: %s\n%s\n%s\n%s\n%s\n%d\n%s" % (
1444
entry.file_id, parent_str, name_str, entry.revision,
1445
entry.text_sha1, entry.text_size, exec_str)
1446
elif entry.kind == 'directory':
1447
return b"dir: %s\n%s\n%s\n%s" % (
1448
entry.file_id, parent_str, name_str, entry.revision)
1449
elif entry.kind == 'symlink':
1450
return b"symlink: %s\n%s\n%s\n%s\n%s" % (
1451
entry.file_id, parent_str, name_str, entry.revision,
1452
entry.symlink_target.encode("utf8"))
1453
elif entry.kind == 'tree-reference':
1454
return b"tree: %s\n%s\n%s\n%s\n%s" % (
1455
entry.file_id, parent_str, name_str, entry.revision,
1456
entry.reference_revision)
1458
raise ValueError("unknown kind %r" % entry.kind)
1460
def _expand_fileids_to_parents_and_children(self, file_ids):
1461
"""Give a more wholistic view starting with the given file_ids.
1463
For any file_id which maps to a directory, we will include all children
1464
of that directory. We will also include all directories which are
1465
parents of the given file_ids, but we will not include their children.
1472
fringle # fringle-id
1476
if given [foo-id] we will include
1477
TREE_ROOT as interesting parents
1479
foo-id, baz-id, frob-id, fringle-id
1483
# TODO: Pre-pass over the list of fileids to see if anything is already
1484
# deserialized in self._fileid_to_entry_cache
1486
directories_to_expand = set()
1487
children_of_parent_id = {}
1488
# It is okay if some of the fileids are missing
1489
for entry in self._getitems(file_ids):
1490
if entry.kind == 'directory':
1491
directories_to_expand.add(entry.file_id)
1492
interesting.add(entry.parent_id)
1493
children_of_parent_id.setdefault(entry.parent_id, set()
1494
).add(entry.file_id)
1496
# Now, interesting has all of the direct parents, but not the
1497
# parents of those parents. It also may have some duplicates with
1499
remaining_parents = interesting.difference(file_ids)
1500
# When we hit the TREE_ROOT, we'll get an interesting parent of None,
1501
# but we don't actually want to recurse into that
1502
interesting.add(None) # this will auto-filter it in the loop
1503
remaining_parents.discard(None)
1504
while remaining_parents:
1505
next_parents = set()
1506
for entry in self._getitems(remaining_parents):
1507
next_parents.add(entry.parent_id)
1508
children_of_parent_id.setdefault(entry.parent_id, set()
1509
).add(entry.file_id)
1510
# Remove any search tips we've already processed
1511
remaining_parents = next_parents.difference(interesting)
1512
interesting.update(remaining_parents)
1513
# We should probably also .difference(directories_to_expand)
1514
interesting.update(file_ids)
1515
interesting.discard(None)
1516
while directories_to_expand:
1517
# Expand directories by looking in the
1518
# parent_id_basename_to_file_id map
1519
keys = [StaticTuple(f,).intern() for f in directories_to_expand]
1520
directories_to_expand = set()
1521
items = self.parent_id_basename_to_file_id.iteritems(keys)
1522
next_file_ids = {item[1] for item in items}
1523
next_file_ids = next_file_ids.difference(interesting)
1524
interesting.update(next_file_ids)
1525
for entry in self._getitems(next_file_ids):
1526
if entry.kind == 'directory':
1527
directories_to_expand.add(entry.file_id)
1528
children_of_parent_id.setdefault(entry.parent_id, set()
1529
).add(entry.file_id)
1530
return interesting, children_of_parent_id
1532
def filter(self, specific_fileids):
1533
"""Get an inventory view filtered against a set of file-ids.
1535
Children of directories and parents are included.
1537
The result may or may not reference the underlying inventory
1538
so it should be treated as immutable.
1541
parent_to_children) = self._expand_fileids_to_parents_and_children(
1543
# There is some overlap here, but we assume that all interesting items
1544
# are in the _fileid_to_entry_cache because we had to read them to
1545
# determine if they were a dir we wanted to recurse, or just a file
1546
# This should give us all the entries we'll want to add, so start
1548
other = Inventory(self.root_id)
1549
other.root.revision = self.root.revision
1550
other.revision_id = self.revision_id
1551
if not interesting or not parent_to_children:
1552
# empty filter, or filtering entrys that don't exist
1553
# (if even 1 existed, then we would have populated
1554
# parent_to_children with at least the tree root.)
1556
cache = self._fileid_to_entry_cache
1557
remaining_children = collections.deque(parent_to_children[self.root_id])
1558
while remaining_children:
1559
file_id = remaining_children.popleft()
1561
if ie.kind == 'directory':
1562
ie = ie.copy() # We create a copy to depopulate the .children attribute
1563
# TODO: depending on the uses of 'other' we should probably alwyas
1564
# '.copy()' to prevent someone from mutating other and
1565
# invaliding our internal cache
1567
if file_id in parent_to_children:
1568
remaining_children.extend(parent_to_children[file_id])
1572
def _bytes_to_utf8name_key(data):
1573
"""Get the file_id, revision_id key out of data."""
1574
# We don't normally care about name, except for times when we want
1575
# to filter out empty names because of non rich-root...
1576
sections = data.split(b'\n')
1577
kind, file_id = sections[0].split(b': ')
1578
return (sections[2], bytesintern(file_id), bytesintern(sections[3]))
1580
def _bytes_to_entry(self, bytes):
1581
"""Deserialise a serialised entry."""
1582
sections = bytes.split(b'\n')
1583
if sections[0].startswith(b"file: "):
1584
result = InventoryFile(sections[0][6:],
1585
sections[2].decode('utf8'),
1587
result.text_sha1 = sections[4]
1588
result.text_size = int(sections[5])
1589
result.executable = sections[6] == b"Y"
1590
elif sections[0].startswith(b"dir: "):
1591
result = CHKInventoryDirectory(sections[0][5:],
1592
sections[2].decode('utf8'),
1594
elif sections[0].startswith(b"symlink: "):
1595
result = InventoryLink(sections[0][9:],
1596
sections[2].decode('utf8'),
1598
result.symlink_target = sections[4].decode('utf8')
1599
elif sections[0].startswith(b"tree: "):
1600
result = TreeReference(sections[0][6:],
1601
sections[2].decode('utf8'),
1603
result.reference_revision = sections[4]
1605
raise ValueError("Not a serialised entry %r" % bytes)
1606
result.file_id = bytesintern(result.file_id)
1607
result.revision = bytesintern(sections[3])
1608
if result.parent_id == b'':
1609
result.parent_id = None
1610
self._fileid_to_entry_cache[result.file_id] = result
1613
def create_by_apply_delta(self, inventory_delta, new_revision_id,
1614
propagate_caches=False):
1615
"""Create a new CHKInventory by applying inventory_delta to this one.
1617
See the inventory developers documentation for the theory behind
1620
:param inventory_delta: The inventory delta to apply. See
1621
Inventory.apply_delta for details.
1622
:param new_revision_id: The revision id of the resulting CHKInventory.
1623
:param propagate_caches: If True, the caches for this inventory are
1624
copied to and updated for the result.
1625
:return: The new CHKInventory.
1627
split = osutils.split
1628
result = CHKInventory(self._search_key_name)
1629
if propagate_caches:
1630
# Just propagate the path-to-fileid cache for now
1631
result._path_to_fileid_cache = self._path_to_fileid_cache.copy()
1632
search_key_func = chk_map.search_key_registry.get(self._search_key_name)
1633
self.id_to_entry._ensure_root()
1634
maximum_size = self.id_to_entry._root_node.maximum_size
1635
result.revision_id = new_revision_id
1636
result.id_to_entry = chk_map.CHKMap(
1637
self.id_to_entry._store,
1638
self.id_to_entry.key(),
1639
search_key_func=search_key_func)
1640
result.id_to_entry._ensure_root()
1641
result.id_to_entry._root_node.set_maximum_size(maximum_size)
1642
# Change to apply to the parent_id_basename delta. The dict maps
1643
# (parent_id, basename) -> (old_key, new_value). We use a dict because
1644
# when a path has its id replaced (e.g. the root is changed, or someone
1645
# does bzr mv a b, bzr mv c a, we should output a single change to this
1646
# map rather than two.
1647
parent_id_basename_delta = {}
1648
if self.parent_id_basename_to_file_id is not None:
1649
result.parent_id_basename_to_file_id = chk_map.CHKMap(
1650
self.parent_id_basename_to_file_id._store,
1651
self.parent_id_basename_to_file_id.key(),
1652
search_key_func=search_key_func)
1653
result.parent_id_basename_to_file_id._ensure_root()
1654
self.parent_id_basename_to_file_id._ensure_root()
1655
result_p_id_root = result.parent_id_basename_to_file_id._root_node
1656
p_id_root = self.parent_id_basename_to_file_id._root_node
1657
result_p_id_root.set_maximum_size(p_id_root.maximum_size)
1658
result_p_id_root._key_width = p_id_root._key_width
1660
result.parent_id_basename_to_file_id = None
1661
result.root_id = self.root_id
1662
id_to_entry_delta = []
1663
# inventory_delta is only traversed once, so we just update the
1665
# Check for repeated file ids
1666
inventory_delta = _check_delta_unique_ids(inventory_delta)
1667
# Repeated old paths
1668
inventory_delta = _check_delta_unique_old_paths(inventory_delta)
1669
# Check for repeated new paths
1670
inventory_delta = _check_delta_unique_new_paths(inventory_delta)
1671
# Check for entries that don't match the fileid
1672
inventory_delta = _check_delta_ids_match_entry(inventory_delta)
1673
# Check for nonsense fileids
1674
inventory_delta = _check_delta_ids_are_valid(inventory_delta)
1675
# Check for new_path <-> entry consistency
1676
inventory_delta = _check_delta_new_path_entry_both_or_None(
1678
# All changed entries need to have their parents be directories and be
1679
# at the right path. This set contains (path, id) tuples.
1681
# When we delete an item, all the children of it must be either deleted
1682
# or altered in their own right. As we batch process the change via
1683
# CHKMap.apply_delta, we build a set of things to use to validate the
1687
for old_path, new_path, file_id, entry in inventory_delta:
1690
result.root_id = file_id
1691
if new_path is None:
1696
if propagate_caches:
1698
del result._path_to_fileid_cache[old_path]
1701
deletes.add(file_id)
1703
new_key = StaticTuple(file_id,)
1704
new_value = result._entry_to_bytes(entry)
1705
# Update caches. It's worth doing this whether
1706
# we're propagating the old caches or not.
1707
result._path_to_fileid_cache[new_path] = file_id
1708
parents.add((split(new_path)[0], entry.parent_id))
1709
if old_path is None:
1712
old_key = StaticTuple(file_id,)
1713
if self.id2path(file_id) != old_path:
1714
raise errors.InconsistentDelta(old_path, file_id,
1715
"Entry was at wrong other path %r." %
1716
self.id2path(file_id))
1717
altered.add(file_id)
1718
id_to_entry_delta.append(StaticTuple(old_key, new_key, new_value))
1719
if result.parent_id_basename_to_file_id is not None:
1720
# parent_id, basename changes
1721
if old_path is None:
1724
old_entry = self.get_entry(file_id)
1725
old_key = self._parent_id_basename_key(old_entry)
1726
if new_path is None:
1730
new_key = self._parent_id_basename_key(entry)
1732
# If the two keys are the same, the value will be unchanged
1733
# as its always the file id for this entry.
1734
if old_key != new_key:
1735
# Transform a change into explicit delete/add preserving
1736
# a possible match on the key from a different file id.
1737
if old_key is not None:
1738
parent_id_basename_delta.setdefault(
1739
old_key, [None, None])[0] = old_key
1740
if new_key is not None:
1741
parent_id_basename_delta.setdefault(
1742
new_key, [None, None])[1] = new_value
1743
# validate that deletes are complete.
1744
for file_id in deletes:
1745
entry = self.get_entry(file_id)
1746
if entry.kind != 'directory':
1748
# This loop could potentially be better by using the id_basename
1749
# map to just get the child file ids.
1750
for child in viewvalues(entry.children):
1751
if child.file_id not in altered:
1752
raise errors.InconsistentDelta(self.id2path(child.file_id),
1753
child.file_id, "Child not deleted or reparented when "
1755
result.id_to_entry.apply_delta(id_to_entry_delta)
1756
if parent_id_basename_delta:
1757
# Transform the parent_id_basename delta data into a linear delta
1758
# with only one record for a given key. Optimally this would allow
1759
# re-keying, but its simpler to just output that as a delete+add
1760
# to spend less time calculating the delta.
1762
for key, (old_key, value) in viewitems(parent_id_basename_delta):
1763
if value is not None:
1764
delta_list.append((old_key, key, value))
1766
delta_list.append((old_key, None, None))
1767
result.parent_id_basename_to_file_id.apply_delta(delta_list)
1768
parents.discard(('', None))
1769
for parent_path, parent in parents:
1771
if result.get_entry(parent).kind != 'directory':
1772
raise errors.InconsistentDelta(result.id2path(parent), parent,
1773
'Not a directory, but given children')
1774
except errors.NoSuchId:
1775
raise errors.InconsistentDelta("<unknown>", parent,
1776
"Parent is not present in resulting inventory.")
1777
if result.path2id(parent_path) != parent:
1778
raise errors.InconsistentDelta(parent_path, parent,
1779
"Parent has wrong path %r." % result.path2id(parent_path))
1783
def deserialise(klass, chk_store, bytes, expected_revision_id):
1784
"""Deserialise a CHKInventory.
1786
:param chk_store: A CHK capable VersionedFiles instance.
1787
:param bytes: The serialised bytes.
1788
:param expected_revision_id: The revision ID we think this inventory is
1790
:return: A CHKInventory
1792
lines = bytes.split(b'\n')
1793
if lines[-1] != b'':
1794
raise AssertionError('bytes to deserialize must end with an eol')
1796
if lines[0] != b'chkinventory:':
1797
raise ValueError("not a serialised CHKInventory: %r" % bytes)
1799
allowed_keys = frozenset((b'root_id', b'revision_id',
1800
b'parent_id_basename_to_file_id',
1801
b'search_key_name', b'id_to_entry'))
1802
for line in lines[1:]:
1803
key, value = line.split(b': ', 1)
1804
if key not in allowed_keys:
1805
raise errors.BzrError('Unknown key in inventory: %r\n%r'
1808
raise errors.BzrError('Duplicate key in inventory: %r\n%r'
1811
revision_id = bytesintern(info[b'revision_id'])
1812
root_id = bytesintern(info[b'root_id'])
1813
search_key_name = bytesintern(info.get(b'search_key_name', b'plain'))
1814
parent_id_basename_to_file_id = bytesintern(info.get(
1815
b'parent_id_basename_to_file_id', None))
1816
if not parent_id_basename_to_file_id.startswith(b'sha1:'):
1817
raise ValueError('parent_id_basename_to_file_id should be a sha1'
1818
' key not %r' % (parent_id_basename_to_file_id,))
1819
id_to_entry = info[b'id_to_entry']
1820
if not id_to_entry.startswith(b'sha1:'):
1821
raise ValueError('id_to_entry should be a sha1'
1822
' key not %r' % (id_to_entry,))
1824
result = CHKInventory(search_key_name)
1825
result.revision_id = revision_id
1826
result.root_id = root_id
1827
search_key_func = chk_map.search_key_registry.get(
1828
result._search_key_name)
1829
if parent_id_basename_to_file_id is not None:
1830
result.parent_id_basename_to_file_id = chk_map.CHKMap(
1831
chk_store, StaticTuple(parent_id_basename_to_file_id,),
1832
search_key_func=search_key_func)
1834
result.parent_id_basename_to_file_id = None
1836
result.id_to_entry = chk_map.CHKMap(chk_store,
1837
StaticTuple(id_to_entry,),
1838
search_key_func=search_key_func)
1839
if (result.revision_id,) != expected_revision_id:
1840
raise ValueError("Mismatched revision id and expected: %r, %r" %
1841
(result.revision_id, expected_revision_id))
1845
def from_inventory(klass, chk_store, inventory, maximum_size=0, search_key_name=b'plain'):
1846
"""Create a CHKInventory from an existing inventory.
1848
The content of inventory is copied into the chk_store, and a
1849
CHKInventory referencing that is returned.
1851
:param chk_store: A CHK capable VersionedFiles instance.
1852
:param inventory: The inventory to copy.
1853
:param maximum_size: The CHKMap node size limit.
1854
:param search_key_name: The identifier for the search key function
1856
result = klass(search_key_name)
1857
result.revision_id = inventory.revision_id
1858
result.root_id = inventory.root.file_id
1860
entry_to_bytes = result._entry_to_bytes
1861
parent_id_basename_key = result._parent_id_basename_key
1862
id_to_entry_dict = {}
1863
parent_id_basename_dict = {}
1864
for path, entry in inventory.iter_entries():
1865
key = StaticTuple(entry.file_id,).intern()
1866
id_to_entry_dict[key] = entry_to_bytes(entry)
1867
p_id_key = parent_id_basename_key(entry)
1868
parent_id_basename_dict[p_id_key] = entry.file_id
1870
result._populate_from_dicts(chk_store, id_to_entry_dict,
1871
parent_id_basename_dict, maximum_size=maximum_size)
1874
def _populate_from_dicts(self, chk_store, id_to_entry_dict,
1875
parent_id_basename_dict, maximum_size):
1876
search_key_func = chk_map.search_key_registry.get(self._search_key_name)
1877
root_key = chk_map.CHKMap.from_dict(chk_store, id_to_entry_dict,
1878
maximum_size=maximum_size, key_width=1,
1879
search_key_func=search_key_func)
1880
self.id_to_entry = chk_map.CHKMap(chk_store, root_key,
1882
root_key = chk_map.CHKMap.from_dict(chk_store,
1883
parent_id_basename_dict,
1884
maximum_size=maximum_size, key_width=2,
1885
search_key_func=search_key_func)
1886
self.parent_id_basename_to_file_id = chk_map.CHKMap(chk_store,
1887
root_key, search_key_func)
1889
def _parent_id_basename_key(self, entry):
1890
"""Create a key for a entry in a parent_id_basename_to_file_id index."""
1891
if entry.parent_id is not None:
1892
parent_id = entry.parent_id
1895
return StaticTuple(parent_id, entry.name.encode('utf8')).intern()
1897
def get_entry(self, file_id):
1898
"""map a single file_id -> InventoryEntry."""
1900
raise errors.NoSuchId(self, file_id)
1901
result = self._fileid_to_entry_cache.get(file_id, None)
1902
if result is not None:
1905
return self._bytes_to_entry(
1906
next(self.id_to_entry.iteritems([StaticTuple(file_id,)]))[1])
1907
except StopIteration:
1908
# really we're passing an inventory, not a tree...
1909
raise errors.NoSuchId(self, file_id)
1911
def _getitems(self, file_ids):
1912
"""Similar to get_entry, but lets you query for multiple.
1914
The returned order is undefined. And currently if an item doesn't
1915
exist, it isn't included in the output.
1919
for file_id in file_ids:
1920
entry = self._fileid_to_entry_cache.get(file_id, None)
1922
remaining.append(file_id)
1924
result.append(entry)
1925
file_keys = [StaticTuple(f,).intern() for f in remaining]
1926
for file_key, value in self.id_to_entry.iteritems(file_keys):
1927
entry = self._bytes_to_entry(value)
1928
result.append(entry)
1929
self._fileid_to_entry_cache[entry.file_id] = entry
1932
def has_id(self, file_id):
1933
# Perhaps have an explicit 'contains' method on CHKMap ?
1934
if self._fileid_to_entry_cache.get(file_id, None) is not None:
1937
self.id_to_entry.iteritems([StaticTuple(file_id,)]))) == 1
1939
def is_root(self, file_id):
1940
return file_id == self.root_id
1942
def _iter_file_id_parents(self, file_id):
1943
"""Yield the parents of file_id up to the root."""
1944
while file_id is not None:
1946
ie = self.get_entry(file_id)
1948
raise errors.NoSuchId(tree=self, file_id=file_id)
1950
file_id = ie.parent_id
1952
def iter_all_ids(self):
1953
"""Iterate over all file-ids."""
1954
for key, _ in self.id_to_entry.iteritems():
1957
def iter_just_entries(self):
1958
"""Iterate over all entries.
1960
Unlike iter_entries(), just the entries are returned (not (path, ie))
1961
and the order of entries is undefined.
1963
XXX: We may not want to merge this into bzr.dev.
1965
for key, entry in self.id_to_entry.iteritems():
1967
ie = self._fileid_to_entry_cache.get(file_id, None)
1969
ie = self._bytes_to_entry(entry)
1970
self._fileid_to_entry_cache[file_id] = ie
1973
def _preload_cache(self):
1974
"""Make sure all file-ids are in _fileid_to_entry_cache"""
1975
if self._fully_cached:
1976
return # No need to do it again
1977
# The optimal sort order is to use iteritems() directly
1978
cache = self._fileid_to_entry_cache
1979
for key, entry in self.id_to_entry.iteritems():
1981
if file_id not in cache:
1982
ie = self._bytes_to_entry(entry)
1986
last_parent_id = last_parent_ie = None
1987
pid_items = self.parent_id_basename_to_file_id.iteritems()
1988
for key, child_file_id in pid_items:
1989
if key == (b'', b''): # This is the root
1990
if child_file_id != self.root_id:
1991
raise ValueError('Data inconsistency detected.'
1992
' We expected data with key ("","") to match'
1993
' the root id, but %s != %s'
1994
% (child_file_id, self.root_id))
1996
parent_id, basename = key
1997
ie = cache[child_file_id]
1998
if parent_id == last_parent_id:
1999
parent_ie = last_parent_ie
2001
parent_ie = cache[parent_id]
2002
if parent_ie.kind != 'directory':
2003
raise ValueError('Data inconsistency detected.'
2004
' An entry in the parent_id_basename_to_file_id map'
2005
' has parent_id {%s} but the kind of that object'
2006
' is %r not "directory"' % (parent_id, parent_ie.kind))
2007
if parent_ie._children is None:
2008
parent_ie._children = {}
2009
basename = basename.decode('utf-8')
2010
if basename in parent_ie._children:
2011
existing_ie = parent_ie._children[basename]
2012
if existing_ie != ie:
2013
raise ValueError('Data inconsistency detected.'
2014
' Two entries with basename %r were found'
2015
' in the parent entry {%s}'
2016
% (basename, parent_id))
2017
if basename != ie.name:
2018
raise ValueError('Data inconsistency detected.'
2019
' In the parent_id_basename_to_file_id map, file_id'
2020
' {%s} is listed as having basename %r, but in the'
2021
' id_to_entry map it is %r'
2022
% (child_file_id, basename, ie.name))
2023
parent_ie._children[basename] = ie
2024
self._fully_cached = True
2026
def iter_changes(self, basis):
2027
"""Generate a Tree.iter_changes change list between this and basis.
2029
:param basis: Another CHKInventory.
2030
:return: An iterator over the changes between self and basis, as per
2031
tree.iter_changes().
2033
# We want: (file_id, (path_in_source, path_in_target),
2034
# changed_content, versioned, parent, name, kind,
2036
for key, basis_value, self_value in \
2037
self.id_to_entry.iter_changes(basis.id_to_entry):
2039
if basis_value is not None:
2040
basis_entry = basis._bytes_to_entry(basis_value)
2041
path_in_source = basis.id2path(file_id)
2042
basis_parent = basis_entry.parent_id
2043
basis_name = basis_entry.name
2044
basis_executable = basis_entry.executable
2046
path_in_source = None
2049
basis_executable = None
2050
if self_value is not None:
2051
self_entry = self._bytes_to_entry(self_value)
2052
path_in_target = self.id2path(file_id)
2053
self_parent = self_entry.parent_id
2054
self_name = self_entry.name
2055
self_executable = self_entry.executable
2057
path_in_target = None
2060
self_executable = None
2061
if basis_value is None:
2063
kind = (None, self_entry.kind)
2064
versioned = (False, True)
2065
elif self_value is None:
2067
kind = (basis_entry.kind, None)
2068
versioned = (True, False)
2070
kind = (basis_entry.kind, self_entry.kind)
2071
versioned = (True, True)
2072
changed_content = False
2073
if kind[0] != kind[1]:
2074
changed_content = True
2075
elif kind[0] == 'file':
2076
if (self_entry.text_size != basis_entry.text_size or
2077
self_entry.text_sha1 != basis_entry.text_sha1):
2078
changed_content = True
2079
elif kind[0] == 'symlink':
2080
if self_entry.symlink_target != basis_entry.symlink_target:
2081
changed_content = True
2082
elif kind[0] == 'tree-reference':
2083
if (self_entry.reference_revision !=
2084
basis_entry.reference_revision):
2085
changed_content = True
2086
parent = (basis_parent, self_parent)
2087
name = (basis_name, self_name)
2088
executable = (basis_executable, self_executable)
2089
if (not changed_content
2090
and parent[0] == parent[1]
2091
and name[0] == name[1]
2092
and executable[0] == executable[1]):
2093
# Could happen when only the revision changed for a directory
2096
yield (file_id, (path_in_source, path_in_target), changed_content,
2097
versioned, parent, name, kind, executable)
2100
"""Return the number of entries in the inventory."""
2101
return len(self.id_to_entry)
2103
def _make_delta(self, old):
2104
"""Make an inventory delta from two inventories."""
2105
if not isinstance(old, CHKInventory):
2106
return CommonInventory._make_delta(self, old)
2108
for key, old_value, self_value in \
2109
self.id_to_entry.iter_changes(old.id_to_entry):
2111
if old_value is not None:
2112
old_path = old.id2path(file_id)
2115
if self_value is not None:
2116
entry = self._bytes_to_entry(self_value)
2117
self._fileid_to_entry_cache[file_id] = entry
2118
new_path = self.id2path(file_id)
2122
delta.append((old_path, new_path, file_id, entry))
2125
def path2id(self, relpath):
2126
"""See CommonInventory.path2id()."""
2127
# TODO: perhaps support negative hits?
2128
if isinstance(relpath, (str, text_type)):
2129
names = osutils.splitpath(relpath)
2134
relpath = osutils.pathjoin(*relpath)
2135
result = self._path_to_fileid_cache.get(relpath, None)
2136
if result is not None:
2138
current_id = self.root_id
2139
if current_id is None:
2141
parent_id_index = self.parent_id_basename_to_file_id
2143
for basename in names:
2144
if cur_path is None:
2147
cur_path = cur_path + '/' + basename
2148
basename_utf8 = basename.encode('utf8')
2149
file_id = self._path_to_fileid_cache.get(cur_path, None)
2151
key_filter = [StaticTuple(current_id, basename_utf8)]
2152
items = parent_id_index.iteritems(key_filter)
2153
for (parent_id, name_utf8), file_id in items:
2154
if parent_id != current_id or name_utf8 != basename_utf8:
2155
raise errors.BzrError("corrupt inventory lookup! "
2156
"%r %r %r %r" % (parent_id, current_id, name_utf8,
2161
self._path_to_fileid_cache[cur_path] = file_id
2162
current_id = file_id
2166
"""Serialise the inventory to lines."""
2167
lines = [b"chkinventory:\n"]
2168
if self._search_key_name != b'plain':
2169
# custom ordering grouping things that don't change together
2170
lines.append(b'search_key_name: %s\n' % (
2171
self._search_key_name))
2172
lines.append(b"root_id: %s\n" % self.root_id)
2173
lines.append(b'parent_id_basename_to_file_id: %s\n' %
2174
(self.parent_id_basename_to_file_id.key()[0],))
2175
lines.append(b"revision_id: %s\n" % self.revision_id)
2176
lines.append(b"id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
2178
lines.append(b"revision_id: %s\n" % self.revision_id)
2179
lines.append(b"root_id: %s\n" % self.root_id)
2180
if self.parent_id_basename_to_file_id is not None:
2181
lines.append(b'parent_id_basename_to_file_id: %s\n' %
2182
(self.parent_id_basename_to_file_id.key()[0],))
2183
lines.append(b"id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
2188
"""Get the root entry."""
2189
return self.get_entry(self.root_id)
2192
class CHKInventoryDirectory(InventoryDirectory):
2193
"""A directory in an inventory."""
2195
__slots__ = ['_children', '_chk_inventory']
2197
def __init__(self, file_id, name, parent_id, chk_inventory):
2198
# Don't call InventoryDirectory.__init__ - it isn't right for this
2200
InventoryEntry.__init__(self, file_id, name, parent_id)
2201
self._children = None
2202
self._chk_inventory = chk_inventory
2206
"""Access the list of children of this directory.
2208
With a parent_id_basename_to_file_id index, loads all the children,
2209
without loads the entire index. Without is bad. A more sophisticated
2210
proxy object might be nice, to allow partial loading of children as
2211
well when specific names are accessed. (So path traversal can be
2212
written in the obvious way but not examine siblings.).
2214
if self._children is not None:
2215
return self._children
2216
# No longer supported
2217
if self._chk_inventory.parent_id_basename_to_file_id is None:
2218
raise AssertionError("Inventories without"
2219
" parent_id_basename_to_file_id are no longer supported")
2221
# XXX: Todo - use proxy objects for the children rather than loading
2222
# all when the attribute is referenced.
2223
parent_id_index = self._chk_inventory.parent_id_basename_to_file_id
2225
for (parent_id, name_utf8), file_id in parent_id_index.iteritems(
2226
key_filter=[StaticTuple(self.file_id,)]):
2227
child_keys.add(StaticTuple(file_id,))
2229
for file_id_key in child_keys:
2230
entry = self._chk_inventory._fileid_to_entry_cache.get(
2231
file_id_key[0], None)
2232
if entry is not None:
2233
result[entry.name] = entry
2234
cached.add(file_id_key)
2235
child_keys.difference_update(cached)
2236
# populate; todo: do by name
2237
id_to_entry = self._chk_inventory.id_to_entry
2238
for file_id_key, bytes in id_to_entry.iteritems(child_keys):
2239
entry = self._chk_inventory._bytes_to_entry(bytes)
2240
result[entry.name] = entry
2241
self._chk_inventory._fileid_to_entry_cache[file_id_key[0]] = entry
2242
self._children = result
2245
1373
entry_factory = {
2246
1374
'directory': InventoryDirectory,
2247
1375
'file': InventoryFile,
added
removed
bzrlib/inventory.py
