← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/memorytree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-03-11 13:47:06 UTC
  • mfrom: (5051.3.16 use-branch-open)
  • Revision ID: pqm@pqm.ubuntu.com-20100311134706-kaerqhx3lf7xn6rh
(Jelmer) Pass colocated branch names further down the call stack.

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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""MemoryTree object.
18
18
 
20
20
"""
21
21
 
22
22
 
23
 
from copy import deepcopy
 
23
import os
24
24
 
25
25
from bzrlib import (
26
26
    errors,
27
27
    mutabletree,
 
28
    osutils,
28
29
    revision as _mod_revision,
29
30
    )
30
31
from bzrlib.decorators import needs_read_lock, needs_write_lock
35
36
 
36
37
class MemoryTree(mutabletree.MutableTree):
37
38
    """A MemoryTree is a specialisation of MutableTree.
38
 
    
 
39
 
39
40
    It maintains nearly no state outside of read_lock and write_lock
40
41
    transactions. (it keeps a reference to the branch, and its last-revision
41
42
    only).
68
69
    def create_on_branch(branch):
69
70
        """Create a MemoryTree for branch, using the last-revision of branch."""
70
71
        revision_id = _mod_revision.ensure_null(branch.last_revision())
71
 
        if _mod_revision.is_null(revision_id):
72
 
            revision_id = None
73
72
        return MemoryTree(branch, revision_id)
74
73
 
75
74
    def _gather_kinds(self, files, kinds):
76
75
        """See MutableTree._gather_kinds.
77
 
        
 
76
 
78
77
        This implementation does not care about the file kind of
79
78
        missing files, so is a no-op.
80
79
        """
101
100
            return None, False, None
102
101
        return entry.kind, entry.executable, None
103
102
 
 
103
    @needs_tree_write_lock
 
104
    def rename_one(self, from_rel, to_rel):
 
105
        file_id = self.path2id(from_rel)
 
106
        to_dir, to_tail = os.path.split(to_rel)
 
107
        to_parent_id = self.path2id(to_dir)
 
108
        self._file_transport.move(from_rel, to_rel)
 
109
        self._inventory.rename(file_id, to_parent_id, to_tail)
 
110
 
104
111
    def path_content_summary(self, path):
105
112
        """See Tree.path_content_summary."""
106
113
        id = self.path2id(path)
204
211
 
205
212
    def _populate_from_branch(self):
206
213
        """Populate the in-tree state from the branch."""
207
 
        self._basis_tree = self.branch.repository.revision_tree(
208
 
            self._branch_revision_id)
209
 
        if self._branch_revision_id is None:
 
214
        self._set_basis()
 
215
        if self._branch_revision_id == _mod_revision.NULL_REVISION:
210
216
            self._parent_ids = []
211
217
        else:
212
218
            self._parent_ids = [self._branch_revision_id]
213
 
        self._inventory = deepcopy(self._basis_tree._inventory)
 
219
        self._inventory = self._basis_tree._inventory._get_mutable_inventory()
214
220
        self._file_transport = MemoryTransport()
215
221
        # TODO copy the revision trees content, or do it lazy, or something.
216
222
        inventory_entries = self._inventory.iter_entries()
272
278
            _mod_revision.check_not_reserved_id(revision_id)
273
279
        if len(revision_ids) == 0:
274
280
            self._parent_ids = []
275
 
            self._basis_tree = self.branch.repository.revision_tree(None)
 
281
            self._branch_revision_id = _mod_revision.NULL_REVISION
276
282
        else:
277
283
            self._parent_ids = revision_ids
278
 
            self._basis_tree = self.branch.repository.revision_tree(
279
 
                                    revision_ids[0])
280
284
            self._branch_revision_id = revision_ids[0]
 
285
        self._allow_leftmost_as_ghost = allow_leftmost_as_ghost
 
286
        self._set_basis()
 
287
    
 
288
    def _set_basis(self):
 
289
        try:
 
290
            self._basis_tree = self.branch.repository.revision_tree(
 
291
                self._branch_revision_id)
 
292
        except errors.NoSuchRevision:
 
293
            if self._allow_leftmost_as_ghost:
 
294
                self._basis_tree = self.branch.repository.revision_tree(
 
295
                    _mod_revision.NULL_REVISION)
 
296
            else:
 
297
                raise
281
298
 
282
299
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
283
300
        """See MutableTree.set_parent_trees()."""
284
301
        if len(parents_list) == 0:
285
302
            self._parent_ids = []
286
 
            self._basis_tree = self.branch.repository.revision_tree(None)
 
303
            self._basis_tree = self.branch.repository.revision_tree(
 
304
                                   _mod_revision.NULL_REVISION)
287
305
        else:
288
306
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
289
307
                # a ghost in the left most parent
290
308
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
291
309
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
292
310
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
293
 
                self._basis_tree = self.branch.repository.revision_tree(None)
 
311
                self._basis_tree = self.branch.repository.revision_tree(
 
312
                                       _mod_revision.NULL_REVISION)
294
313
            else:
295
314
                self._basis_tree = parents_list[0][1]
296
315
            self._branch_revision_id = parents_list[0][0]