/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: Andrew Bennetts
  • Date: 2011-06-09 07:38:32 UTC
  • mto: This revision was merged to the branch mainline in revision 5964.
  • Revision ID: andrew.bennetts@canonical.com-20110609073832-dt6oww033iexli4l
Fix thinko in wording regarding stacking invariants and revisions with multiple parents.

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
 
 
20
from bzrlib.pyutils import get_named_object
20
21
 
21
22
 
22
23
class _ObjectGetter(object):
100
101
        self._default_key = None
101
102
        # Map from key => (is_lazy, info)
102
103
        self._dict = {}
103
 
        self._aliases = {}
104
104
        self._help_dict = {}
105
105
        self._info_dict = {}
106
106
 
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
107
    def register(self, key, obj, help=None, info=None,
118
108
                 override_existing=False):
119
109
        """Register a new object to a name.
161
151
        self._dict[key] = _LazyObjectGetter(module_name, member_name)
162
152
        self._add_help_and_info(key, help=help, info=info)
163
153
 
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
154
    def _add_help_and_info(self, key, help=None, info=None):
179
155
        """Add the help and information about this key"""
180
156
        self._help_dict[key] = help
250
226
 
251
227
    def keys(self):
252
228
        """Get a list of registered entries"""
253
 
        return sorted(self._dict)
 
229
        return sorted(self._dict.keys())
254
230
 
255
231
    def iteritems(self):
256
 
        for key in self._dict:
257
 
            yield key, self._dict[key].get_obj()
 
232
        for key, getter in self._dict.iteritems():
 
233
            yield key, getter.get_obj()
258
234
 
259
235
    def items(self):
260
236
        # We should not use the iteritems() implementation below (see bug
261
237
        # #430510)
262
 
        return [(key, self._dict[key].get_obj()) for key in self.keys()]
 
238
        return sorted([(key, getter.get_obj())
 
239
                       for key, getter in self._dict.items()])
263
240
 
264
241
    def _set_default_key(self, key):
265
 
        if key not in self._dict:
 
242
        if not self._dict.has_key(key):
266
243
            raise KeyError('No object registered under key %s.' % key)
267
244
        else:
268
245
            self._default_key = key
271
248
        return self._default_key
272
249
 
273
250
    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.")
 
251
                            doc="Current value of the default key."
 
252
                                " Can be set to any existing key.")
276
253
 
277
254
 
278
255
class FormatRegistry(Registry):
285
262
    def register(self, key, obj, help=None, info=None,
286
263
                 override_existing=False):
287
264
        Registry.register(self, key, obj, help=help, info=info,
288
 
                          override_existing=override_existing)
 
265
            override_existing=override_existing)
289
266
        if self._other_registry is not None:
290
267
            self._other_registry.register(key, obj, help=help,
291
 
                                          info=info, override_existing=override_existing)
 
268
                info=info, override_existing=override_existing)
292
269
 
293
270
    def register_lazy(self, key, module_name, member_name,
294
271
                      help=None, info=None,
296
273
        # Overridden to allow capturing registrations to two seperate
297
274
        # registries in a single call.
298
275
        Registry.register_lazy(self, key, module_name, member_name,
299
 
                               help=help, info=info, override_existing=override_existing)
 
276
                help=help, info=info, override_existing=override_existing)
300
277
        if self._other_registry is not None:
301
278
            self._other_registry.register_lazy(key, module_name, member_name,
302
 
                                               help=help, info=info, override_existing=override_existing)
 
279
                help=help, info=info, override_existing=override_existing)
303
280
 
304
281
    def remove(self, key):
305
282
        Registry.remove(self, key)