← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/decorators.py

Merge up through 2.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/decorators.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
24
24
 
25
25
import sys
26
26
 
 
27
from bzrlib import trace
 
28
 
27
29
 
28
30
def _get_parameters(func):
29
31
    """Recreate the parameters for a function using introspection.
204
206
    return write_locked
205
207
 
206
208
 
 
209
def only_raises(*errors):
 
210
    """Make a decorator that will only allow the given error classes to be
 
211
    raised.  All other errors will be logged and then discarded.
 
212
 
 
213
    Typical use is something like::
 
214
 
 
215
        @only_raises(LockNotHeld, LockBroken)
 
216
        def unlock(self):
 
217
            # etc
 
218
    """
 
219
    def decorator(unbound):
 
220
        def wrapped(*args, **kwargs):
 
221
            try:
 
222
                return unbound(*args, **kwargs)
 
223
            except errors:
 
224
                raise
 
225
            except:
 
226
                trace.mutter('Error suppressed by only_raises:')
 
227
                trace.log_exception_quietly()
 
228
        wrapped.__doc__ = unbound.__doc__
 
229
        wrapped.__name__ = unbound.__name__
 
230
        return wrapped
 
231
    return decorator
 
232
 
 
233
 
207
234
# Default is more functionality, 'bzr' the commandline will request fast
208
235
# versions.
209
236
needs_read_lock = _pretty_needs_read_lock
226
253
    global needs_read_lock, needs_write_lock
227
254
    needs_read_lock = _pretty_needs_read_lock
228
255
    needs_write_lock = _pretty_needs_write_lock
 
256
 
 
257
 
 
258
# This implementation of cachedproperty is copied from Launchpad's
 
259
# canonical.launchpad.cachedproperty module (with permission from flacoste)
 
260
# -- spiv & vila 100120
 
261
def cachedproperty(attrname_or_fn):
 
262
    """A decorator for methods that makes them properties with their return
 
263
    value cached.
 
264
 
 
265
    The value is cached on the instance, using the attribute name provided.
 
266
 
 
267
    If you don't provide a name, the mangled name of the property is used.
 
268
 
 
269
    >>> class CachedPropertyTest(object):
 
270
    ...
 
271
    ...     @cachedproperty('_foo_cache')
 
272
    ...     def foo(self):
 
273
    ...         print 'foo computed'
 
274
    ...         return 23
 
275
    ...
 
276
    ...     @cachedproperty
 
277
    ...     def bar(self):
 
278
    ...         print 'bar computed'
 
279
    ...         return 69
 
280
 
 
281
    >>> cpt = CachedPropertyTest()
 
282
    >>> getattr(cpt, '_foo_cache', None) is None
 
283
    True
 
284
    >>> cpt.foo
 
285
    foo computed
 
286
    23
 
287
    >>> cpt.foo
 
288
    23
 
289
    >>> cpt._foo_cache
 
290
    23
 
291
    >>> cpt.bar
 
292
    bar computed
 
293
    69
 
294
    >>> cpt._bar_cached_value
 
295
    69
 
296
 
 
297
    """
 
298
    if isinstance(attrname_or_fn, basestring):
 
299
        attrname = attrname_or_fn
 
300
        return _CachedPropertyForAttr(attrname)
 
301
    else:
 
302
        fn = attrname_or_fn
 
303
        attrname = '_%s_cached_value' % fn.__name__
 
304
        return _CachedProperty(attrname, fn)
 
305
 
 
306
 
 
307
class _CachedPropertyForAttr(object):
 
308
 
 
309
    def __init__(self, attrname):
 
310
        self.attrname = attrname
 
311
 
 
312
    def __call__(self, fn):
 
313
        return _CachedProperty(self.attrname, fn)
 
314
 
 
315
 
 
316
class _CachedProperty(object):
 
317
 
 
318
    def __init__(self, attrname, fn):
 
319
        self.fn = fn
 
320
        self.attrname = attrname
 
321
        self.marker = object()
 
322
 
 
323
    def __get__(self, inst, cls=None):
 
324
        if inst is None:
 
325
            return self
 
326
        cachedresult = getattr(inst, self.attrname, self.marker)
 
327
        if cachedresult is self.marker:
 
328
            result = self.fn(inst)
 
329
            setattr(inst, self.attrname, result)
 
330
            return result
 
331
        else:
 
332
            return cachedresult