home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_649 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  7.5 KB  |  236 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import ctypes
  6. import weakref
  7. from multiprocessing import heap, RLock
  8. from multiprocessing.forking import assert_spawning, ForkingPickler
  9. __all__ = [
  10.     'RawValue',
  11.     'RawArray',
  12.     'Value',
  13.     'Array',
  14.     'copy',
  15.     'synchronized']
  16. typecode_to_type = {
  17.     'c': ctypes.c_char,
  18.     'u': ctypes.c_wchar,
  19.     'b': ctypes.c_byte,
  20.     'B': ctypes.c_ubyte,
  21.     'h': ctypes.c_short,
  22.     'H': ctypes.c_ushort,
  23.     'i': ctypes.c_int,
  24.     'I': ctypes.c_uint,
  25.     'l': ctypes.c_long,
  26.     'L': ctypes.c_ulong,
  27.     'f': ctypes.c_float,
  28.     'd': ctypes.c_double }
  29.  
  30. def _new_value(type_):
  31.     size = ctypes.sizeof(type_)
  32.     wrapper = heap.BufferWrapper(size)
  33.     return rebuild_ctype(type_, wrapper, None)
  34.  
  35.  
  36. def RawValue(typecode_or_type, *args):
  37.     type_ = typecode_to_type.get(typecode_or_type, typecode_or_type)
  38.     obj = _new_value(type_)
  39.     ctypes.memset(ctypes.addressof(obj), 0, ctypes.sizeof(obj))
  40.     obj.__init__(*args)
  41.     return obj
  42.  
  43.  
  44. def RawArray(typecode_or_type, size_or_initializer):
  45.     type_ = typecode_to_type.get(typecode_or_type, typecode_or_type)
  46.     if isinstance(size_or_initializer, int):
  47.         type_ = type_ * size_or_initializer
  48.         return _new_value(type_)
  49.     type_ = type_ * len(size_or_initializer)
  50.     result = _new_value(type_)
  51.     result.__init__(*size_or_initializer)
  52.     return result
  53.  
  54.  
  55. def Value(typecode_or_type, *args, **kwds):
  56.     lock = kwds.pop('lock', None)
  57.     if kwds:
  58.         raise ValueError('unrecognized keyword argument(s): %s' % kwds.keys())
  59.     kwds
  60.     obj = RawValue(typecode_or_type, *args)
  61.     if lock is False:
  62.         return obj
  63.     if lock in (True, None):
  64.         lock = RLock()
  65.     
  66.     if not hasattr(lock, 'acquire'):
  67.         raise AttributeError("'%r' has no method 'acquire'" % lock)
  68.     hasattr(lock, 'acquire')
  69.     return synchronized(obj, lock)
  70.  
  71.  
  72. def Array(typecode_or_type, size_or_initializer, **kwds):
  73.     lock = kwds.pop('lock', None)
  74.     if kwds:
  75.         raise ValueError('unrecognized keyword argument(s): %s' % kwds.keys())
  76.     kwds
  77.     obj = RawArray(typecode_or_type, size_or_initializer)
  78.     if lock is False:
  79.         return obj
  80.     if lock in (True, None):
  81.         lock = RLock()
  82.     
  83.     if not hasattr(lock, 'acquire'):
  84.         raise AttributeError("'%r' has no method 'acquire'" % lock)
  85.     hasattr(lock, 'acquire')
  86.     return synchronized(obj, lock)
  87.  
  88.  
  89. def copy(obj):
  90.     new_obj = _new_value(type(obj))
  91.     ctypes.pointer(new_obj)[0] = obj
  92.     return new_obj
  93.  
  94.  
  95. def synchronized(obj, lock = None):
  96.     if isinstance(obj, ctypes._SimpleCData):
  97.         return Synchronized(obj, lock)
  98.     if isinstance(obj, ctypes.Array):
  99.         if obj._type_ is ctypes.c_char:
  100.             return SynchronizedString(obj, lock)
  101.         return SynchronizedArray(obj, lock)
  102.     cls = type(obj)
  103.     
  104.     try:
  105.         scls = class_cache[cls]
  106.     except KeyError:
  107.         isinstance(obj, ctypes.Array)
  108.         isinstance(obj, ctypes.Array)
  109.         isinstance(obj, ctypes._SimpleCData)
  110.         names = [ field[0] for field in cls._fields_ ]
  111.         d = dict((lambda .0: for name in .0:
  112. (name, make_property(name)))(names))
  113.         classname = 'Synchronized' + cls.__name__
  114.     except:
  115.         scls = class_cache[cls] = type(classname, (SynchronizedBase,), d)
  116.  
  117.     return scls(obj, lock)
  118.  
  119.  
  120. def reduce_ctype(obj):
  121.     assert_spawning(obj)
  122.     if isinstance(obj, ctypes.Array):
  123.         return (rebuild_ctype, (obj._type_, obj._wrapper, obj._length_))
  124.     return (rebuild_ctype, (type(obj), obj._wrapper, None))
  125.  
  126.  
  127. def rebuild_ctype(type_, wrapper, length):
  128.     if length is not None:
  129.         type_ = type_ * length
  130.     
  131.     ForkingPickler.register(type_, reduce_ctype)
  132.     obj = type_.from_address(wrapper.get_address())
  133.     obj._wrapper = wrapper
  134.     return obj
  135.  
  136.  
  137. def make_property(name):
  138.     
  139.     try:
  140.         return prop_cache[name]
  141.     except KeyError:
  142.         d = { }
  143.         exec template % (name,) * 7 in d
  144.         prop_cache[name] = d[name]
  145.         return d[name]
  146.  
  147.  
  148. template = '\ndef get%s(self):\n    self.acquire()\n    try:\n        return self._obj.%s\n    finally:\n        self.release()\ndef set%s(self, value):\n    self.acquire()\n    try:\n        self._obj.%s = value\n    finally:\n        self.release()\n%s = property(get%s, set%s)\n'
  149. prop_cache = { }
  150. class_cache = weakref.WeakKeyDictionary()
  151.  
  152. class SynchronizedBase(object):
  153.     
  154.     def __init__(self, obj, lock = None):
  155.         self._obj = obj
  156.         if not lock:
  157.             pass
  158.         self._lock = RLock()
  159.         self.acquire = self._lock.acquire
  160.         self.release = self._lock.release
  161.  
  162.     
  163.     def __reduce__(self):
  164.         assert_spawning(self)
  165.         return (synchronized, (self._obj, self._lock))
  166.  
  167.     
  168.     def get_obj(self):
  169.         return self._obj
  170.  
  171.     
  172.     def get_lock(self):
  173.         return self._lock
  174.  
  175.     
  176.     def __repr__(self):
  177.         return '<%s wrapper for %s>' % (type(self).__name__, self._obj)
  178.  
  179.  
  180.  
  181. class Synchronized(SynchronizedBase):
  182.     value = make_property('value')
  183.  
  184.  
  185. class SynchronizedArray(SynchronizedBase):
  186.     
  187.     def __len__(self):
  188.         return len(self._obj)
  189.  
  190.     
  191.     def __getitem__(self, i):
  192.         self.acquire()
  193.         
  194.         try:
  195.             return self._obj[i]
  196.         finally:
  197.             self.release()
  198.  
  199.  
  200.     
  201.     def __setitem__(self, i, value):
  202.         self.acquire()
  203.         
  204.         try:
  205.             self._obj[i] = value
  206.         finally:
  207.             self.release()
  208.  
  209.  
  210.     
  211.     def __getslice__(self, start, stop):
  212.         self.acquire()
  213.         
  214.         try:
  215.             return self._obj[start:stop]
  216.         finally:
  217.             self.release()
  218.  
  219.  
  220.     
  221.     def __setslice__(self, start, stop, values):
  222.         self.acquire()
  223.         
  224.         try:
  225.             self._obj[start:stop] = values
  226.         finally:
  227.             self.release()
  228.  
  229.  
  230.  
  231.  
  232. class SynchronizedString(SynchronizedArray):
  233.     value = make_property('value')
  234.     raw = make_property('raw')
  235.  
  236.