← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/memorytree.py

  • Committer: Ian Clatworthy
  • Date: 2009-09-09 11:43:10 UTC
  • mto: (4634.37.2 prepare-2.0)
  • mto: This revision was merged to the branch mainline in revision 4689.
  • Revision ID: ian.clatworthy@canonical.com-20090909114310-glw7tv76i5gnx9pt
put rules back in Makefile supporting plain-style docs

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
        """
92
91
        stream = self._file_transport.get(path)
93
92
        return sha_file(stream)
94
93
 
 
94
    def get_root_id(self):
 
95
        return self.path2id('')
 
96
 
95
97
    def _comparison_data(self, entry, path):
96
98
        """See Tree._comparison_data."""
97
99
        if entry is None:
98
100
            return None, False, None
99
101
        return entry.kind, entry.executable, None
100
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
 
 
111
    def path_content_summary(self, path):
 
112
        """See Tree.path_content_summary."""
 
113
        id = self.path2id(path)
 
114
        if id is None:
 
115
            return 'missing', None, None, None
 
116
        kind = self.kind(id)
 
117
        if kind == 'file':
 
118
            bytes = self._file_transport.get_bytes(path)
 
119
            size = len(bytes)
 
120
            executable = self._inventory[id].executable
 
121
            sha1 = None # no stat cache
 
122
            return (kind, size, executable, sha1)
 
123
        elif kind == 'directory':
 
124
            # memory tree does not support nested trees yet.
 
125
            return kind, None, None, None
 
126
        elif kind == 'symlink':
 
127
            raise NotImplementedError('symlink support')
 
128
        else:
 
129
            raise NotImplementedError('unknown kind')
 
130
 
101
131
    def _file_size(self, entry, stat_value):
102
132
        """See Tree._file_size."""
103
133
        if entry is None:
181
211
 
182
212
    def _populate_from_branch(self):
183
213
        """Populate the in-tree state from the branch."""
184
 
        self._basis_tree = self.branch.repository.revision_tree(
185
 
            self._branch_revision_id)
186
 
        if self._branch_revision_id is None:
 
214
        self._set_basis()
 
215
        if self._branch_revision_id == _mod_revision.NULL_REVISION:
187
216
            self._parent_ids = []
188
217
        else:
189
218
            self._parent_ids = [self._branch_revision_id]
190
 
        self._inventory = deepcopy(self._basis_tree._inventory)
 
219
        self._inventory = self._basis_tree._inventory._get_mutable_inventory()
191
220
        self._file_transport = MemoryTransport()
192
221
        # TODO copy the revision trees content, or do it lazy, or something.
193
222
        inventory_entries = self._inventory.iter_entries()
249
278
            _mod_revision.check_not_reserved_id(revision_id)
250
279
        if len(revision_ids) == 0:
251
280
            self._parent_ids = []
252
 
            self._basis_tree = self.branch.repository.revision_tree(None)
 
281
            self._branch_revision_id = _mod_revision.NULL_REVISION
253
282
        else:
254
283
            self._parent_ids = revision_ids
255
 
            self._basis_tree = self.branch.repository.revision_tree(
256
 
                                    revision_ids[0])
257
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
258
298
 
259
299
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
260
300
        """See MutableTree.set_parent_trees()."""
261
301
        if len(parents_list) == 0:
262
302
            self._parent_ids = []
263
 
            self._basis_tree = self.branch.repository.revision_tree(None)
 
303
            self._basis_tree = self.branch.repository.revision_tree(
 
304
                                   _mod_revision.NULL_REVISION)
264
305
        else:
265
306
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
266
307
                # a ghost in the left most parent
267
308
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
268
309
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
269
310
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
270
 
                import pdb; pdb.set_trace()
271
 
                self._basis_tree = self.branch.repository.revision_tree(None)
 
311
                self._basis_tree = self.branch.repository.revision_tree(
 
312
                                       _mod_revision.NULL_REVISION)
272
313
            else:
273
314
                self._basis_tree = parents_list[0][1]
274
315
            self._branch_revision_id = parents_list[0][0]