[Zodb-checkins] CVS: Zope3/lib/python/Persistence - Class.py:1.5 Module.py:1.29 __init__.py:1.9 cPersistence.c:1.21 cPersistence.h:1.6 cPersistenceAPI.h:1.6
Jim Fulton
jim@zope.com
Thu, 10 Oct 2002 04:20:12 -0400
Update of /cvs-repository/Zope3/lib/python/Persistence
In directory cvs.zope.org:/tmp/cvs-serv8043/lib/python/Persistence
Modified Files:
Class.py Module.py __init__.py cPersistence.c cPersistence.h
cPersistenceAPI.h
Log Message:
Backed out a bunch of persistence changes checkin in last night that
broke things badly. Unit tests failed and zope wouldn't start under
either Python 2.2.1 or the Python CVS head. Aaaargh.
=== Zope3/lib/python/Persistence/Class.py 1.4 => 1.5 ===
--- Zope3/lib/python/Persistence/Class.py:1.4 Wed Oct 9 18:41:32 2002
+++ Zope3/lib/python/Persistence/Class.py Thu Oct 10 04:20:06 2002
@@ -13,7 +13,7 @@
##############################################################################
"""Persistent Classes."""
-from Persistence import Persistent, PersistentMetaClass
+from Persistence import Persistent
from Persistence.cPersistence import UPTODATE, CHANGED, STICKY, GHOST
from Persistence.IPersistent import IPersistent
from Persistence.Function import PersistentFunction
@@ -22,10 +22,6 @@
from types import FunctionType as function
import time
-# XXX There is a lot of magic here to give classes and instances
-# separate sets of attributes. This code should be documented, as it
-# it quite delicate, and it should be move to a separate module.
-
class ExtClassDescr(object):
"""Maintains seperate class and instance descriptors for an attribute.
@@ -148,7 +144,7 @@
return o
return default
-class PersistentClassMetaClass(PersistentMetaClass):
+class PersistentMetaClass(type):
# an attempt to make persistent classes look just like other
# persistent objects by providing class attributes and methods
@@ -162,7 +158,7 @@
_pc_init = 0
def __new__(meta, name, bases, dict):
- cls = super(PersistentClassMetaClass, meta).__new__(meta, name, bases, dict)
+ cls = super(PersistentMetaClass, meta).__new__(meta, name, bases, dict)
# helper functions
def extend_attr(attr, v):
prev = findattr(cls, attr, None)
@@ -195,7 +191,7 @@
if cls._p_state is None:
cls._p_activate()
cls._p_atime = int(time.time() % 86400)
- return super(PersistentClassMetaClass, cls).__getattribute__(name)
+ return super(PersistentMetaClass, cls).__getattribute__(name)
def __setattr__(cls, attr, val):
if not attr.startswith("_pc_") and cls._pc_init:
@@ -205,7 +201,7 @@
if set is not None:
set(None, val)
return
- super(PersistentClassMetaClass, cls).__setattr__(attr, val)
+ super(PersistentMetaClass, cls).__setattr__(attr, val)
def __delattr__(cls, attr):
if attr.startswith('_p_'):
@@ -214,7 +210,7 @@
pass
else:
return
- super(PersistentClassMetaClass, cls).__delattr__(attr)
+ super(PersistentMetaClass, cls).__delattr__(attr)
def __getstate__(cls):
dict = {}
@@ -246,14 +242,14 @@
class PersistentBaseClass(Persistent):
- __metaclass__ = PersistentClassMetaClass
+ __metaclass__ = PersistentMetaClass
def _test():
global PC, P
class PC(Persistent):
- __metaclass__ = PersistentClassMetaClass
+ __metaclass__ = PersistentMetaClass
def __init__(self):
self.x = 1
=== Zope3/lib/python/Persistence/Module.py 1.28 => 1.29 ===
--- Zope3/lib/python/Persistence/Module.py:1.28 Wed Oct 9 18:41:32 2002
+++ Zope3/lib/python/Persistence/Module.py Thu Oct 10 04:20:06 2002
@@ -22,7 +22,7 @@
from Persistence import Persistent
from Persistence.cPersistence import GHOST
-from Persistence.Class import PersistentClassMetaClass
+from Persistence.Class import PersistentMetaClass
from Persistence.Function import PersistentFunction
from Persistence.IPersistentModuleManager import IPersistentModuleManager
from Persistence.IPersistentModuleRegistry \
@@ -135,7 +135,7 @@
for k, v in new.items():
if isinstance(v, function):
v = new[k] = PersistentFunction(v, module)
- elif isinstance(v.__class__, PersistentClassMetaClass):
+ elif isinstance(v.__class__, PersistentMetaClass):
v.__class__.fixup(module)
# XXX need to check for classes that are not persistent!
=== Zope3/lib/python/Persistence/__init__.py 1.8 => 1.9 ===
--- Zope3/lib/python/Persistence/__init__.py:1.8 Wed Oct 9 18:41:32 2002
+++ Zope3/lib/python/Persistence/__init__.py Thu Oct 10 04:20:06 2002
@@ -11,15 +11,15 @@
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
-"""Provide access to Persistent C extension types."""
+"""Provide access to Persistent and BasePersistent C extension types."""
-from cPersistence import Persistent, PersistentMetaClass
+from cPersistence import Persistent, BasePersistent
# Wire up simple constructor
import cPersistence
-##simple_new = cPersistence.simple_new
-##del cPersistence.simple_new
-##del cPersistence
+simple_new = cPersistence.simple_new
+del cPersistence.simple_new
+del cPersistence
import copy_reg
-copy_reg.constructor(cPersistence.simple_new)
-##del copy_reg
+copy_reg.constructor(simple_new)
+del copy_reg
=== Zope3/lib/python/Persistence/cPersistence.c 1.20 => 1.21 ===
--- Zope3/lib/python/Persistence/cPersistence.c:1.20 Wed Oct 9 18:41:32 2002
+++ Zope3/lib/python/Persistence/cPersistence.c Thu Oct 10 04:20:06 2002
@@ -20,8 +20,35 @@
"\n"
"$Id$\n";
-/* Python version of the simple_new function; */
-static PyObject *py_simple_new = NULL;
+/* cPersistence defines two Python types and a C API for them.
+
+ This table summarizes the stuff connected to each type.
+
+ PyTypeObject PyPersistBase_Type PyPersist_Type
+ supports persistent objects in C persistent objects in Python
+ PyObject * PyPersistBaseObject * PyPersistObject *
+ C struct PyPersist_HEAD PyPersist_INSTANCE_HEAD
+ C API macro PyPersist_BASE_TYPE PyPersist_INSTANCE_TYPE
+ Python object Persistence.BasePersistent Persistence.Persistent
+
+ The two types share many of the same tp_xxx implementations. The
+ key difference between the base type and the instance type is that
+ the latter has room for an __dict__. The Persistence.Persistent
+ object is used as a base class for peristent object classes written
+ in Python.
+
+ The functions that can operate on either type take a
+ PyPersistBaseObject * argument. If the function needs to access
+ the po_dict slot, it must first check obj->ob_type->tp_dictoffset.
+ For a PyPersistBase_Type object, the dictoffset is 0.
+
+ The getstate and setstate implementations only work with
+ PyPersist_Type objects, because they depend on having an __dict__.
+
+ The base type exists to support C types that are also persistent.
+ The only examples of such types are in Persistence.BTrees.
+
+*/
/* A helper function that registers a persistent object with its data
manager.
@@ -29,8 +56,14 @@
static PyObject *s_register = NULL;
+/* Python version of the simple_new function; */
+static PyObject *py_simple_new = NULL;
+
+
+
+
PyObject *
-_PyPersist_RegisterDataManager(PyPersistObject *self)
+_PyPersist_RegisterDataManager(PyPersistBaseObject *self)
{
PyObject *meth, *arg, *result;
@@ -62,7 +95,7 @@
*/
PyObject *
-_PyPersist_Load(PyPersistObject *self)
+_PyPersist_Load(PyPersistBaseObject *self)
{
static PyObject *s_setstate = NULL;
PyObject *meth, *arg, *result;
@@ -98,7 +131,7 @@
*/
void
-_PyPersist_SetATime(PyPersistObject *self)
+_PyPersist_SetATime(PyPersistBaseObject *self)
{
time_t t = time(NULL);
self->po_atime = t % 86400;
@@ -190,7 +223,7 @@
persist_activate(PyPersistObject *self)
{
if (self->po_state == GHOST && self->po_dm)
- return _PyPersist_Load((PyPersistObject *)self);
+ return _PyPersist_Load((PyPersistBaseObject *)self);
Py_INCREF(Py_None);
return Py_None;
}
@@ -280,7 +313,7 @@
if (newstate == CHANGED_TRUE || newstate == CHANGED_FALSE) {
/* Turn a ghost into a real object. */
self->po_state = CHANGED;
- if (_PyPersist_Load((PyPersistObject *)self) == NULL)
+ if (_PyPersist_Load((PyPersistBaseObject *)self) == NULL)
return -1;
if (newstate == CHANGED_TRUE)
self->po_state = CHANGED;
@@ -291,7 +324,7 @@
/* Mark an up-to-date object as changed. */
if (self->po_state == UPTODATE) {
self->po_state = CHANGED;
- if (!_PyPersist_RegisterDataManager((PyPersistObject *)self))
+ if (!_PyPersist_RegisterDataManager((PyPersistBaseObject *)self))
return -1;
}
} else if (newstate == CHANGED_FALSE) {
@@ -319,6 +352,19 @@
return 0;
}
+static PyObject *
+persist_get_dict(PyPersistObject *self)
+{
+ if (self->po_dict == NULL) {
+ self->po_dict = PyDict_New();
+ if (self->po_dict == NULL)
+ return NULL;
+ }
+ Py_INCREF(self->po_dict);
+ return self->po_dict;
+}
+
+
/* convert_name() returns a new reference to a string name
or sets an exception and returns NULL.
*/
@@ -388,14 +434,14 @@
already registered.
*/
self->po_state = CHANGED;
- if (_PyPersist_Load((PyPersistObject *)self) == NULL) {
+ if (_PyPersist_Load((PyPersistBaseObject *)self) == NULL) {
call_p_deactivate(self);
self->po_state = GHOST;
return NULL;
} else
self->po_state = UPTODATE;
}
- _PyPersist_SetATime((PyPersistObject *)self);
+ _PyPersist_SetATime((PyPersistBaseObject *)self);
}
/* will invoke an __getattr__ if it exists. */
@@ -415,7 +461,7 @@
*/
static int
-persist_setattr_prep(PyPersistObject *self, PyObject *name,
+persist_setattr_prep(PyPersistBaseObject *self, PyObject *name,
PyObject *value)
{
char *s_name;
@@ -445,7 +491,7 @@
"attempt to modify unrevivable ghost");
return -1;
}
- if (_PyPersist_Load((PyPersistObject *)self) == NULL)
+ if (_PyPersist_Load((PyPersistBaseObject *)self) == NULL)
return -1;
}
/* If the object is marked as UPTODATE then it must be
@@ -457,12 +503,12 @@
XXX What if it's in the sticky state?
*/
if (self->po_state == UPTODATE && self->po_dm &&
- !_PyPersist_RegisterDataManager((PyPersistObject *)self))
+ !_PyPersist_RegisterDataManager((PyPersistBaseObject *)self))
return -1;
if (self->po_dm && self->po_oid) {
self->po_state = CHANGED;
- _PyPersist_SetATime((PyPersistObject *)self);
+ _PyPersist_SetATime((PyPersistBaseObject *)self);
}
return 1;
}
@@ -470,7 +516,7 @@
}
static int
-persist_setattro(PyPersistObject *self, PyObject *name, PyObject *value)
+persist_setattro(PyPersistBaseObject *self, PyObject *name, PyObject *value)
{
int r;
@@ -486,7 +532,7 @@
}
static PyObject *
-persist_p_set_or_delattr(PyPersistObject *self, PyObject *name,
+persist_p_set_or_delattr(PyPersistBaseObject *self, PyObject *name,
PyObject *value)
{
PyObject *res;
@@ -521,7 +567,7 @@
*/
static PyObject *
-persist_p_setattr(PyPersistObject *self, PyObject *args)
+persist_p_setattr(PyPersistBaseObject *self, PyObject *args)
{
PyObject *name, *value;
@@ -538,7 +584,7 @@
*/
static PyObject *
-persist_p_delattr(PyPersistObject *self, PyObject *name)
+persist_p_delattr(PyPersistBaseObject *self, PyObject *name)
{
return persist_p_set_or_delattr(self, name, NULL);
}
@@ -549,6 +595,9 @@
Py_XDECREF(self->po_dm);
Py_XDECREF(self->po_oid);
Py_XDECREF(self->po_serial);
+ if (self->ob_type->tp_dictoffset) {
+ Py_XDECREF(self->po_dict);
+ }
PyObject_GC_Del(self);
}
@@ -566,6 +615,9 @@
VISIT(self->po_dm);
VISIT(self->po_oid);
VISIT(self->po_serial);
+ if (self->ob_type->tp_dictoffset) {
+ VISIT(self->po_dict);
+ }
#undef VISIT
return 0;
}
@@ -579,6 +631,10 @@
self->po_dm = NULL;
self->po_oid = NULL;
self->po_serial = NULL;
+ if (self->ob_type->tp_dictoffset) {
+ Py_XDECREF(self->po_dict);
+ self->po_dict = NULL;
+ }
return 0;
}
@@ -628,90 +684,14 @@
return NULL;
}
-/* Make persistent objects work with Python 2.2.
-
- The rules for deciding whether to give an object an __dict__ or an
- __weakref__ are different in 2.2 than in later versions of Python.
- In particular, an object will not get an __dict__ if it has a
- custom setattr.
-*/
-
-static PyObject *
-persist_dict(PyObject *obj, void *context)
-{
- PyObject **dictptr;
-
- dictptr = _PyObject_GetDictPtr(obj);
- assert(dictptr);
-
- if (!*dictptr) {
- PyObject *dict = PyDict_New();
- if (!dict)
- return NULL;
- *dictptr = dict;
- }
- Py_INCREF(*dictptr);
- return *dictptr;
-}
-
-static PyGetSetDef persist_meta_getsets[] = {
- {"__dict__", (getter)persist_dict, NULL, NULL},
- {NULL}
+static PyMethodDef base_persist_methods[] = {
+ {"_p_activate", (PyCFunction)persist_activate, METH_NOARGS, },
+ {"_p_deactivate", (PyCFunction)persist_deactivate, METH_NOARGS, },
+ {"_p_setattr", (PyCFunction)persist_p_setattr, METH_VARARGS, },
+ {"_p_delattr", (PyCFunction)persist_p_delattr, METH_O, },
+ {NULL}
};
-/* PyPersist_New is the tp_new of PersistentMetaClass, which exists
- only for compatibility with Python 2.2.
-
- This new function must determine whether to create an __dict__.
- XXX In the future, it might also handle __weakref__.
-
- Python 2.2 and 2.3 have fairly different rules for whether an
- instance should get a dict. The 2.3 rules will often create an
- __dict__; we don't want to emulate that functionality because it
- would make persistent classes different from non-persistent
- new-style classes.
-*/
-
-static PyObject *
-PyPersist_New(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
- PyTypeObject *new;
-
- new = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds);
- if (!new)
- return NULL;
-
- /* the slots test is not correct, because all base types must
- define slots to get slots.
- */
- if (!(PyObject_HasAttrString((PyObject *)new, "__slots__")
- || new->tp_dictoffset)) {
- PyObject *descr;
-
- /* Update the type to know about __dict__. */
- if (type->tp_itemsize)
- new->tp_dictoffset = -(long)sizeof(PyObject *);
- else
- new->tp_dictoffset = type->tp_basicsize;
- /* alignment issues */
- new->tp_basicsize += sizeof(PyObject *);
-
- /* Put a descriptor for __dict__ in the type's __dict__.
- It's too late to get type to do this for us. */
- descr = PyDescr_NewGetSet(new, persist_meta_getsets);
- if (!descr) {
- Py_DECREF(new);
- return NULL;
- }
- if (PyDict_SetItemString(new->tp_dict, "__dict__", descr) < 0) {
- Py_DECREF(new);
- return NULL;
- }
- }
-
- return (PyObject *)new;
-}
-
static PyMethodDef persist_methods[] = {
{"__reduce__", (PyCFunction)persist_reduce, METH_NOARGS, },
{"__getstate__", (PyCFunction)persist_getstate, METH_NOARGS, },
@@ -723,8 +703,14 @@
{NULL}
};
+static PyGetSetDef base_persist_getsets[] = {
+ {"_p_changed", (getter)persist_get_state, (setter)persist_set_state},
+ {NULL}
+};
+
static PyGetSetDef persist_getsets[] = {
{"_p_changed", (getter)persist_get_state, (setter)persist_set_state},
+ {"__dict__", (getter)persist_get_dict},
{NULL}
};
@@ -735,6 +721,7 @@
{"_p_oid", T_OBJECT, offsetof(PyPersistObject, po_oid)},
{"_p_serial", T_OBJECT, offsetof(PyPersistObject, po_serial)},
{"_p_atime", T_INT, offsetof(PyPersistObject, po_atime)},
+ /* XXX should this be exposed? */
{"_p_state", T_INT, offsetof(PyPersistObject, po_state), RO},
{NULL}
};
@@ -748,14 +735,56 @@
*/
#define DEFERRED_ADDRESS(ADDR) 0
-static PyTypeObject PyPersist_MetaType = {
+/* XXX Not sure how much functionality the base persistent type should
+ provide. It is currently used only by the BTrees.
+*/
+
+
+static PyTypeObject PyPersistBase_Type = {
PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
0, /* ob_size */
- "Persistence.PersistentMetaClass", /* tp_name */
+ "Persistence.BasePersistent", /* tp_name */
+ sizeof(PyPersistBaseObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)persist_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ (getattrofunc)persist_getattro, /* tp_getattro */
+ (setattrofunc)persist_setattro, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ 0, /* tp_doc */
+ (traverseproc)persist_traverse, /* tp_traverse */
+ (inquiry)persist_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ base_persist_methods, /* tp_methods */
+ persist_members, /* tp_members */
+ base_persist_getsets, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ 0, /*PyType_GenericNew,*/ /* tp_new */
};
static PyTypeObject PyPersist_Type = {
- PyObject_HEAD_INIT(&PyPersist_MetaType)
+ PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
0, /* ob_size */
"Persistence.Persistent", /* tp_name */
sizeof(PyPersistObject), /* tp_basicsize */
@@ -791,26 +820,27 @@
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
- 0, /* tp_dictoffset */
+ offsetof(PyPersistObject, po_dict), /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
- 0, /* tp_new */
+ 0, /*PyType_GenericNew,*/ /* tp_new */
};
static PyObject *
simple_new(PyObject *self, PyObject *type_object)
{
- return PyType_GenericNew((PyTypeObject*)type_object, NULL, NULL);
+ return PyType_GenericNew((PyTypeObject*)type_object, NULL, NULL);
}
static PyMethodDef PyPersist_methods[] = {
- {"simple_new", simple_new, METH_O,
- "Create an object by simply calling a class' __new__ method without "
- "arguments."},
- {NULL, NULL}
+ {"simple_new", simple_new, METH_O,
+ "Create an object by simply calling a class' __new__ method without "
+ "arguments."},
+ {NULL, NULL}
};
static PyPersist_C_API_struct c_api = {
+ &PyPersistBase_Type,
&PyPersist_Type,
_PyPersist_Load,
_PyPersist_RegisterDataManager,
@@ -861,22 +891,16 @@
{
PyObject *m, *d, *v;
- /* It's easier to initialize a few fields by assignment than to
- fill out the entire type structure in an initializer.
- */
- PyPersist_MetaType.ob_type = &PyType_Type;
- PyPersist_MetaType.tp_new = PyPersist_New;
- PyPersist_MetaType.tp_base = &PyType_Type;
- PyPersist_MetaType.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
- Py_TPFLAGS_BASETYPE;
- PyPersist_MetaType.tp_traverse = PyType_Type.tp_traverse;
- PyPersist_MetaType.tp_clear = PyType_Type.tp_clear;
- if (PyType_Ready(&PyPersist_MetaType) < 0)
- return;
-
+ PyPersistBase_Type.ob_type = &PyType_Type;
+ PyPersistBase_Type.tp_new = PyType_GenericNew;
+ PyPersist_Type.ob_type = &PyType_Type;
PyPersist_Type.tp_new = PyType_GenericNew;
+ if (PyType_Ready(&PyPersistBase_Type) < 0)
+ return;
if (PyType_Ready(&PyPersist_Type) < 0)
return;
+ if (persist_set_interface(&PyPersistBase_Type) < 0)
+ return;
if (persist_set_interface(&PyPersist_Type) < 0)
return;
@@ -891,9 +915,10 @@
Py_INCREF(&PyPersist_Type);
if (PyDict_SetItemString(d, "Persistent", (PyObject *)&PyPersist_Type) < 0)
return;
- Py_INCREF(&PyPersist_MetaType);
- if (PyDict_SetItemString(d, "PersistentMetaClass",
- (PyObject *)&PyPersist_MetaType) < 0)
+
+ Py_INCREF(&PyPersistBase_Type);
+ if (PyDict_SetItemString(d, "BasePersistent",
+ (PyObject *)&PyPersistBase_Type) < 0)
return;
v = PyCObject_FromVoidPtr(&c_api, NULL);
=== Zope3/lib/python/Persistence/cPersistence.h 1.5 => 1.6 ===
--- Zope3/lib/python/Persistence/cPersistence.h:1.5 Wed Oct 9 18:41:32 2002
+++ Zope3/lib/python/Persistence/cPersistence.h Thu Oct 10 04:20:06 2002
@@ -40,13 +40,21 @@
int po_atime; \
enum PyPersist_State po_state;
+#define PyPersist_INSTANCE_HEAD \
+ PyPersist_HEAD \
+ PyObject *po_dict;
+
typedef struct {
PyPersist_HEAD
+} PyPersistBaseObject;
+
+typedef struct {
+ PyPersist_INSTANCE_HEAD
} PyPersistObject;
-extern PyObject *_PyPersist_Load(PyPersistObject *);
-extern PyObject *_PyPersist_RegisterDataManager(PyPersistObject *);
-extern void _PyPersist_SetATime(PyPersistObject *);
+extern PyObject *_PyPersist_Load(PyPersistBaseObject *);
+extern PyObject *_PyPersist_RegisterDataManager(PyPersistBaseObject *);
+extern void _PyPersist_SetATime(PyPersistBaseObject *);
/* A struct to encapsulation the PyPersist C API for use by other
dynamically load extensions.
@@ -54,8 +62,9 @@
typedef struct {
PyTypeObject *base_type;
- PyObject *(*load)(PyPersistObject *);
- PyObject *(*reg_mgr)(PyPersistObject *);
- void (*set_atime)(PyPersistObject *);
+ PyTypeObject *instance_type;
+ PyObject *(*load)(PyPersistBaseObject *);
+ PyObject *(*reg_mgr)(PyPersistBaseObject *);
+ void (*set_atime)(PyPersistBaseObject *);
} PyPersist_C_API_struct;
=== Zope3/lib/python/Persistence/cPersistenceAPI.h 1.5 => 1.6 ===
--- Zope3/lib/python/Persistence/cPersistenceAPI.h:1.5 Wed Oct 9 18:41:32 2002
+++ Zope3/lib/python/Persistence/cPersistenceAPI.h Thu Oct 10 04:20:06 2002
@@ -21,12 +21,13 @@
static PyPersist_C_API_struct *PyPersist_C_API;
-#define PyPersist_TYPE PyPersist_C_API->base_type
+#define PyPersist_BASE_TYPE PyPersist_C_API->base_type
+#define PyPersist_INSTANCE_TYPE PyPersist_C_API->instance_type
#define PyPersist_INCREF(O) \
if (((O)->po_state == UPTODATE) \
|| ((O)->po_state == GHOST \
- && PyPersist_C_API->load((PyPersistObject *)(O)))) \
+ && PyPersist_C_API->load((PyPersistBaseObject *)(O)))) \
(O)->po_state = STICKY;
#define PyPersist_DECREF(O) \
@@ -40,24 +41,24 @@
((O)->po_state == STICKY || (O)->po_state == CHANGED)
#define PyPersist_CHANGED(O) \
- PyPersist_C_API->reg_mgr((PyPersistObject *)(O))
+ PyPersist_C_API->reg_mgr((PyPersistBaseObject *)(O))
#define PyPersist_SetATime(O) \
- PyPersist_C_API->set_atime((PyPersistObject *)(O))
+ PyPersist_C_API->set_atime((PyPersistBaseObject *)(O))
/* Macros for compatibility with ZODB 3 C extensions. */
#define PER_USE_OR_RETURN(O, R) \
{ \
if (((O)->po_state == GHOST) \
- && (PyPersist_C_API->load((PyPersistObject *)(O)) < 0)) { \
+ && (PyPersist_C_API->load((PyPersistBaseObject *)(O)) < 0)) { \
(O)->po_state = STICKY; \
return (R); \
} else if ((O)->po_state == UPTODATE) \
(O)->po_state = STICKY; \
}
-#define PER_CHANGED(O) PyPersist_C_API->reg_mgr((PyPersistObject *)(O))
+#define PER_CHANGED(O) PyPersist_C_API->reg_mgr((PyPersistBaseObject *)(O))
#define PER_ALLOW_DEACTIVATION(O) \
{ \
@@ -72,9 +73,9 @@
}
#define PER_USE(O) \
- ((((PyPersistObject *)(O))->po_state != GHOST) \
- || (PyPersist_C_API->load((PyPersistObject *)(O)) >= 0) \
- ? ((((PyPersistObject *)(O))->po_state == UPTODATE) \
- ? (((PyPersistObject *)(O))->po_state = STICKY) : 1) : 0)
+ ((((PyPersistBaseObject *)(O))->po_state != GHOST) \
+ || (PyPersist_C_API->load((PyPersistBaseObject *)(O)) >= 0) \
+ ? ((((PyPersistBaseObject *)(O))->po_state == UPTODATE) \
+ ? (((PyPersistBaseObject *)(O))->po_state = STICKY) : 1) : 0)
-#define PER_ACCESSED(O) PyPersist_C_API->set_atime((PyPersistObject *)O)
+#define PER_ACCESSED(O) PyPersist_C_API->set_atime((PyPersistBaseObject *)O)