← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/memorytree.py

  • Committer: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/memorytree.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""MemoryTree object.
18
18
 
19
19
See MemoryTree for more details.
20
20
"""
21
21
 
22
 
from __future__ import absolute_import
23
22
 
24
 
import os
 
23
from copy import deepcopy
25
24
 
26
25
from bzrlib import (
27
26
    errors,
28
27
    mutabletree,
29
28
    revision as _mod_revision,
30
29
    )
31
 
from bzrlib.decorators import needs_read_lock
32
 
from bzrlib.inventory import Inventory
 
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
33
31
from bzrlib.osutils import sha_file
34
32
from bzrlib.mutabletree import needs_tree_write_lock
35
33
from bzrlib.transport.memory import MemoryTransport
36
34
 
37
35
 
38
 
class MemoryTree(mutabletree.MutableInventoryTree):
 
36
class MemoryTree(mutabletree.MutableTree):
39
37
    """A MemoryTree is a specialisation of MutableTree.
40
 
 
 
38
    
41
39
    It maintains nearly no state outside of read_lock and write_lock
42
40
    transactions. (it keeps a reference to the branch, and its last-revision
43
41
    only).
51
49
        self._locks = 0
52
50
        self._lock_mode = None
53
51
 
54
 
    def get_config_stack(self):
55
 
        return self.branch.get_config_stack()
56
 
 
57
 
    def is_control_filename(self, filename):
58
 
        # Memory tree doesn't have any control filenames
59
 
        return False
60
 
 
61
52
    @needs_tree_write_lock
62
53
    def _add(self, files, ids, kinds):
63
54
        """See MutableTree._add."""
77
68
    def create_on_branch(branch):
78
69
        """Create a MemoryTree for branch, using the last-revision of branch."""
79
70
        revision_id = _mod_revision.ensure_null(branch.last_revision())
 
71
        if _mod_revision.is_null(revision_id):
 
72
            revision_id = None
80
73
        return MemoryTree(branch, revision_id)
81
74
 
82
75
    def _gather_kinds(self, files, kinds):
83
76
        """See MutableTree._gather_kinds.
84
 
 
 
77
        
85
78
        This implementation does not care about the file kind of
86
79
        missing files, so is a no-op.
87
80
        """
108
101
            return None, False, None
109
102
        return entry.kind, entry.executable, None
110
103
 
111
 
    @needs_tree_write_lock
112
 
    def rename_one(self, from_rel, to_rel):
113
 
        file_id = self.path2id(from_rel)
114
 
        to_dir, to_tail = os.path.split(to_rel)
115
 
        to_parent_id = self.path2id(to_dir)
116
 
        self._file_transport.move(from_rel, to_rel)
117
 
        self._inventory.rename(file_id, to_parent_id, to_tail)
118
 
 
119
104
    def path_content_summary(self, path):
120
105
        """See Tree.path_content_summary."""
121
106
        id = self.path2id(path)
219
204
 
220
205
    def _populate_from_branch(self):
221
206
        """Populate the in-tree state from the branch."""
222
 
        self._set_basis()
223
 
        if self._branch_revision_id == _mod_revision.NULL_REVISION:
 
207
        self._basis_tree = self.branch.repository.revision_tree(
 
208
            self._branch_revision_id)
 
209
        if self._branch_revision_id is None:
224
210
            self._parent_ids = []
225
211
        else:
226
212
            self._parent_ids = [self._branch_revision_id]
227
 
        self._inventory = Inventory(None, self._basis_tree.get_revision_id())
 
213
        self._inventory = deepcopy(self._basis_tree._inventory)
228
214
        self._file_transport = MemoryTransport()
229
215
        # TODO copy the revision trees content, or do it lazy, or something.
230
 
        inventory_entries = self._basis_tree.iter_entries_by_dir()
 
216
        inventory_entries = self._inventory.iter_entries()
231
217
        for path, entry in inventory_entries:
232
 
            self._inventory.add(entry.copy())
233
218
            if path == '':
234
219
                continue
235
220
            if entry.kind == 'directory':
287
272
            _mod_revision.check_not_reserved_id(revision_id)
288
273
        if len(revision_ids) == 0:
289
274
            self._parent_ids = []
290
 
            self._branch_revision_id = _mod_revision.NULL_REVISION
 
275
            self._basis_tree = self.branch.repository.revision_tree(None)
291
276
        else:
292
277
            self._parent_ids = revision_ids
 
278
            self._basis_tree = self.branch.repository.revision_tree(
 
279
                                    revision_ids[0])
293
280
            self._branch_revision_id = revision_ids[0]
294
 
        self._allow_leftmost_as_ghost = allow_leftmost_as_ghost
295
 
        self._set_basis()
296
 
    
297
 
    def _set_basis(self):
298
 
        try:
299
 
            self._basis_tree = self.branch.repository.revision_tree(
300
 
                self._branch_revision_id)
301
 
        except errors.NoSuchRevision:
302
 
            if self._allow_leftmost_as_ghost:
303
 
                self._basis_tree = self.branch.repository.revision_tree(
304
 
                    _mod_revision.NULL_REVISION)
305
 
            else:
306
 
                raise
307
281
 
308
282
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
309
283
        """See MutableTree.set_parent_trees()."""
310
284
        if len(parents_list) == 0:
311
285
            self._parent_ids = []
312
 
            self._basis_tree = self.branch.repository.revision_tree(
313
 
                                   _mod_revision.NULL_REVISION)
 
286
            self._basis_tree = self.branch.repository.revision_tree(None)
314
287
        else:
315
288
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
316
289
                # a ghost in the left most parent
317
290
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
318
291
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
319
292
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
320
 
                self._basis_tree = self.branch.repository.revision_tree(
321
 
                                       _mod_revision.NULL_REVISION)
 
293
                self._basis_tree = self.branch.repository.revision_tree(None)
322
294
            else:
323
295
                self._basis_tree = parents_list[0][1]
324
296
            self._branch_revision_id = parents_list[0][0]