home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / bsddb / __init__.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  10.1 KB  |  294 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Support for BerkeleyDB 3.2 through 4.2.
  5. '''
  6.  
  7. try:
  8.     if __name__ == 'bsddb3':
  9.         import _pybsddb
  10.         _bsddb = _pybsddb
  11.     else:
  12.         import _bsddb
  13. except ImportError:
  14.     import sys
  15.     del sys.modules[__name__]
  16.     raise 
  17.  
  18. db = _db = _bsddb
  19. __version__ = db.__version__
  20. error = db.DBError
  21. import sys
  22. import os
  23. if sys.version >= '2.3':
  24.     import UserDict
  25.     from weakref import ref
  26.     exec "\nclass _iter_mixin(UserDict.DictMixin):\n    def _make_iter_cursor(self):\n        cur = self.db.cursor()\n        key = id(cur)\n        self._cursor_refs[key] = ref(cur, self._gen_cref_cleaner(key))\n        return cur\n\n    def _gen_cref_cleaner(self, key):\n        # use generate the function for the weakref callback here\n        # to ensure that we do not hold a strict reference to cur\n        # in the callback.\n        return lambda ref: self._cursor_refs.pop(key, None)\n\n    def __iter__(self):\n        try:\n            cur = self._make_iter_cursor()\n\n            # FIXME-20031102-greg: race condition.  cursor could\n            # be closed by another thread before this call.\n\n            # since we're only returning keys, we call the cursor\n            # methods with flags=0, dlen=0, dofs=0\n            key = cur.first(0,0,0)[0]\n            yield key\n\n            next = cur.next\n            while 1:\n                try:\n                    key = next(0,0,0)[0]\n                    yield key\n                except _bsddb.DBCursorClosedError:\n                    cur = self._make_iter_cursor()\n                    # FIXME-20031101-greg: race condition.  cursor could\n                    # be closed by another thread before this call.\n                    cur.set(key,0,0,0)\n                    next = cur.next\n        except _bsddb.DBNotFoundError:\n            return\n        except _bsddb.DBCursorClosedError:\n            # the database was modified during iteration.  abort.\n            return\n\n    def iteritems(self):\n        try:\n            try:\n                cur = self._make_iter_cursor()\n            except AttributeError:\n                return\n\n            # FIXME-20031102-greg: race condition.  cursor could\n            # be closed by another thread before this call.\n\n            kv = cur.first()\n            key = kv[0]\n            yield kv\n\n            next = cur.next\n            while 1:\n                try:\n                    kv = next()\n                    key = kv[0]\n                    yield kv\n                except _bsddb.DBCursorClosedError:\n                    cur = self._make_iter_cursor()\n                    # FIXME-20031101-greg: race condition.  cursor could\n                    # be closed by another thread before this call.\n                    cur.set(key,0,0,0)\n                    next = cur.next\n        except _bsddb.DBNotFoundError:\n            return\n        except _bsddb.DBCursorClosedError:\n            # the database was modified during iteration.  abort.\n            return\n"
  27. else:
  28.     
  29.     class _iter_mixin:
  30.         pass
  31.  
  32.  
  33. class _DBWithCursor(_iter_mixin):
  34.     '''
  35.     A simple wrapper around DB that makes it look like the bsddbobject in
  36.     the old module.  It uses a cursor as needed to provide DB traversal.
  37.     '''
  38.     
  39.     def __init__(self, db):
  40.         self.db = db
  41.         self.db.set_get_returns_none(0)
  42.         self.dbc = None
  43.         self.saved_dbc_key = None
  44.         self._cursor_refs = { }
  45.  
  46.     
  47.     def __del__(self):
  48.         self.close()
  49.  
  50.     
  51.     def _checkCursor(self):
  52.         if self.dbc is None:
  53.             self.dbc = self.db.cursor()
  54.             if self.saved_dbc_key is not None:
  55.                 self.dbc.set(self.saved_dbc_key)
  56.                 self.saved_dbc_key = None
  57.             
  58.         
  59.  
  60.     
  61.     def _closeCursors(self, save = 1):
  62.         if self.dbc:
  63.             c = self.dbc
  64.             self.dbc = None
  65.             if save:
  66.                 
  67.                 try:
  68.                     self.saved_dbc_key = c.current(0, 0, 0)[0]
  69.                 except db.DBError:
  70.                     pass
  71.                 except:
  72.                     None<EXCEPTION MATCH>db.DBError
  73.                 
  74.  
  75.             None<EXCEPTION MATCH>db.DBError
  76.             c.close()
  77.             del c
  78.         
  79.         for cref in self._cursor_refs.values():
  80.             c = cref()
  81.             if c is not None:
  82.                 c.close()
  83.                 continue
  84.         
  85.  
  86.     
  87.     def _checkOpen(self):
  88.         if self.db is None:
  89.             raise error, 'BSDDB object has already been closed'
  90.         
  91.  
  92.     
  93.     def isOpen(self):
  94.         return self.db is not None
  95.  
  96.     
  97.     def __len__(self):
  98.         self._checkOpen()
  99.         return len(self.db)
  100.  
  101.     
  102.     def __getitem__(self, key):
  103.         self._checkOpen()
  104.         return self.db[key]
  105.  
  106.     
  107.     def __setitem__(self, key, value):
  108.         self._checkOpen()
  109.         self._closeCursors()
  110.         self.db[key] = value
  111.  
  112.     
  113.     def __delitem__(self, key):
  114.         self._checkOpen()
  115.         self._closeCursors()
  116.         del self.db[key]
  117.  
  118.     
  119.     def close(self):
  120.         self._closeCursors(save = 0)
  121.         if self.dbc is not None:
  122.             self.dbc.close()
  123.         
  124.         v = 0
  125.         if self.db is not None:
  126.             v = self.db.close()
  127.         
  128.         self.dbc = None
  129.         self.db = None
  130.         return v
  131.  
  132.     
  133.     def keys(self):
  134.         self._checkOpen()
  135.         return self.db.keys()
  136.  
  137.     
  138.     def has_key(self, key):
  139.         self._checkOpen()
  140.         return self.db.has_key(key)
  141.  
  142.     
  143.     def set_location(self, key):
  144.         self._checkOpen()
  145.         self._checkCursor()
  146.         return self.dbc.set_range(key)
  147.  
  148.     
  149.     def next(self):
  150.         self._checkOpen()
  151.         self._checkCursor()
  152.         rv = self.dbc.next()
  153.         return rv
  154.  
  155.     
  156.     def previous(self):
  157.         self._checkOpen()
  158.         self._checkCursor()
  159.         rv = self.dbc.prev()
  160.         return rv
  161.  
  162.     
  163.     def first(self):
  164.         self._checkOpen()
  165.         self._checkCursor()
  166.         rv = self.dbc.first()
  167.         return rv
  168.  
  169.     
  170.     def last(self):
  171.         self._checkOpen()
  172.         self._checkCursor()
  173.         rv = self.dbc.last()
  174.         return rv
  175.  
  176.     
  177.     def sync(self):
  178.         self._checkOpen()
  179.         return self.db.sync()
  180.  
  181.  
  182.  
  183. def hashopen(file, flag = 'c', mode = 438, pgsize = None, ffactor = None, nelem = None, cachesize = None, lorder = None, hflags = 0):
  184.     flags = _checkflag(flag, file)
  185.     e = _openDBEnv()
  186.     d = db.DB(e)
  187.     d.set_flags(hflags)
  188.     if cachesize is not None:
  189.         d.set_cachesize(0, cachesize)
  190.     
  191.     if pgsize is not None:
  192.         d.set_pagesize(pgsize)
  193.     
  194.     if lorder is not None:
  195.         d.set_lorder(lorder)
  196.     
  197.     if ffactor is not None:
  198.         d.set_h_ffactor(ffactor)
  199.     
  200.     if nelem is not None:
  201.         d.set_h_nelem(nelem)
  202.     
  203.     d.open(file, db.DB_HASH, flags, mode)
  204.     return _DBWithCursor(d)
  205.  
  206.  
  207. def btopen(file, flag = 'c', mode = 438, btflags = 0, cachesize = None, maxkeypage = None, minkeypage = None, pgsize = None, lorder = None):
  208.     flags = _checkflag(flag, file)
  209.     e = _openDBEnv()
  210.     d = db.DB(e)
  211.     if cachesize is not None:
  212.         d.set_cachesize(0, cachesize)
  213.     
  214.     if pgsize is not None:
  215.         d.set_pagesize(pgsize)
  216.     
  217.     if lorder is not None:
  218.         d.set_lorder(lorder)
  219.     
  220.     d.set_flags(btflags)
  221.     if minkeypage is not None:
  222.         d.set_bt_minkey(minkeypage)
  223.     
  224.     if maxkeypage is not None:
  225.         d.set_bt_maxkey(maxkeypage)
  226.     
  227.     d.open(file, db.DB_BTREE, flags, mode)
  228.     return _DBWithCursor(d)
  229.  
  230.  
  231. def rnopen(file, flag = 'c', mode = 438, rnflags = 0, cachesize = None, pgsize = None, lorder = None, rlen = None, delim = None, source = None, pad = None):
  232.     flags = _checkflag(flag, file)
  233.     e = _openDBEnv()
  234.     d = db.DB(e)
  235.     if cachesize is not None:
  236.         d.set_cachesize(0, cachesize)
  237.     
  238.     if pgsize is not None:
  239.         d.set_pagesize(pgsize)
  240.     
  241.     if lorder is not None:
  242.         d.set_lorder(lorder)
  243.     
  244.     d.set_flags(rnflags)
  245.     if delim is not None:
  246.         d.set_re_delim(delim)
  247.     
  248.     if rlen is not None:
  249.         d.set_re_len(rlen)
  250.     
  251.     if source is not None:
  252.         d.set_re_source(source)
  253.     
  254.     if pad is not None:
  255.         d.set_re_pad(pad)
  256.     
  257.     d.open(file, db.DB_RECNO, flags, mode)
  258.     return _DBWithCursor(d)
  259.  
  260.  
  261. def _openDBEnv():
  262.     e = db.DBEnv()
  263.     e.open('.', db.DB_PRIVATE | db.DB_CREATE | db.DB_THREAD | db.DB_INIT_LOCK | db.DB_INIT_MPOOL)
  264.     return e
  265.  
  266.  
  267. def _checkflag(flag, file):
  268.     if flag == 'r':
  269.         flags = db.DB_RDONLY
  270.     elif flag == 'rw':
  271.         flags = 0
  272.     elif flag == 'w':
  273.         flags = db.DB_CREATE
  274.     elif flag == 'c':
  275.         flags = db.DB_CREATE
  276.     elif flag == 'n':
  277.         flags = db.DB_CREATE
  278.         if os.path.isfile(file):
  279.             os.unlink(file)
  280.         
  281.     else:
  282.         raise error, "flags should be one of 'r', 'w', 'c' or 'n'"
  283.     return flags | db.DB_THREAD
  284.  
  285.  
  286. try:
  287.     import thread
  288.     del thread
  289.     if db.version() < (3, 3, 0):
  290.         db.DB_THREAD = 0
  291. except ImportError:
  292.     db.DB_THREAD = 0
  293.  
  294.