548
549
self._ensure_block(block_index, entry_index, utf8path)
549
550
self._dirblock_state = DirState.IN_MEMORY_MODIFIED
550
551
if self._id_index:
551
self._id_index.setdefault(entry_key[2], set()).add(entry_key)
552
self._add_to_id_index(self._id_index, entry_key)
553
554
def _bisect(self, paths):
554
555
"""Bisect through the disk structure for specific rows.
1567
1568
id_index = self._get_id_index()
1568
1569
for file_id in new_ids:
1569
for key in id_index.get(file_id, []):
1570
for key in id_index.get(file_id, ()):
1570
1571
block_i, entry_i, d_present, f_present = \
1571
1572
self._get_block_entry_index(key[0], key[1], tree_index)
1572
1573
if not f_present:
1980
1981
' tree_index, file_id and path')
1983
possible_keys = self._get_id_index().get(fileid_utf8, None)
1984
possible_keys = self._get_id_index().get(fileid_utf8, ())
1984
1985
if not possible_keys:
1985
1986
return None, None
1986
1987
for key in possible_keys:
2145
2146
def _get_id_index(self):
2146
"""Get an id index of self._dirblocks."""
2147
"""Get an id index of self._dirblocks.
2149
This maps from file_id => [(directory, name, file_id)] entries where
2150
that file_id appears in one of the trees.
2147
2152
if self._id_index is None:
2149
2154
for key, tree_details in self._iter_entries():
2150
id_index.setdefault(key[2], set()).add(key)
2155
self._add_to_id_index(id_index, key)
2151
2156
self._id_index = id_index
2152
2157
return self._id_index
2159
def _add_to_id_index(self, id_index, entry_key):
2160
"""Add this entry to the _id_index mapping."""
2161
# This code used to use a set for every entry in the id_index. However,
2162
# it is *rare* to have more than one entry. So a set is a large
2163
# overkill. And even when we do, we won't ever have more than the
2164
# number of parent trees. Which is still a small number (rarely >2). As
2165
# such, we use a simple tuple, and do our own uniqueness checks. While
2166
# the 'in' check is O(N) since N is nicely bounded it shouldn't ever
2167
# cause quadratic failure.
2168
# TODO: This should use StaticTuple
2169
file_id = entry_key[2]
2170
entry_key = static_tuple.StaticTuple.from_sequence(entry_key)
2171
if file_id not in id_index:
2172
id_index[file_id] = static_tuple.StaticTuple(entry_key,)
2174
entry_keys = id_index[file_id]
2175
if entry_key not in entry_keys:
2176
id_index[file_id] = entry_keys + (entry_key,)
2178
def _remove_from_id_index(self, id_index, entry_key):
2179
"""Remove this entry from the _id_index mapping.
2181
It is an programming error to call this when the entry_key is not
2184
file_id = entry_key[2]
2185
entry_keys = list(id_index[file_id])
2186
entry_keys.remove(entry_key)
2187
id_index[file_id] = static_tuple.StaticTuple.from_sequence(entry_keys)
2154
2189
def _get_output_lines(self, lines):
2155
2190
"""Format lines for final output.
2415
2450
by_path[entry[0]] = [entry[1][0]] + \
2416
2451
[DirState.NULL_PARENT_DETAILS] * parent_count
2417
id_index[entry[0][2]] = set([entry[0]])
2452
# TODO: Possibly inline this, since we know it isn't present yet
2453
# id_index[entry[0][2]] = (entry[0],)
2454
self._add_to_id_index(id_index, entry[0])
2419
2456
# now the parent trees:
2420
2457
for tree_index, tree in enumerate(parent_trees):
2442
2479
new_entry_key = (dirname, basename, file_id)
2443
2480
# tree index consistency: All other paths for this id in this tree
2444
2481
# index must point to the correct path.
2445
for entry_key in id_index.setdefault(file_id, set()):
2482
for entry_key in id_index.get(file_id, ()):
2446
2483
# TODO:PROFILING: It might be faster to just update
2447
2484
# rather than checking if we need to, and then overwrite
2448
2485
# the one we are located at.
2454
2491
by_path[entry_key][tree_index] = ('r', path_utf8, 0, False, '')
2455
2492
# by path consistency: Insert into an existing path record (trivial), or
2456
2493
# add a new one with relocation pointers for the other tree indexes.
2457
if new_entry_key in id_index[file_id]:
2494
entry_keys = id_index.get(file_id, ())
2495
if new_entry_key in entry_keys:
2458
2496
# there is already an entry where this data belongs, just insert it.
2459
2497
by_path[new_entry_key][tree_index] = \
2460
2498
self._inv_entry_to_details(entry)
2465
2503
new_details = []
2466
2504
for lookup_index in xrange(tree_index):
2467
2505
# boundary case: this is the first occurence of file_id
2468
# so there are no id_indexs, possibly take this out of
2506
# so there are no id_indexes, possibly take this out of
2470
if not len(id_index[file_id]):
2508
if not len(entry_keys):
2471
2509
new_details.append(DirState.NULL_PARENT_DETAILS)
2473
2511
# grab any one entry, use it to find the right path.
2474
2512
# TODO: optimise this to reduce memory use in highly
2475
2513
# fragmented situations by reusing the relocation
2477
a_key = iter(id_index[file_id]).next()
2515
a_key = iter(entry_keys).next()
2478
2516
if by_path[a_key][lookup_index][0] in ('r', 'a'):
2479
2517
# its a pointer or missing statement, use it as is.
2480
2518
new_details.append(by_path[a_key][lookup_index])
2485
2523
new_details.append(self._inv_entry_to_details(entry))
2486
2524
new_details.extend(new_location_suffix)
2487
2525
by_path[new_entry_key] = new_details
2488
id_index[file_id].add(new_entry_key)
2526
self._add_to_id_index(id_index, new_entry_key)
2489
2527
# --- end generation of full tree mappings
2491
2529
# sort and output all the entries
2644
2682
trace.mutter("set_state_from_inventory complete.")
2684
def set_state_from_scratch(self, working_inv, parent_trees, parent_ghosts):
2685
"""Wipe the currently stored state and set it to something new.
2687
This is a hard-reset for the data we are working with.
2689
# Technically, we really want a write lock, but until we write, we
2690
# don't really need it.
2691
self._requires_lock()
2692
# root dir and root dir contents with no children. We have to have a
2693
# root for set_state_from_inventory to work correctly.
2694
empty_root = (('', '', inventory.ROOT_ID),
2695
[('d', '', 0, False, DirState.NULLSTAT)])
2696
empty_tree_dirblocks = [('', [empty_root]), ('', [])]
2697
self._set_data([], empty_tree_dirblocks)
2698
self.set_state_from_inventory(working_inv)
2699
self.set_parent_trees(parent_trees, parent_ghosts)
2646
2701
def _make_absent(self, current_old):
2647
2702
"""Mark current_old - an entry - as absent for tree 0.
2673
2728
block[1].pop(entry_index)
2674
2729
# if we have an id_index in use, remove this key from it for this id.
2675
2730
if self._id_index is not None:
2676
self._id_index[current_old[0][2]].remove(current_old[0])
2731
self._remove_from_id_index(self._id_index, current_old[0])
2677
2732
# update all remaining keys for this id to record it as absent. The
2678
2733
# existing details may either be the record we are marking as deleted
2679
2734
# (if there were other trees with the id present at this path), or may
2750
2805
# new entry, synthesis cross reference here,
2751
existing_keys = id_index.setdefault(key[2], set())
2806
existing_keys = id_index.get(key[2], ())
2752
2807
if not existing_keys:
2753
2808
# not currently in the state, simplest case
2754
2809
new_entry = key, [new_details] + self._empty_parent_info()
2786
2841
other_entry = other_block[other_entry_index]
2787
2842
other_entry[1][0] = ('r', path_utf8, 0, False, '')
2788
self._maybe_remove_row(other_block, other_entry_index,
2843
if self._maybe_remove_row(other_block, other_entry_index,
2845
# If the row holding this was removed, we need to
2846
# recompute where this entry goes
2847
entry_index, _ = self._find_entry_index(key, block)
2792
2850
# adds a tuple to the new details for each column
2794
2852
# - or by creating a new pointer to the right row inside that column
2795
2853
num_present_parents = self._num_present_parents()
2796
2854
if num_present_parents:
2855
# TODO: This re-evaluates the existing_keys set, do we need
2856
# to do that ourselves?
2797
2857
other_key = list(existing_keys)[0]
2798
2858
for lookup_index in xrange(1, num_present_parents + 1):
2799
2859
# grab any one entry, use it to find the right path.
2818
2878
pointer_path = osutils.pathjoin(*other_key[0:2])
2819
2879
new_entry[1].append(('r', pointer_path, 0, False, ''))
2820
2880
block.insert(entry_index, new_entry)
2821
existing_keys.add(key)
2881
self._add_to_id_index(id_index, key)
2823
2883
# Does the new state matter?
2824
2884
block[entry_index][1][0] = new_details
2833
2893
# converted to relocated.
2834
2894
if path_utf8 is None:
2835
2895
raise AssertionError('no path')
2836
for entry_key in id_index.setdefault(key[2], set()):
2896
existing_keys = id_index.get(key[2], ())
2897
if key not in existing_keys:
2898
raise AssertionError('We found the entry in the blocks, but'
2899
' the key is not in the id_index.'
2900
' key: %s, existing_keys: %s' % (key, existing_keys))
2901
for entry_key in existing_keys:
2837
2902
# TODO:PROFILING: It might be faster to just update
2838
2903
# rather than checking if we need to, and then overwrite
2839
2904
# the one we are located at.
added
removed
bzrlib/dirstate.py
