Copy in 'persistent' from tseaver-python_picklecache-2 branch of ZODB.

persistent/README.txt

+===================
+Persistence support
+===================
+
+(This document is under construction. More basic documentation will eventually
+appear here.)
+
+
+Overriding `__getattr__`, `__getattribute__`, `__setattr__`, and `__delattr__`
+------------------------------------------------------------------------------
+
+Subclasses can override the attribute-management methods.  For the
+`__getattr__` method, the behavior is like that for regular Python
+classes and for earlier versions of ZODB 3.
+
+For `__getattribute__`, __setattr__`, and `__delattr__`, it is necessary
+to call certain methods defined by `persistent.Persistent`.  Detailed
+examples and documentation is provided in the test module,
+`persistent.tests.test_overriding_attrs`.

persistent/__init__.py

+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Provide access to Persistent and PersistentMapping.
+
+$Id$
+"""
+try:
+    from cPersistence import Persistent
+    from cPersistence import GHOST
+    from cPersistence import UPTODATE
+    from cPersistence import CHANGED
+    from cPersistence import STICKY
+    from cPersistence import simple_new
+except ImportError: # XXX need pure-Python fallback
+    _HAVE_CPERSISTECE = False
+    from pyPersistence import Persistent
+    from pyPersistence import GHOST
+    from pyPersistence import UPTODATE
+    from pyPersistence import CHANGED
+    from pyPersistence import STICKY
+else:
+    _HAVE_CPERSISTECE = True
+    import copy_reg
+    copy_reg.constructor(simple_new)
+
+try:
+    from cPickleCache import PickleCache
+except ImportError:
+    from picklecache import PickleCache
+
+if _HAVE_CPERSISTECE:
+    # Make an interface declaration for Persistent, if zope.interface
+    # is available.  XXX that the pyPersistent version already does this?
+    try:
+        from zope.interface import classImplements
+    except ImportError:
+        pass
+    else:
+        from persistent.interfaces import IPersistent
+        classImplements(Persistent, IPersistent)

persistent/cPersistence.h

+/*****************************************************************************
+
+  Copyright (c) 2001, 2002 Zope Foundation and Contributors.
+  All Rights Reserved.
+
+  This software is subject to the provisions of the Zope Public License,
+  Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+  WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+  FOR A PARTICULAR PURPOSE
+
+ ****************************************************************************/
+
+#ifndef CPERSISTENCE_H
+#define CPERSISTENCE_H
+
+#include "Python.h"
+#include "py24compat.h"
+
+#include "ring.h"
+
+#define CACHE_HEAD \
+    PyObject_HEAD \
+    CPersistentRing ring_home; \
+    int non_ghost_count; \
+    PY_LONG_LONG total_estimated_size;
+
+struct ccobject_head_struct;
+
+typedef struct ccobject_head_struct PerCache;    
+
+/* How big is a persistent object?
+
+   12  PyGC_Head is two pointers and an int
+    8  PyObject_HEAD is an int and a pointer
+ 
+   12  jar, oid, cache pointers
+    8  ring struct
+    8  serialno
+    4  state + extra
+    4  size info
+
+  (56) so far
+
+    4  dict ptr
+    4  weaklist ptr
+  -------------------------
+   68  only need 62, but obmalloc rounds up to multiple of eight
+
+  Even a ghost requires 64 bytes.  It's possible to make a persistent
+  instance with slots and no dict, which changes the storage needed.
+
+*/
+
+#define cPersistent_HEAD \
+    PyObject_HEAD \
+    PyObject *jar; \
+    PyObject *oid; \
+    PerCache *cache; \
+    CPersistentRing ring; \
+    char serial[8]; \
+    signed state:8;                              \
+    unsigned estimated_size:24;
+
+/* We recently added estimated_size.  We originally added it as a new
+   unsigned long field after a signed char state field and a
+   3-character reserved field.  This didn't work because there
+   are packages in the wild that have their own copies of cPersistence.h
+   that didn't see the update.  
+
+   To get around this, we used the reserved space by making
+   estimated_size a 24-bit bit field in the space occupied by the old
+   3-character reserved field.  To fit in 24 bits, we made the units
+   of estimated_size 64-character blocks.  This allows is to handle up
+   to a GB.  We should never see that, but to be paranoid, we also
+   truncate sizes greater than 1GB.  We also set the minimum size to
+   64 bytes.
+
+   We use the _estimated_size_in_24_bits and _estimated_size_in_bytes
+   macros both to avoid repetition and to make intent a little clearer.
+*/
+#define _estimated_size_in_24_bits(I) ((I) > 1073741696 ? 16777215 : (I)/64+1)
+#define _estimated_size_in_bytes(I) ((I)*64)
+
+#define cPersistent_GHOST_STATE -1
+#define cPersistent_UPTODATE_STATE 0
+#define cPersistent_CHANGED_STATE 1
+#define cPersistent_STICKY_STATE 2
+
+typedef struct {
+    cPersistent_HEAD
+} cPersistentObject;
+
+typedef void (*percachedelfunc)(PerCache *, PyObject *);
+
+typedef struct {
+    PyTypeObject *pertype;
+    getattrofunc getattro;
+    setattrofunc setattro;
+    int (*changed)(cPersistentObject*);
+    void (*accessed)(cPersistentObject*);
+    void (*ghostify)(cPersistentObject*);
+    int (*setstate)(PyObject*);
+    percachedelfunc percachedel;
+    int (*readCurrent)(cPersistentObject*);
+} cPersistenceCAPIstruct;
+
+#define cPersistenceType cPersistenceCAPI->pertype
+
+#ifndef DONT_USE_CPERSISTENCECAPI
+static cPersistenceCAPIstruct *cPersistenceCAPI;
+#endif
+
+#define cPersistanceModuleName "cPersistence"
+
+#define PER_TypeCheck(O) PyObject_TypeCheck((O), cPersistenceCAPI->pertype)
+
+#define PER_USE_OR_RETURN(O,R) {if((O)->state==cPersistent_GHOST_STATE && cPersistenceCAPI->setstate((PyObject*)(O)) < 0) return (R); else if ((O)->state==cPersistent_UPTODATE_STATE) (O)->state=cPersistent_STICKY_STATE;}
+
+#define PER_CHANGED(O) (cPersistenceCAPI->changed((cPersistentObject*)(O)))
+
+#define PER_READCURRENT(O, E)                                     \
+  if (cPersistenceCAPI->readCurrent((cPersistentObject*)(O)) < 0) { E; }
+
+#define PER_GHOSTIFY(O) (cPersistenceCAPI->ghostify((cPersistentObject*)(O)))
+
+/* If the object is sticky, make it non-sticky, so that it can be ghostified.
+   The value is not meaningful
+ */
+#define PER_ALLOW_DEACTIVATION(O) ((O)->state==cPersistent_STICKY_STATE && ((O)->state=cPersistent_UPTODATE_STATE))
+
+#define PER_PREVENT_DEACTIVATION(O)  ((O)->state==cPersistent_UPTODATE_STATE && ((O)->state=cPersistent_STICKY_STATE))
+
+/* 
+   Make a persistent object usable from C by:
+
+   - Making sure it is not a ghost
+
+   - Making it sticky.
+
+   IMPORTANT: If you call this and don't call PER_ALLOW_DEACTIVATION, 
+              your object will not be ghostified.
+
+   PER_USE returns a 1 on success and 0 failure, where failure means
+   error.
+ */
+#define PER_USE(O) \
+(((O)->state != cPersistent_GHOST_STATE \
+  || (cPersistenceCAPI->setstate((PyObject*)(O)) >= 0)) \
+ ? (((O)->state==cPersistent_UPTODATE_STATE) \
+    ? ((O)->state=cPersistent_STICKY_STATE) : 1) : 0)
+
+#define PER_ACCESSED(O)  (cPersistenceCAPI->accessed((cPersistentObject*)(O)))
+
+#endif

persistent/dict.py

+##############################################################################
+#
+# Copyright Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+
+# persistent.dict is deprecated. User persistent.mapping
+from persistent.mapping import PersistentMapping as PersistentDict

persistent/list.py

+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+"""Python implementation of persistent list.
+
+$Id$"""
+
+import persistent
+from UserList import UserList
+
+class PersistentList(UserList, persistent.Persistent):
+    __super_setitem = UserList.__setitem__
+    __super_delitem = UserList.__delitem__
+    __super_setslice = UserList.__setslice__
+    __super_delslice = UserList.__delslice__
+    __super_iadd = UserList.__iadd__
+    __super_imul = UserList.__imul__
+    __super_append = UserList.append
+    __super_insert = UserList.insert
+    __super_pop = UserList.pop
+    __super_remove = UserList.remove
+    __super_reverse = UserList.reverse
+    __super_sort = UserList.sort
+    __super_extend = UserList.extend
+
+    def __setitem__(self, i, item):
+        self.__super_setitem(i, item)
+        self._p_changed = 1
+
+    def __delitem__(self, i):
+        self.__super_delitem(i)
+        self._p_changed = 1
+
+    def __setslice__(self, i, j, other):
+        self.__super_setslice(i, j, other)
+        self._p_changed = 1
+
+    def __delslice__(self, i, j):
+        self.__super_delslice(i, j)
+        self._p_changed = 1
+
+    def __iadd__(self, other):
+        L = self.__super_iadd(other)
+        self._p_changed = 1
+        return L
+
+    def __imul__(self, n):
+        L = self.__super_imul(n)
+        self._p_changed = 1
+        return L
+
+    def append(self, item):
+        self.__super_append(item)
+        self._p_changed = 1
+
+    def insert(self, i, item):
+        self.__super_insert(i, item)
+        self._p_changed = 1
+
+    def pop(self, i=-1):
+        rtn = self.__super_pop(i)
+        self._p_changed = 1
+        return rtn
+
+    def remove(self, item):
+        self.__super_remove(item)
+        self._p_changed = 1
+
+    def reverse(self):
+        self.__super_reverse()
+        self._p_changed = 1
+
+    def sort(self, *args, **kwargs):
+        self.__super_sort(*args, **kwargs)
+        self._p_changed = 1
+
+    def extend(self, other):
+        self.__super_extend(other)
+        self._p_changed = 1
+
+    # This works around a bug in Python 2.1.x (up to 2.1.2 at least) where the
+    # __cmp__ bogusly raises a RuntimeError, and because this is an extension
+    # class, none of the rich comparison stuff works anyway.
+    def __cmp__(self, other):
+        return cmp(self.data, self._UserList__cast(other))

persistent/mapping.py

+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+
+"""Python implementation of persistent base types
+
+$Id$"""
+
+import persistent
+import UserDict
+
+class default(object):
+
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, inst, class_):
+        if inst is None:
+            return self
+        return self.func(inst)
+
+
+class PersistentMapping(UserDict.IterableUserDict, persistent.Persistent):
+    """A persistent wrapper for mapping objects.
+
+    This class allows wrapping of mapping objects so that object
+    changes are registered.  As a side effect, mapping objects may be
+    subclassed.
+
+    A subclass of PersistentMapping or any code that adds new
+    attributes should not create an attribute named _container.  This
+    is reserved for backwards compatibility reasons.
+    """
+
+    # UserDict provides all of the mapping behavior.  The
+    # PersistentMapping class is responsible marking the persistent
+    # state as changed when a method actually changes the state.  At
+    # the mapping API evolves, we may need to add more methods here.
+
+    __super_delitem = UserDict.IterableUserDict.__delitem__
+    __super_setitem = UserDict.IterableUserDict.__setitem__
+    __super_clear = UserDict.IterableUserDict.clear
+    __super_update = UserDict.IterableUserDict.update
+    __super_setdefault = UserDict.IterableUserDict.setdefault
+    __super_pop = UserDict.IterableUserDict.pop
+    __super_popitem = UserDict.IterableUserDict.popitem
+
+    def __delitem__(self, key):
+        self.__super_delitem(key)
+        self._p_changed = 1
+
+    def __setitem__(self, key, v):
+        self.__super_setitem(key, v)
+        self._p_changed = 1
+
+    def clear(self):
+        self.__super_clear()
+        self._p_changed = 1
+
+    def update(self, b):
+        self.__super_update(b)
+        self._p_changed = 1
+
+    def setdefault(self, key, failobj=None):
+        # We could inline all of UserDict's implementation into the
+        # method here, but I'd rather not depend at all on the
+        # implementation in UserDict (simple as it is).
+        if not self.has_key(key):
+            self._p_changed = 1
+        return self.__super_setdefault(key, failobj)
+
+    def pop(self, key, *args):
+        self._p_changed = 1
+        return self.__super_pop(key, *args)
+
+    def popitem(self):
+        self._p_changed = 1
+        return self.__super_popitem()
+
+    # Old implementations used _container rather than data.
+    # Use a descriptor to provide data when we have _container instead
+
+    @default
+    def data(self):
+        # We don't want to cause a write on read, so wer're careful not to
+        # do anything that would cause us to become marked as changed, however,
+        # if we're modified, then the saved record will have data, not
+        # _container.
+        data = self.__dict__.pop('_container')
+        self.__dict__['data'] = data
+
+        return data

persistent/picklecache.py

+##############################################################################
+#
+# Copyright (c) 2009 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+import weakref
+
+from zope.interface import implements
+
+from persistent.interfaces import CHANGED
+from persistent.interfaces import GHOST
+from persistent.interfaces import IPickleCache
+from persistent.interfaces import STICKY
+
+class RingNode(object):
+    # 32 byte fixed size wrapper.
+    __slots__ = ('object', 'next', 'prev')
+    def __init__(self, object, next=None, prev=None):
+        self.object = object
+        self.next = next
+        self.prev = prev
+
+class PickleCache(object):
+    implements(IPickleCache)
+
+    def __init__(self, jar, target_size=0, cache_size_bytes=0):
+        # TODO:  forward-port Dieter's bytes stuff
+        self.jar = jar
+        self.target_size = target_size
+        self.drain_resistance = 0
+        self.non_ghost_count = 0
+        self.persistent_classes = {}
+        self.data = weakref.WeakValueDictionary()
+        self.ring = RingNode(None)
+        self.ring.next = self.ring.prev = self.ring
+
+    # IPickleCache API
+    def __len__(self):
+        """ See IPickleCache.
+        """
+        return (len(self.persistent_classes) +
+                len(self.data))
+
+    def __getitem__(self, oid):
+        """ See IPickleCache.
+        """
+        value = self.data.get(oid)
+        if value is not None:
+            return value
+        return self.persistent_classes[oid]
+
+    def __setitem__(self, oid, value):
+        """ See IPickleCache.
+        """
+        if not isinstance(oid, str):
+            raise ValueError('OID must be string: %s' % oid)
+        # XXX
+        if oid in self.persistent_classes or oid in self.data:
+            raise KeyError('Duplicate OID: %s' % oid)
+        if type(value) is type:
+            self.persistent_classes[oid] = value
+        else:
+            self.data[oid] = value
+            if value._p_state != GHOST:
+                self.non_ghost_count += 1
+                mru = self.ring.prev
+                self.ring.prev = node = RingNode(value, self.ring, mru)
+                mru.next = node
+
+    def __delitem__(self, oid):
+        """ See IPickleCache.
+        """
+        if not isinstance(oid, str):
+            raise ValueError('OID must be string: %s' % oid)
+        if oid in self.persistent_classes:
+            del self.persistent_classes[oid]
+        else:
+            value = self.data.pop(oid)
+            node = self.ring.next
+            if node is None:
+                return
+            while node is not self.ring:
+                if node.object is value:
+                    node.prev.next, node.next.prev = node.next, node.prev
+                    self.non_ghost_count -= 1
+                    break
+                node = node.next
+
+    def get(self, oid, default=None):
+        """ See IPickleCache.
+        """
+        value = self.data.get(oid, self)
+        if value is not self:
+            return value
+        return self.persistent_classes.get(oid, default)
+
+    def mru(self, oid):
+        """ See IPickleCache.
+        """
+        node = self.ring.next
+        while node is not self.ring and node.object._p_oid != oid:
+            node = node.next
+        if node is self.ring:
+            value = self.data[oid]
+            if value._p_state != GHOST:
+                self.non_ghost_count += 1
+                mru = self.ring.prev
+                self.ring.prev = node = RingNode(value, self.ring, mru)
+                mru.next = node
+        else:
+            # remove from old location
+            node.prev.next, node.next.prev = node.next, node.prev
+            # splice into new
+            self.ring.prev.next, node.prev = node, self.ring.prev
+            self.ring.prev, node.next = node, self.ring
+        
+    def ringlen(self):
+        """ See IPickleCache.
+        """
+        result = 0
+        node = self.ring.next
+        while node is not self.ring:
+            result += 1
+            node = node.next
+        return result
+
+    def items(self):
+        """ See IPickleCache.
+        """
+        return self.data.items()
+
+    def lru_items(self):
+        """ See IPickleCache.
+        """
+        result = []
+        node = self.ring.next
+        while node is not self.ring:
+            result.append((node.object._p_oid, node.object))
+            node = node.next
+        return result
+
+    def klass_items(self):
+        """ See IPickleCache.
+        """
+        return self.persistent_classes.items()
+
+    def incrgc(self, ignored=None):
+        """ See IPickleCache.
+        """
+        target = self.target_size
+        if self.drain_resistance >= 1:
+            size = self.non_ghost_count
+            target2 = size - 1 - (size / self.drain_resistance)
+            if target2 < target:
+                target = target2
+        self._sweep(target)
+
+    def full_sweep(self, target=None):
+        """ See IPickleCache.
+        """
+        self._sweep(0)
+
+    minimize = full_sweep
+
+    def reify(self, oid):
+        """ See IPickleCache.
+        """
+        pass
+
+    def invalidate(self, to_invalidate):
+        """ See IPickleCache.
+        """
+        if isinstance(to_invalidate, str):
+            self._invalidate(to_invalidate)
+        else:
+            for oid in to_invalidate:
+                self._invalidate(oid)
+
+    def debug_info(self):
+        """ See IPickleCache.
+        """
+        result = []
+        for oid, klass in self.persistent_classes.items():
+            result.append((oid,
+                            len(gc.getreferents(value)),
+                            type(value).__name__,
+                            value._p_state,
+                            ))
+        for oid, value in self.data.items():
+            result.append((oid,
+                            len(gc.getreferents(value)),
+                            type(value).__name__,
+                            ))
+
+    cache_size = property(lambda self: self.target_size)
+    cache_drain_resistance = property(lambda self: self.drain_resistance)
+    cache_non_ghost_count = property(lambda self: self.non_ghost_count)
+    cache_data = property(lambda self: dict(self.data.items()))
+    cache_klass_count = property(lambda self: len(self.persistent_classes))
+
+    # Helpers
+    def _sweep(self, target):
+        # lock
+        node = self.ring.next
+        while node is not self.ring and self.non_ghost_count > target:
+            if node.object._p_state not in (STICKY, CHANGED):
+                node.prev.next, node.next.prev = node.next, node.prev
+                node.object = None
+                self.non_ghost_count -= 1
+            node = node.next
+
+    def _invalidate(self, oid):
+        value = self.data.get(oid)
+        if value is not None and value._p_state != GHOST:
+            # value._p_invalidate() # NOOOO, we'll do it ourselves.
+            value._p_ghostify() # TBD
+            node = self.ring.next
+            while node is not self.ring:
+                if node.object is value:
+                    node.prev.next, node.next.prev = node.next, node.prev
+                    break
+        elif oid in self.persistent_classes:
+            del self.persistent_classes[oid]
+

persistent/py24compat.h

+/* Backport type definitions from Python 2.5's object.h */
+#ifndef PERSISTENT_PY24COMPAT_H
+#define PERSISTENT_PY24COMPAT_H
+#if PY_VERSION_HEX < 0x02050000
+typedef int Py_ssize_t;
+#define PY_SSIZE_T_MAX INT_MAX
+#define PY_SSIZE_T_MIN INT_MIN
+#endif /* PY_VERSION_HEX */
+#endif /* PERSISTENT_PY24COMPAT_H */

persistent/ring.c

+/*****************************************************************************
+
+  Copyright (c) 2003 Zope Foundation and Contributors.
+  All Rights Reserved.
+
+  This software is subject to the provisions of the Zope Public License,
+  Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+  WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+  FOR A PARTICULAR PURPOSE
+
+ ****************************************************************************/
+
+#define RING_C "$Id$\n"
+
+/* Support routines for the doubly-linked list of cached objects.
+
+The cache stores a doubly-linked list of persistent objects, with
+space for the pointers allocated in the objects themselves.  The cache
+stores the distinguished head of the list, which is not a valid
+persistent object.
+
+The next pointers traverse the ring in order starting with the least
+recently used object.  The prev pointers traverse the ring in order
+starting with the most recently used object.
+
+*/
+
+#include "Python.h"
+#include "ring.h"
+
+void
+ring_add(CPersistentRing *ring, CPersistentRing *elt)
+{
+    assert(!elt->r_next);
+    elt->r_next = ring;
+    elt->r_prev = ring->r_prev;
+    ring->r_prev->r_next = elt;
+    ring->r_prev = elt;
+}
+
+void
+ring_del(CPersistentRing *elt)
+{
+    elt->r_next->r_prev = elt->r_prev;
+    elt->r_prev->r_next = elt->r_next;
+    elt->r_next = NULL;
+    elt->r_prev = NULL;
+}
+
+void
+ring_move_to_head(CPersistentRing *ring, CPersistentRing *elt)
+{
+    elt->r_prev->r_next = elt->r_next;
+    elt->r_next->r_prev = elt->r_prev;
+    elt->r_next = ring;
+    elt->r_prev = ring->r_prev;
+    ring->r_prev->r_next = elt;
+    ring->r_prev = elt;
+}

persistent/ring.h

+/*****************************************************************************
+
+  Copyright (c) 2003 Zope Foundation and Contributors.
+  All Rights Reserved.
+
+  This software is subject to the provisions of the Zope Public License,
+  Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+  WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+  FOR A PARTICULAR PURPOSE
+
+ ****************************************************************************/
+
+/* Support routines for the doubly-linked list of cached objects.
+
+The cache stores a headed, doubly-linked, circular list of persistent
+objects, with space for the pointers allocated in the objects themselves.
+The cache stores the distinguished head of the list, which is not a valid
+persistent object.  The other list members are non-ghost persistent
+objects, linked in LRU (least-recently used) order.
+
+The r_next pointers traverse the ring starting with the least recently used
+object.  The r_prev pointers traverse the ring starting with the most
+recently used object.
+
+Obscure:  While each object is pointed at twice by list pointers (once by
+its predecessor's r_next, again by its successor's r_prev), the refcount
+on the object is bumped only by 1.  This leads to some possibly surprising
+sequences of incref and decref code.  Note that since the refcount is
+bumped at least once, the list does hold a strong reference to each
+object in it.
+*/
+
+typedef struct CPersistentRing_struct
+{
+    struct CPersistentRing_struct *r_prev;
+    struct CPersistentRing_struct *r_next;
+} CPersistentRing;
+
+/* The list operations here take constant time independent of the
+ * number of objects in the list:
+ */
+
+/* Add elt as the most recently used object.  elt must not already be
+ * in the list, although this isn't checked.
+ */
+void ring_add(CPersistentRing *ring, CPersistentRing *elt);
+
+/* Remove elt from the list.  elt must already be in the list, although
+ * this isn't checked.
+ */
+void ring_del(CPersistentRing *elt);
+
+/* elt must already be in the list, although this isn't checked.  It's
+ * unlinked from its current position, and relinked into the list as the
+ * most recently used object (which is arguably the tail of the list
+ * instead of the head -- but the name of this function could be argued
+ * either way).  This is equivalent to
+ *
+ *     ring_del(elt);
+ *     ring_add(ring, elt);
+ *
+ * but may be a little quicker.
+ */
+void ring_move_to_head(CPersistentRing *ring, CPersistentRing *elt);

persistent/tests/__init__.py

+# package

persistent/tests/test_persistent.py

+##############################################################################
+#
+# Copyright (c) Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+from persistent import Persistent
+
+try:
+    from persistent import simple_new
+except ImportError:
+    simple_new = None
+
+import os
+if os.environ.get('USE_ZOPE_TESTING_DOCTEST'):
+    from zope.testing import doctest
+else:
+    import doctest
+
+import unittest
+
+class P(Persistent):
+    def __init__(self):
+        self.x = 0
+    def inc(self):
+        self.x += 1
+
+def cpersistent_setstate_pointer_sanity():
+    """
+    >>> Persistent().__setstate__({})
+    Traceback (most recent call last):
+    ...
+    TypeError: this object has no instance dictionary
+
+    >>> class C(Persistent): __slots__ = 'x', 'y'
+    >>> C().__setstate__(({}, {}))
+    Traceback (most recent call last):
+    ...
+    TypeError: this object has no instance dictionary
+    """
+
+if simple_new is not None:
+    def cpersistent_simple_new_invalid_argument():
+        """
+        >>> simple_new('')
+        Traceback (most recent call last):
+        ...
+        TypeError: simple_new argument must be a type object.
+        """
+
+def test_suite():
+    return unittest.TestSuite((
+        doctest.DocFileSuite("persistent.txt", globs={"P": P}),
+        doctest.DocTestSuite(),
+        ))

persistent/tests/test_wref.py

+##############################################################################
+#
+# Copyright (c) 2003 Zope Foundation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+import unittest
+import os
+if os.environ.get('USE_ZOPE_TESTING_DOCTEST'):
+    from zope.testing.doctest import DocTestSuite
+else:
+    from doctest import DocTestSuite
+
+def test_suite():
+    return DocTestSuite('persistent.wref')
+
+if __name__ == '__main__':
+    unittest.main()