← 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-08-28 20:13:31 UTC
  • mfrom: (3658 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3688.
  • Revision ID: john@arbash-meinel.com-20080828201331-dqffxf54l2heokll
Merge bzr.dev 3658

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
 
20
20
"""
21
21
 
22
22
 
23
 
import os
 
23
from copy import deepcopy
24
24
 
25
25
from bzrlib import (
26
26
    errors,
27
27
    mutabletree,
28
28
    revision as _mod_revision,
29
29
    )
30
 
from bzrlib.decorators import needs_read_lock
31
 
from bzrlib.inventory import Inventory
 
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
32
31
from bzrlib.osutils import sha_file
33
32
from bzrlib.mutabletree import needs_tree_write_lock
34
33
from bzrlib.transport.memory import MemoryTransport
35
34
 
36
35
 
37
 
class MemoryTree(mutabletree.MutableInventoryTree):
 
36
class MemoryTree(mutabletree.MutableTree):
38
37
    """A MemoryTree is a specialisation of MutableTree.
39
 
 
 
38
    
40
39
    It maintains nearly no state outside of read_lock and write_lock
41
40
    transactions. (it keeps a reference to the branch, and its last-revision
42
41
    only).
50
49
        self._locks = 0
51
50
        self._lock_mode = None
52
51
 
53
 
    def is_control_filename(self, filename):
54
 
        # Memory tree doesn't have any control filenames
55
 
        return False
56
 
 
57
52
    @needs_tree_write_lock
58
53
    def _add(self, files, ids, kinds):
59
54
        """See MutableTree._add."""
73
68
    def create_on_branch(branch):
74
69
        """Create a MemoryTree for branch, using the last-revision of branch."""
75
70
        revision_id = _mod_revision.ensure_null(branch.last_revision())
 
71
        if _mod_revision.is_null(revision_id):
 
72
            revision_id = None
76
73
        return MemoryTree(branch, revision_id)
77
74
 
78
75
    def _gather_kinds(self, files, kinds):
79
76
        """See MutableTree._gather_kinds.
80
 
 
 
77
        
81
78
        This implementation does not care about the file kind of
82
79
        missing files, so is a no-op.
83
80
        """
104
101
            return None, False, None
105
102
        return entry.kind, entry.executable, None
106
103
 
107
 
    @needs_tree_write_lock
108
 
    def rename_one(self, from_rel, to_rel):
109
 
        file_id = self.path2id(from_rel)
110
 
        to_dir, to_tail = os.path.split(to_rel)
111
 
        to_parent_id = self.path2id(to_dir)
112
 
        self._file_transport.move(from_rel, to_rel)
113
 
        self._inventory.rename(file_id, to_parent_id, to_tail)
114
 
 
115
104
    def path_content_summary(self, path):
116
105
        """See Tree.path_content_summary."""
117
106
        id = self.path2id(path)
215
204
 
216
205
    def _populate_from_branch(self):
217
206
        """Populate the in-tree state from the branch."""
218
 
        self._set_basis()
219
 
        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:
220
210
            self._parent_ids = []
221
211
        else:
222
212
            self._parent_ids = [self._branch_revision_id]
223
 
        self._inventory = Inventory(None, self._basis_tree.get_revision_id())
 
213
        self._inventory = deepcopy(self._basis_tree._inventory)
224
214
        self._file_transport = MemoryTransport()
225
215
        # TODO copy the revision trees content, or do it lazy, or something.
226
 
        inventory_entries = self._basis_tree.iter_entries_by_dir()
 
216
        inventory_entries = self._inventory.iter_entries()
227
217
        for path, entry in inventory_entries:
228
 
            self._inventory.add(entry.copy())
229
218
            if path == '':
230
219
                continue
231
220
            if entry.kind == 'directory':
283
272
            _mod_revision.check_not_reserved_id(revision_id)
284
273
        if len(revision_ids) == 0:
285
274
            self._parent_ids = []
286
 
            self._branch_revision_id = _mod_revision.NULL_REVISION
 
275
            self._basis_tree = self.branch.repository.revision_tree(None)
287
276
        else:
288
277
            self._parent_ids = revision_ids
 
278
            self._basis_tree = self.branch.repository.revision_tree(
 
279
                                    revision_ids[0])
289
280
            self._branch_revision_id = revision_ids[0]
290
 
        self._allow_leftmost_as_ghost = allow_leftmost_as_ghost
291
 
        self._set_basis()
292
 
    
293
 
    def _set_basis(self):
294
 
        try:
295
 
            self._basis_tree = self.branch.repository.revision_tree(
296
 
                self._branch_revision_id)
297
 
        except errors.NoSuchRevision:
298
 
            if self._allow_leftmost_as_ghost:
299
 
                self._basis_tree = self.branch.repository.revision_tree(
300
 
                    _mod_revision.NULL_REVISION)
301
 
            else:
302
 
                raise
303
281
 
304
282
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
305
283
        """See MutableTree.set_parent_trees()."""
306
284
        if len(parents_list) == 0:
307
285
            self._parent_ids = []
308
 
            self._basis_tree = self.branch.repository.revision_tree(
309
 
                                   _mod_revision.NULL_REVISION)
 
286
            self._basis_tree = self.branch.repository.revision_tree(None)
310
287
        else:
311
288
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
312
289
                # a ghost in the left most parent
313
290
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
314
291
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
315
292
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
316
 
                self._basis_tree = self.branch.repository.revision_tree(
317
 
                                       _mod_revision.NULL_REVISION)
 
293
                self._basis_tree = self.branch.repository.revision_tree(None)
318
294
            else:
319
295
                self._basis_tree = parents_list[0][1]
320
296
            self._branch_revision_id = parents_list[0][0]