/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 bzrlib/registry.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/registry.py
16
16
 
17
17
"""Classes to provide name-to-object registry-like support."""
18
18
 
19
 
from .pyutils import get_named_object
 
19
from __future__ import absolute_import
 
20
 
 
21
from bzrlib.pyutils import get_named_object
20
22
 
21
23
 
22
24
class _ObjectGetter(object):
100
102
        self._default_key = None
101
103
        # Map from key => (is_lazy, info)
102
104
        self._dict = {}
103
 
        self._aliases = {}
104
105
        self._help_dict = {}
105
106
        self._info_dict = {}
106
107
 
107
 
    def aliases(self):
108
 
        """Return a set of the format names which are aliases."""
109
 
        return dict(self._aliases.items())
110
 
 
111
 
    def alias_map(self):
112
 
        ret = {}
113
 
        for alias, target in self._aliases.items():
114
 
            ret.setdefault(target, []).append(alias)
115
 
        return ret
116
 
 
117
108
    def register(self, key, obj, help=None, info=None,
118
109
                 override_existing=False):
119
110
        """Register a new object to a name.
161
152
        self._dict[key] = _LazyObjectGetter(module_name, member_name)
162
153
        self._add_help_and_info(key, help=help, info=info)
163
154
 
164
 
    def register_alias(self, key, target, info=None):
165
 
        """Register an alias.
166
 
 
167
 
        :param key: Alias name
168
 
        :param target: Target key name
169
 
        """
170
 
        if key in self._dict and key not in self._aliases:
171
 
            raise KeyError('Key %r already registered and not an alias' % key)
172
 
        self._dict[key] = self._dict[target]
173
 
        self._aliases[key] = target
174
 
        if info is None:
175
 
            info = self._info_dict[target]
176
 
        self._add_help_and_info(key, help=self._help_dict[target], info=info)
177
 
 
178
155
    def _add_help_and_info(self, key, help=None, info=None):
179
156
        """Add the help and information about this key"""
180
157
        self._help_dict[key] = help
250
227
 
251
228
    def keys(self):
252
229
        """Get a list of registered entries"""
253
 
        return sorted(self._dict)
 
230
        return sorted(self._dict.keys())
254
231
 
255
232
    def iteritems(self):
256
 
        for key in self._dict:
257
 
            yield key, self._dict[key].get_obj()
 
233
        for key, getter in self._dict.iteritems():
 
234
            yield key, getter.get_obj()
258
235
 
259
236
    def items(self):
260
237
        # We should not use the iteritems() implementation below (see bug
261
238
        # #430510)
262
 
        return [(key, self._dict[key].get_obj()) for key in self.keys()]
 
239
        return sorted([(key, getter.get_obj())
 
240
                       for key, getter in self._dict.items()])
263
241
 
264
242
    def _set_default_key(self, key):
265
 
        if key not in self._dict:
 
243
        if not self._dict.has_key(key):
266
244
            raise KeyError('No object registered under key %s.' % key)
267
245
        else:
268
246
            self._default_key = key
271
249
        return self._default_key
272
250
 
273
251
    default_key = property(_get_default_key, _set_default_key,
274
 
                           doc="Current value of the default key."
275
 
                           " Can be set to any existing key.")
 
252
                            doc="Current value of the default key."
 
253
                                " Can be set to any existing key.")
276
254
 
277
255
 
278
256
class FormatRegistry(Registry):
285
263
    def register(self, key, obj, help=None, info=None,
286
264
                 override_existing=False):
287
265
        Registry.register(self, key, obj, help=help, info=info,
288
 
                          override_existing=override_existing)
 
266
            override_existing=override_existing)
289
267
        if self._other_registry is not None:
290
268
            self._other_registry.register(key, obj, help=help,
291
 
                                          info=info, override_existing=override_existing)
 
269
                info=info, override_existing=override_existing)
292
270
 
293
271
    def register_lazy(self, key, module_name, member_name,
294
272
                      help=None, info=None,
296
274
        # Overridden to allow capturing registrations to two seperate
297
275
        # registries in a single call.
298
276
        Registry.register_lazy(self, key, module_name, member_name,
299
 
                               help=help, info=info, override_existing=override_existing)
 
277
                help=help, info=info, override_existing=override_existing)
300
278
        if self._other_registry is not None:
301
279
            self._other_registry.register_lazy(key, module_name, member_name,
302
 
                                               help=help, info=info, override_existing=override_existing)
 
280
                help=help, info=info, override_existing=override_existing)
303
281
 
304
282
    def remove(self, key):
305
283
        Registry.remove(self, key)