~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: 2007-03-09 22:57:21 UTC
  • mfrom: (1551.12.48 mergedirective)
  • Revision ID: pqm@pqm.ubuntu.com-20070309225721-d395866527ca9a47
Add support for merge directives

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
"""MemoryTree object.
 
18
 
 
19
See MemoryTree for more details.
 
20
"""
 
21
 
 
22
 
 
23
from copy import deepcopy
 
24
 
 
25
from bzrlib import errors, mutabletree
 
26
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
27
from bzrlib.osutils import sha_file
 
28
from bzrlib.mutabletree import needs_tree_write_lock
 
29
from bzrlib.transport.memory import MemoryTransport
 
30
 
 
31
 
 
32
class MemoryTree(mutabletree.MutableTree):
 
33
    """A MemoryTree is a specialisation of MutableTree.
 
34
    
 
35
    It maintains nearly no state outside of read_lock and write_lock
 
36
    transactions. (it keeps a reference to the branch, and its last-revision
 
37
    only).
 
38
    """
 
39
 
 
40
    def __init__(self, branch, revision_id):
 
41
        """Construct a MemoryTree for branch using revision_id."""
 
42
        self.branch = branch
 
43
        self.bzrdir = branch.bzrdir
 
44
        self._branch_revision_id = revision_id
 
45
        self._locks = 0
 
46
        self._lock_mode = None
 
47
 
 
48
    @needs_tree_write_lock
 
49
    def _add(self, files, ids, kinds):
 
50
        """See MutableTree._add."""
 
51
        for f, file_id, kind in zip(files, ids, kinds):
 
52
            if kind is None:
 
53
                kind = 'file'
 
54
            if file_id is None:
 
55
                self._inventory.add_path(f, kind=kind)
 
56
            else:
 
57
                self._inventory.add_path(f, kind=kind, file_id=file_id)
 
58
 
 
59
    def basis_tree(self):
 
60
        """See Tree.basis_tree()."""
 
61
        return self._basis_tree
 
62
 
 
63
    @staticmethod
 
64
    def create_on_branch(branch):
 
65
        """Create a MemoryTree for branch, using the last-revision of branch."""
 
66
        return MemoryTree(branch, branch.last_revision())
 
67
 
 
68
    def _gather_kinds(self, files, kinds):
 
69
        """See MutableTree._gather_kinds.
 
70
        
 
71
        This implementation does not care about the file kind of
 
72
        missing files, so is a no-op.
 
73
        """
 
74
 
 
75
    def get_file(self, file_id):
 
76
        """See Tree.get_file."""
 
77
        return self._file_transport.get(self.id2path(file_id))
 
78
 
 
79
    def get_file_sha1(self, file_id, path=None):
 
80
        """See Tree.get_file_sha1()."""
 
81
        if path is None:
 
82
            path = self.id2path(file_id)
 
83
        stream = self._file_transport.get(path)
 
84
        return sha_file(stream)
 
85
 
 
86
    @needs_read_lock
 
87
    def get_parent_ids(self):
 
88
        """See Tree.get_parent_ids.
 
89
 
 
90
        This implementation returns the current cached value from
 
91
            self._parent_ids.
 
92
        """
 
93
        return list(self._parent_ids)
 
94
 
 
95
    def has_filename(self, filename):
 
96
        """See Tree.has_filename()."""
 
97
        return self._file_transport.has(filename)
 
98
 
 
99
    def is_executable(self, file_id, path=None):
 
100
        return self._inventory[file_id].executable
 
101
 
 
102
    def kind(self, file_id):
 
103
        return self._inventory[file_id].kind
 
104
 
 
105
    def mkdir(self, path, file_id=None):
 
106
        """See MutableTree.mkdir()."""
 
107
        self.add(path, file_id, 'directory')
 
108
        if file_id is None:
 
109
            file_id = self.path2id(path)
 
110
        self._file_transport.mkdir(path)
 
111
        return file_id
 
112
 
 
113
    @needs_read_lock
 
114
    def last_revision(self):
 
115
        """See MutableTree.last_revision."""
 
116
        return self._branch_revision_id
 
117
 
 
118
    def lock_read(self):
 
119
        """Lock the memory tree for reading.
 
120
 
 
121
        This triggers population of data from the branch for its revision.
 
122
        """
 
123
        self._locks += 1
 
124
        try:
 
125
            if self._locks == 1:
 
126
                self.branch.lock_read()
 
127
                self._lock_mode = "r"
 
128
                self._populate_from_branch()
 
129
        except:
 
130
            self._locks -= 1
 
131
            raise
 
132
 
 
133
    def lock_tree_write(self):
 
134
        """See MutableTree.lock_tree_write()."""
 
135
        self._locks += 1
 
136
        try:
 
137
            if self._locks == 1:
 
138
                self.branch.lock_read()
 
139
                self._lock_mode = "w"
 
140
                self._populate_from_branch()
 
141
            elif self._lock_mode == "r":
 
142
                raise errors.ReadOnlyError(self)
 
143
        except:
 
144
            self._locks -= 1
 
145
            raise
 
146
 
 
147
    def lock_write(self):
 
148
        """See MutableTree.lock_write()."""
 
149
        self._locks += 1
 
150
        try:
 
151
            if self._locks == 1:
 
152
                self.branch.lock_write()
 
153
                self._lock_mode = "w"
 
154
                self._populate_from_branch()
 
155
            elif self._lock_mode == "r":
 
156
                raise errors.ReadOnlyError(self)
 
157
        except:
 
158
            self._locks -= 1
 
159
            raise
 
160
 
 
161
    def _populate_from_branch(self):
 
162
        """Populate the in-tree state from the branch."""
 
163
        self._basis_tree = self.branch.repository.revision_tree(
 
164
            self._branch_revision_id)
 
165
        if self._branch_revision_id is None:
 
166
            self._parent_ids = []
 
167
        else:
 
168
            self._parent_ids = [self._branch_revision_id]
 
169
        self._inventory = deepcopy(self._basis_tree._inventory)
 
170
        self._file_transport = MemoryTransport()
 
171
        # TODO copy the revision trees content, or do it lazy, or something.
 
172
        inventory_entries = self._inventory.iter_entries()
 
173
        for path, entry in inventory_entries:
 
174
            if path == '':
 
175
                continue
 
176
            if entry.kind == 'directory':
 
177
                self._file_transport.mkdir(path)
 
178
            elif entry.kind == 'file':
 
179
                self._file_transport.put_file(path,
 
180
                    self._basis_tree.get_file(entry.file_id))
 
181
            else:
 
182
                raise NotImplementedError(self._populate_from_branch)
 
183
 
 
184
    def put_file_bytes_non_atomic(self, file_id, bytes):
 
185
        """See MutableTree.put_file_bytes_non_atomic."""
 
186
        self._file_transport.put_bytes(self.id2path(file_id), bytes)
 
187
 
 
188
    def unlock(self):
 
189
        """Release a lock.
 
190
 
 
191
        This frees all cached state when the last lock context for the tree is
 
192
        left.
 
193
        """
 
194
        if self._locks == 1:
 
195
            self._basis_tree = None
 
196
            self._parent_ids = []
 
197
            self._inventory = None
 
198
            try:
 
199
                self.branch.unlock()
 
200
            finally:
 
201
                self._locks = 0
 
202
                self._lock_mode = None
 
203
        else:
 
204
            self._locks -= 1
 
205
 
 
206
    @needs_tree_write_lock
 
207
    def unversion(self, file_ids):
 
208
        """Remove the file ids in file_ids from the current versioned set.
 
209
 
 
210
        When a file_id is unversioned, all of its children are automatically
 
211
        unversioned.
 
212
 
 
213
        :param file_ids: The file ids to stop versioning.
 
214
        :raises: NoSuchId if any fileid is not currently versioned.
 
215
        """
 
216
        # XXX: This should be in mutabletree, but the inventory-save action
 
217
        # is not relevant to memory tree. Until that is done in unlock by
 
218
        # working tree, we cannot share the implementation.
 
219
        for file_id in file_ids:
 
220
            if self._inventory.has_id(file_id):
 
221
                self._inventory.remove_recursive_id(file_id)
 
222
            else:
 
223
                raise errors.NoSuchId(self, file_id)
 
224
 
 
225
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
226
        """See MutableTree.set_parent_trees()."""
 
227
        if len(parents_list) == 0:
 
228
            self._parent_ids = []
 
229
            self._basis_tree = self.branch.repository.revisiontree(None)
 
230
        else:
 
231
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
 
232
                # a ghost in the left most parent
 
233
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
 
234
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
 
235
            if parents_list[0][1] is None:
 
236
                self._basis_tree = self.branch.repository.revisiontree(None)
 
237
            else:
 
238
                self._basis_tree = parents_list[0][1]
 
239
            self._branch_revision_id = parents_list[0][0]