/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/inter.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/inter.py
16
16
 
17
17
"""Inter-object utility class."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
from .errors import BzrError
20
 
from .lock import LogicalLockResult
21
 
from .pyutils import get_named_object
22
22
 
23
23
 
24
24
class NoCompatibleInter(BzrError):
45
45
 
46
46
    If the source and target objects implement the locking protocol -
47
47
    lock_read, lock_write, unlock, then the InterObject's lock_read,
48
 
    lock_write and unlock methods may be used.
 
48
    lock_write and unlock methods may be used (optionally in conjunction with
 
49
    the needs_read_lock and needs_write_lock decorators.)
49
50
 
50
51
    When looking for an inter, the most recently registered types are tested
51
52
    first.  So typically the most generic and slowest InterObjects should be
91
92
        If an optimised worker exists it will be used otherwise
92
93
        a default Inter worker instance will be created.
93
94
        """
94
 
        for i, provider in enumerate(reversed(klass._optimisers)):
95
 
            if isinstance(provider, tuple):
96
 
                provider = get_named_object(provider[0], provider[1])
97
 
                klass._optimisers[-i] = provider
 
95
        for provider in reversed(klass._optimisers):
98
96
            if provider.is_compatible(source, target):
99
97
                return provider(source, target)
100
98
        raise NoCompatibleInter(source, target)
101
99
 
102
 
    @classmethod
103
 
    def iter_optimisers(klass):
104
 
        for provider in klass._optimisers:
105
 
            if isinstance(provider, tuple):
106
 
                yield get_named_object(provider[0], provider[1])
107
 
            else:
108
 
                yield provider
109
 
 
110
100
    def lock_read(self):
111
101
        """Take out a logical read lock.
112
102
 
114
104
        a read lock and the target a read lock.
115
105
        """
116
106
        self._double_lock(self.source.lock_read, self.target.lock_read)
117
 
        return LogicalLockResult(self.unlock)
118
107
 
119
108
    def lock_write(self):
120
109
        """Take out a logical write lock.
123
112
        a read lock and the target a write lock.
124
113
        """
125
114
        self._double_lock(self.source.lock_read, self.target.lock_write)
126
 
        return LogicalLockResult(self.unlock)
127
115
 
128
116
    @classmethod
129
117
    def register_optimiser(klass, optimiser):
130
118
        """Register an InterObject optimiser."""
131
119
        klass._optimisers.append(optimiser)
132
120
 
133
 
    @classmethod
134
 
    def register_lazy_optimiser(klass, module_name, member_name):
135
 
        # TODO(jelmer): Allow passing in a custom .is_compatible
136
 
        klass._optimisers.append((module_name, member_name))
137
 
 
138
121
    def unlock(self):
139
122
        """Release the locks on source and target."""
140
123
        try: