/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

• browse files at revision 4775.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 4775.1.1

• reverse the comparison (4775.1.1 to 5200.3.3)
• stop comparing with revision 5200.3.3

Show diffs side-by-side

added

removed

bzrlib/workingtree_4.py

1

 

# Copyright (C) 2007-2010 Canonical Ltd

 

1

# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

53

53

from bzrlib.decorators import needs_read_lock, needs_write_lock

54

54

from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname

55

55

from bzrlib.inventory import Inventory, ROOT_ID, entry_factory

 

56

import bzrlib.mutabletree

56

57

from bzrlib.mutabletree import needs_tree_write_lock

57

58

from bzrlib.osutils import (

58

59

    file_kind,

567

568

            return _mod_revision.NULL_REVISION

568

569

 

569

570

    def lock_read(self):

570

 

        """See Branch.lock_read, and WorkingTree.unlock.

571

 

 

572

 

        :return: An object with an unlock method which will release the lock

573

 

            obtained.

574

 

        """

 

571

        """See Branch.lock_read, and WorkingTree.unlock."""

575

572

        self.branch.lock_read()

576

573

        try:

577

574

            self._control_files.lock_read()

590

587

        except:

591

588

            self.branch.unlock()

592

589

            raise

593

 

        return self

594

590

 

595

591

    def _lock_self_write(self):

596

592

        """This should be called after the branch is locked."""

611

607

        except:

612

608

            self.branch.unlock()

613

609

            raise

614

 

        return self

615

610

 

616

611

    def lock_tree_write(self):

617

 

        """See MutableTree.lock_tree_write, and WorkingTree.unlock.

618

 

 

619

 

        :return: An object with an unlock method which will release the lock

620

 

            obtained.

621

 

        """

 

612

        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""

622

613

        self.branch.lock_read()

623

 

        return self._lock_self_write()

 

614

        self._lock_self_write()

624

615

 

625

616

    def lock_write(self):

626

 

        """See MutableTree.lock_write, and WorkingTree.unlock.

627

 

 

628

 

        :return: An object with an unlock method which will release the lock

629

 

            obtained.

630

 

        """

 

617

        """See MutableTree.lock_write, and WorkingTree.unlock."""

631

618

        self.branch.lock_write()

632

 

        return self._lock_self_write()

 

619

        self._lock_self_write()

633

620

 

634

621

    @needs_tree_write_lock

635

622

    def move(self, from_paths, to_dir, after=False):

1385

1372

 

1386

1373

 

1387

1374

class DirStateWorkingTreeFormat(WorkingTreeFormat3):

1388

 

 

1389

1375

    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,

1390

1376

                   accelerator_tree=None, hardlink=False):

1391

1377

        """See WorkingTreeFormat.initialize().

1461

1447

                if basis_root_id is not None:

1462

1448

                    wt._set_root_id(basis_root_id)

1463

1449

                    wt.flush()

 

1450

                # If content filtering is supported, do not use the accelerator

 

1451

                # tree - the cost of transforming the content both ways and

 

1452

                # checking for changed content can outweight the gains it gives.

 

1453

                # Note: do NOT move this logic up higher - using the basis from

 

1454

                # the accelerator tree is still desirable because that can save

 

1455

                # a minute or more of processing on large trees!

 

1456

                # The original tree may not have the same content filters

 

1457

                # applied so we can't safely build the inventory delta from

 

1458

                # the source tree.

1464

1459

                if wt.supports_content_filtering():

1465

 

                    # The original tree may not have the same content filters

1466

 

                    # applied so we can't safely build the inventory delta from

1467

 

                    # the source tree.

 

1460

                    if hardlink:

 

1461

                        # see https://bugs.edge.launchpad.net/bzr/+bug/408193

 

1462

                        trace.warning("hardlinking working copy files is not currently "

 

1463

                            "supported in %r" % (wt,))

 

1464

                    accelerator_tree = None

1468

1465

                    delta_from_tree = False

1469

1466

                else:

1470

1467

                    delta_from_tree = True

1769

1766

            return None

1770

1767

        parent_index = self._get_parent_index()

1771

1768

        last_changed_revision = entry[1][parent_index][4]

1772

 

        try:

1773

 

            rev = self._repository.get_revision(last_changed_revision)

1774

 

        except errors.NoSuchRevision:

1775

 

            raise errors.FileTimestampUnavailable(self.id2path(file_id))

1776

 

        return rev.timestamp

 

1769

        return self._repository.get_revision(last_changed_revision).timestamp

1777

1770

 

1778

1771

    def get_file_sha1(self, file_id, path=None, stat_value=None):

1779

1772

        entry = self._get_entry(file_id=file_id, path=path)

1846

1839

        entry = self._get_entry(file_id=file_id)[1]

1847

1840

        if entry is None:

1848

1841

            raise errors.NoSuchId(tree=self, file_id=file_id)

1849

 

        parent_index = self._get_parent_index()

1850

 

        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]

 

1842

        return dirstate.DirState._minikind_to_kind[entry[1][0]]

1851

1843

 

1852

1844

    def stored_kind(self, file_id):

1853

1845

        """See Tree.stored_kind"""

1873

1865

            return None

1874

1866

        return ie.executable

1875

1867

 

1876

 

    def is_locked(self):

1877

 

        return self._locked

1878

 

 

1879

1868

    def list_files(self, include_root=False, from_dir=None, recursive=True):

1880

1869

        # We use a standard implementation, because DirStateRevisionTree is

1881

1870

        # dealing with one of the parents of the current state

1894

1883

            yield path, 'V', entry.kind, entry.file_id, entry

1895

1884

 

1896

1885

    def lock_read(self):

1897

 

        """Lock the tree for a set of operations.

1898

 

 

1899

 

        :return: An object with an unlock method which will release the lock

1900

 

            obtained.

1901

 

        """

 

1886

        """Lock the tree for a set of operations."""

1902

1887

        if not self._locked:

1903

1888

            self._repository.lock_read()

1904

1889

            if self._dirstate._lock_token is None:

1905

1890

                self._dirstate.lock_read()

1906

1891

                self._dirstate_locked = True

1907

1892

        self._locked += 1

1908

 

        return self

1909

1893

 

1910

1894

    def _must_be_locked(self):

1911

1895

        if not self._locked:

2001

1985

        return result

2002

1986

 

2003

1987

    @classmethod

2004

 

    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,

2005

 

                                                  target):

 

1988

    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):

2006

1989

        from bzrlib.tests.test__dirstate_helpers import \

2007

 

            compiled_dirstate_helpers_feature

2008

 

        test_case.requireFeature(compiled_dirstate_helpers_feature)

 

1990

            CompiledDirstateHelpersFeature

 

1991

        if not CompiledDirstateHelpersFeature.available():

 

1992

            from bzrlib.tests import UnavailableFeature

 

1993

            raise UnavailableFeature(CompiledDirstateHelpersFeature)

2009

1994

        from bzrlib._dirstate_helpers_pyx import ProcessEntryC

2010

1995

        result = klass.make_source_parent_tree(source, target)

2011

1996

        result[1]._iter_changes = ProcessEntryC

2042

2027

            output. An unversioned file is defined as one with (False, False)

2043

2028

            for the versioned pair.

2044

2029

        """

 

2030

        # NB: show_status depends on being able to pass in non-versioned files

 

2031

        # and report them as unknown

2045

2032

        # TODO: handle extra trees in the dirstate.

2046

2033

        if (extra_trees or specific_files == []):

2047

2034

            # we can't fast-path these cases (yet)

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0