python/python-apt.h: Introduce the C++ API

The C++ API provides support for creating Python objects from C++ objects
given by pointer or reference (depending on the implementation of the Python
object) and for retrieving the underlying C++ object from the Python object
and for checking the type of the Python object.

9 files changed, 360 insertions, 7 deletions

diff --git a/debian/changelog b/debian/changelog
index 4ae6e574..415ebdd2 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -3,6 +3,7 @@ python-apt (0.7.92) UNRELEASED; urgency=low
   [ Julian Andres Klode ]
   * Add apt_pkg.HashString and apt_pkg.IndexRecords (Closes: #456141)
   * Add apt_pkg.Policy class (Closes: #382725)
+  * Provide a C++ API in the package python-apt-dev (Closes: #334923)
   * Allow types providing __new__() to be subclassed.
   * Bugfix: Delete pointers correctly, fixing memory leaks. (LP: #370149)
   * apt/package.py: Return VersionList objects in Package.versions, which
diff --git a/debian/control b/debian/control
index 10b9bc31..a16ae10e 100644
--- a/debian/control
+++ b/debian/control
@@ -54,3 +54,14 @@ Description: Python interface to libapt-pkg (debug extension)
  variety of functions.
  .
  This package contains the extension built for the Python debug interpreter.
+
+Package: python-apt-dev
+Architecture: all
+Depends: python-apt (>= ${source:Version}), libapt-pkg-dev (>= 0.7.10)
+Description: Python interface to libapt-pkg (development files)
+ The apt_pkg Python interface will provide full access to the internal
+ libapt-pkg structures allowing Python programs to easily perform a
+ variety of functions.
+ .
+ This package contains the header files needed to use python-apt objects from
+ C++ applications.
diff --git a/debian/python-apt-dev.examples b/debian/python-apt-dev.examples
new file mode 100644
index 00000000..39f7bf97
--- /dev/null
+++ b/debian/python-apt-dev.examples
@@ -0,0 +1 @@
+doc/client-example.cc
diff --git a/debian/python-apt-dev.install b/debian/python-apt-dev.install
new file mode 100644
index 00000000..2a1405fd
--- /dev/null
+++ b/debian/python-apt-dev.install
@@ -0,0 +1,2 @@
+python/python-apt.h usr/include/python-apt/
+python/generic.h usr/include/python-apt/
diff --git a/doc/client-example.cc b/doc/client-example.cc
new file mode 100644
index 00000000..7fa6672f
--- /dev/null
+++ b/doc/client-example.cc
@@ -0,0 +1,46 @@
+/*
+ * client-example.cc - A simple example for using the python-apt C++ API.
+ *
+ * Copyright 2009 Julian Andres Klode <jak@debian.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#include <python-apt/python-apt.h>
+
+int main(int argc, char *argv[]) {
+    Py_Initialize();
+    if (import_apt_pkg() < 0)
+        return 1;
+
+    // Initialize a module.
+    PyObject *Module = Py_InitModule("client", NULL);
+
+    // Create a HashString, which will be added to the module.
+    HashString *hash = new HashString("0966a120bb936bdc6fdeac445707aa6b");
+    // Create a Python object for the hashstring and add it to the module
+    PyModule_AddObject(Module, "hash", PyHashString_FromCpp(hash));
+
+    // Another example: Add the HashString type to the module.
+    Py_INCREF(&PyHashString_Type);
+    PyModule_AddObject(Module, "HashString", (PyObject*)(&PyHashString_Type));
+
+    // Run IPython, adding the client module to the namespace.
+    PySys_SetArgv(argc, argv);
+    PyRun_SimpleString("from IPython.Shell import start\n");
+    PyRun_SimpleString("import client\n");
+    PyRun_SimpleString("start(user_ns=dict(client=client)).mainloop()\n");
+    Py_Finalize();
+}
diff --git a/python/apt_pkgmodule.cc b/python/apt_pkgmodule.cc
index e4fd0dfc..bc2f4258 100644
--- a/python/apt_pkgmodule.cc
+++ b/python/apt_pkgmodule.cc
@@ -498,6 +498,38 @@ static PyMethodDef methods[] =
    {}
 };
 
+static struct _PyAptPkgAPIStruct API = {
+   &PyAcquire_Type,           // acquire_type
+   &PyAcquireFile_Type,       // acquirefile_type
+   &PyAcquireItem_Type,       // acquireitem_type
+   &PyActionGroup_Type,       // actiongroup_type
+   &PyCache_Type,             // cache_type
+   &PyCacheFile_Type,          // cachefile_type
+   &PyCdrom_Type,             // cdrom_type
+   &PyConfiguration_Type,     // configuration_type
+   &PyDepCache_Type,          // depcache_type
+   &PyDependency_Type,        // dependency_type
+   &PyDependencyList_Type,    // dependencylist_type
+   &PyDescription_Type,       // description_type
+   &PyHashes_Type,            // hashes_type
+   &PyHashString_Type,        // hashstring_type
+   &PyIndexRecords_Type,      // indexrecords_type
+   &PyMetaIndex_Type,         // metaindex_type
+   &PyPackage_Type,           // package_type
+   &PyPackageFile_Type,       // packagefile_type
+   &PyPackageIndexFile_Type,  // packageindexfile_type
+   &PyPackageList_Type,       // packagelist_type
+   &PyPackageManager_Type,    // packagemanager_type
+   &PyPackageRecords_Type,    // packagerecords_type
+   &PyPolicy_Type,            // policy_type
+   &PyProblemResolver_Type,   // problemresolver_type
+   &PySourceList_Type,        // sourcelist_type
+   &PySourceRecords_Type,     // sourcerecords_type
+   &PyTagFile_Type,           // tagfile_type
+   &PyTagSection_Type,        // tagsection_type
+   &PyVersion_Type,           // version_type
+};
+
 
 #define ADDTYPE(mod,name,type) { \
     if (PyType_Ready(type) == -1) INIT_ERROR; \
@@ -596,6 +628,12 @@ extern "C" void initapt_pkg()
    PyModule_AddObject(Module,"REWRITE_SOURCE_ORDER",
                       CharCharToList(TFRewriteSourceOrder));
 
+#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 1
+   PyObject *PyCapsule = PyCapsule_New(&API, "apt_pkg._C_API", NULL);
+#else
+   PyObject *PyCapsule = PyCObject_FromVoidPtr(&API, NULL);
+#endif
+   PyModule_AddObject(Module, "_C_API", PyCapsule);
    // Version..
    PyModule_AddStringConstant(Module,"VERSION",(char *)pkgVersion);
    PyModule_AddStringConstant(Module,"LIB_VERSION",(char *)pkgLibVersion);
diff --git a/python/apt_pkgmodule.h b/python/apt_pkgmodule.h
index f77c5e73..97be5d5c 100644
--- a/python/apt_pkgmodule.h
+++ b/python/apt_pkgmodule.h
@@ -104,7 +104,6 @@ extern PyTypeObject PyPackageIndexFile_Type;
 extern PyTypeObject PyMetaIndex_Type;
 
 // HashString
-PyObject *PyHashString_FromCpp(HashString *obj);
 extern PyTypeObject PyHashString_Type;
 
 // IndexRecord
@@ -113,5 +112,6 @@ extern PyTypeObject PyIndexRecords_Type;
 // Policy
 extern PyTypeObject PyPolicy_Type;
 extern PyTypeObject PyHashes_Type;
-
+#include "python-apt.h"
 #endif
+
diff --git a/python/hashstring.cc b/python/hashstring.cc
index d303049a..b76dc127 100644
--- a/python/hashstring.cc
+++ b/python/hashstring.cc
@@ -39,11 +39,6 @@ static PyObject *HashString_NEW(PyTypeObject *type,PyObject *Args,
     return PyObj;
 }
 
-PyObject *PyHashString_FromCpp(HashString *obj)
-{
-    return CppPyObject_NEW<HashString*>(&PyHashString_Type, obj);
-}
-
 static PyObject *HashString_Repr(PyObject *self)
 {
     HashString *hash = GetCpp<HashString*>(self);
diff --git a/python/python-apt.h b/python/python-apt.h
new file mode 100644
index 00000000..557f5a3b
--- /dev/null
+++ b/python/python-apt.h
@@ -0,0 +1,259 @@
+/*
+ * python-apt.h - Header file for the public interface.
+ *
+ * Copyright 2009 Julian Andres Klode <jak@debian.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef PYTHON_APT_H
+#define PYTHON_APT_H
+#include <Python.h>
+#include <apt-pkg/hashes.h>
+#include "generic.h"
+
+struct _PyAptPkgAPIStruct {
+    PyTypeObject *acquire_type;
+    PyTypeObject *acquirefile_type;
+    PyTypeObject *acquireitem_type;
+    PyTypeObject *actiongroup_type;
+    PyTypeObject *cache_type;
+    PyTypeObject *cachefile_type;
+    PyTypeObject *cdrom_type;
+    PyTypeObject *configuration_type;
+    PyTypeObject *depcache_type;
+    PyTypeObject *dependency_type;
+    PyTypeObject *dependencylist_type;
+    PyTypeObject *description_type;
+    PyTypeObject *hashes_type;
+    PyTypeObject *hashstring_type;
+    PyTypeObject *indexrecords_type;
+    PyTypeObject *metaindex_type;
+    PyTypeObject *package_type;
+    PyTypeObject *packagefile_type;
+    PyTypeObject *packageindexfile_type;
+    PyTypeObject *packagelist_type;
+    PyTypeObject *packagemanager_type;
+    PyTypeObject *packagerecords_type;
+    PyTypeObject *policy_type;
+    PyTypeObject *problemresolver_type;
+    PyTypeObject *sourcelist_type;
+    PyTypeObject *sourcerecords_type;
+    PyTypeObject *tagfile_type;
+    PyTypeObject *tagsection_type;
+    PyTypeObject *version_type;
+};
+
+# ifndef APT_PKGMODULE_H
+#  define PyAcquire_Type           *(_PyAptPkg_API->acquire_type)
+#  define PyAcquireFile_Type       *(_PyAptPkg_API->acquirefile_type)
+#  define PyAcquireItem_Type       *(_PyAptPkg_API->acquireitem_type)
+#  define PyActionGroup_Type       *(_PyAptPkg_API->actiongroup_type)
+#  define PyCache_Type             *(_PyAptPkg_API->cache_type)
+#  define PyCacheFile_Type         *(_PyAptPkg_API->cachefile_type)
+#  define PyCdrom_Type             *(_PyAptPkg_API->cdrom_type)
+#  define PyConfiguration_Type     *(_PyAptPkg_API->configuration_type)
+#  define PyDepCache_Type          *(_PyAptPkg_API->depcache_type)
+#  define PyDependency_Type        *(_PyAptPkg_API->dependency_type)
+#  define PyDependencyList_Type    *(_PyAptPkg_API->dependencylist_type)
+#  define PyDescription_Type       *(_PyAptPkg_API->description_type)
+#  define PyHashes_Type            *(_PyAptPkg_API->hashes_type)
+#  define PyHashString_Type        *(_PyAptPkg_API->hashstring_type)
+#  define PyIndexRecords_Type      *(_PyAptPkg_API->indexrecords_type)
+#  define PyMetaIndex_Type         *(_PyAptPkg_API->metaindex_type)
+#  define PyPackage_Type           *(_PyAptPkg_API->package_type)
+#  define PyPackageFile_Type       *(_PyAptPkg_API->packagefile_type)
+#  define PyPackageIndexFile_Type  *(_PyAptPkg_API->packageindexfile_type)
+#  define PyPackageList_Type       *(_PyAptPkg_API->packagelist_type)
+#  define PyPackageManager_Type    *(_PyAptPkg_API->packagemanager_type)
+#  define PyPackageRecords_Type    *(_PyAptPkg_API->packagerecords_type)
+#  define PyPolicy_Type            *(_PyAptPkg_API->policy_type)
+#  define PyProblemResolver_Type   *(_PyAptPkg_API->problemresolver_type)
+#  define PySourceList_Type        *(_PyAptPkg_API->sourcelist_type)
+#  define PySourceRecords_Type     *(_PyAptPkg_API->sourcerecords_type)
+#  define PyTagFile_Type           *(_PyAptPkg_API->tagfile_type)
+#  define PyTagSection_Type        *(_PyAptPkg_API->tagsection_type)
+#  define PyVersion_Type           *(_PyAptPkg_API->version_type)
+
+// Creating
+
+static struct _PyAptPkgAPIStruct *_PyAptPkg_API;
+
+static int import_apt_pkg(void) {
+#  if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 1
+    _PyAptPkg_API = (_PyAptPkgAPIStruct *)PyCapsule_Import("apt_pkg._C_API", 0);
+    return (_PyAptPkg_API != NULL) ? 0 : -1;
+#  else
+
+    PyObject *module = PyImport_ImportModule("apt_pkg");
+
+    if (module == NULL) {
+        return -1;
+    }
+    if (module != NULL) {
+        PyObject *c_api_object = PyObject_GetAttrString(module, "_C_API");
+        if (c_api_object == NULL)
+            return -1;
+        if (PyCObject_Check(c_api_object))
+            _PyAptPkg_API = (struct _PyAptPkgAPIStruct *)PyCObject_AsVoidPtr(c_api_object);
+        Py_DECREF(c_api_object);
+    }
+    return 0;
+#  endif // PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 1
+}
+# endif // APT_PKGMODULE_H
+
+// Checking macros.
+# define PyAcquire_Check(op)          PyObject_TypeCheck(op, &PyAcquire_Type)
+# define PyAcquireFile_Check(op)      PyObject_TypeCheck(op, &PyAcquireFile_Type)
+# define PyAcquireItem_Check(op)      PyObject_TypeCheck(op, &PyAcquireItem_Type)
+# define PyActionGroup_Check(op)      PyObject_TypeCheck(op, &PyActionGroup_Type)
+# define PyCache_Check(op)            PyObject_TypeCheck(op, &PyCache_Type)
+# define PyCacheFile_Check(op)        PyObject_TypeCheck(op, &PyCacheFile_Type)
+# define PyCdrom_Check(op)            PyObject_TypeCheck(op, &PyCdrom_Type)
+# define PyConfiguration_Check(op)    PyObject_TypeCheck(op, &PyConfiguration_Type)
+# define PyDepCache_Check(op)         PyObject_TypeCheck(op, &PyDepCache_Type)
+# define PyDependency_Check(op)       PyObject_TypeCheck(op, &PyDependency_Type)
+# define PyDependencyList_Check(op)   PyObject_TypeCheck(op, &PyDependencyList_Type)
+# define PyDescription_Check(op)      PyObject_TypeCheck(op, &PyDescription_Type)
+# define PyHashes_Check(op)           PyObject_TypeCheck(op, &PyHashes_Type)
+# define PyHashString_Check(op)       PyObject_TypeCheck(op, &PyHashString_Type)
+# define PyIndexRecords_Check(op)     PyObject_TypeCheck(op, &PyIndexRecords_Type)
+# define PyMetaIndex_Check(op)        PyObject_TypeCheck(op, &PyMetaIndex_Type)
+# define PyPackage_Check(op)          PyObject_TypeCheck(op, &PyPackage_Type)
+# define PyPackageFile_Check(op)      PyObject_TypeCheck(op, &PyPackageFile_Type)
+# define PyPackageIndexFile_Check(op) PyObject_TypeCheck(op, &PyPackageIndexFile_Type)
+# define PyPackageList_Check(op)      PyObject_TypeCheck(op, &PyPackageList_Type)
+# define PyPackageManager_Check(op)   PyObject_TypeCheck(op, &PyPackageManager_Type)
+# define PyPackageRecords_Check(op)   PyObject_TypeCheck(op, &PyPackageRecords_Type)
+# define PyPolicy_Check(op)           PyObject_TypeCheck(op, &PyPolicy_Type)
+# define PyProblemResolver_Check(op)  PyObject_TypeCheck(op, &PyProblemResolver_Type)
+# define PySourceList_Check(op)       PyObject_TypeCheck(op, &PySourceList_Type)
+# define PySourceRecords_Check(op)    PyObject_TypeCheck(op, &PySourceRecords_Type)
+# define PyTagFile_Check(op)          PyObject_TypeCheck(op, &PyTagFile_Type)
+# define PyTagSection_Check(op)       PyObject_TypeCheck(op, &PyTagSection_Type)
+# define PyVersion_Check(op)          PyObject_TypeCheck(op, &PyVersion_Type)
+// Exact check macros.
+# define PyAcquire_CheckExact(op)          (Py_TYPE(op) == &PyAcquire_Type)
+# define PyAcquireFile_CheckExact(op)      (Py_TYPE(op) == &PyAcquireFile_Type)
+# define PyAcquireItem_CheckExact(op)      (Py_TYPE(op) == &PyAcquireItem_Type)
+# define PyActionGroup_CheckExact(op)      (Py_TYPE(op) == &PyActionGroup_Type)
+# define PyCache_CheckExact(op)            (Py_TYPE(op) == &PyCache_Type)
+# define PyCacheFile_CheckExact(op)        (Py_TYPE(op) == &PyCacheFile_Type)
+# define PyCdrom_CheckExact(op)            (Py_TYPE(op) == &PyCdrom_Type)
+# define PyConfiguration_CheckExact(op)    (Py_TYPE(op) == &PyConfiguration_Type)
+# define PyDepCache_CheckExact(op)         (Py_TYPE(op) == &PyDepCache_Type)
+# define PyDependency_CheckExact(op)       (Py_TYPE(op) == &PyDependency_Type)
+# define PyDependencyList_CheckExact(op)   (Py_TYPE(op) == &PyDependencyList_Type)
+# define PyDescription_CheckExact(op)      (Py_TYPE(op) == &PyDescription_Type)
+# define PyHashes_CheckExact(op)           (Py_TYPE(op) == &PyHashes_Type)
+# define PyHashString_CheckExact(op)       (Py_TYPE(op) == &PyHashString_Type)
+# define PyIndexRecords_CheckExact(op)     (Py_TYPE(op) == &PyIndexRecords_Type)
+# define PyMetaIndex_CheckExact(op)        (Py_TYPE(op) == &PyMetaIndex_Type)
+# define PyPackage_CheckExact(op)          (Py_TYPE(op) == &PyPackage_Type)
+# define PyPackageFile_CheckExact(op)      (Py_TYPE(op) == &PyPackageFile_Type)
+# define PyPackageIndexFile_CheckExact(op) (Py_TYPE(op) == &PyPackageIndexFile_Type)
+# define PyPackageList_CheckExact(op)      (Py_TYPE(op) == &PyPackageList_Type)
+# define PyPackageManager_CheckExact(op)   (Py_TYPE(op) == &PyPackageManager_Type)
+# define PyPackageRecords_CheckExact(op)   (Py_TYPE(op) == &PyPackageRecords_Type)
+# define PyPolicy_CheckExact(op)           (Py_TYPE(op) == &PyPolicy_Type)
+# define PyProblemResolver_CheckExact(op)  (Py_TYPE(op) == &PyProblemResolver_Type)
+# define PySourceList_CheckExact(op)       (Py_TYPE(op) == &PySourceList_Type)
+# define PySourceRecords_CheckExact(op)    (Py_TYPE(op) == &PySourceRecords_Type)
+# define PyTagFile_CheckExact(op)          (Py_TYPE(op) == &PyTagFile_Type)
+# define PyTagSection_CheckExact(op)       (Py_TYPE(op) == &PyTagSection_Type)
+# define PyVersion_CheckExact(op)          (Py_TYPE(op) == &PyVersion_Type)
+
+// Get the underlying C++ reference or pointer from the Python object.
+# define PyAcquire_ToCpp           GetCpp<pkgAcquire*>
+# define PyAcquireFile_ToCpp       GetCpp<pkgAcqFile*>
+# define PyAcquireItem_ToCpp       GetCpp<pkgAcquire::Item*>
+# define PyActionGroup_ToCpp       GetCpp<pkgDepCache::ActionGroup*>
+# define PyCache_ToCpp             GetCpp<pkgCache*>
+# define PyCacheFile_ToCpp         GetCpp<pkgCacheFile*>
+# define PyCdrom_ToCpp             GetCpp<pkgCdrom>
+# define PyConfiguration_ToCpp     GetCpp<Configuration*>
+# define PyDepCache_ToCpp          GetCpp<pkgDepCache*>
+# define PyDependency_ToCpp        GetCpp<pkgCache::DepIterator>
+//# define PyDependencyList_ToCpp    GetCpp<RDepListStruct> // NOT EXPORTED
+# define PyDescription_ToCpp       GetCpp<pkgCache::DescIterator>
+# define PyHashes_ToCpp            GetCpp<Hashes>
+# define PyHashString_ToCpp        GetCpp<HashString*>
+# define PyIndexRecords_ToCpp      GetCpp<indexRecords*>
+# define PyMetaIndex_ToCpp         GetCpp<metaIndex*>
+# define PyPackage_ToCpp           GetCpp<pkgCache::PkgIterator>
+# define PyPackageFile_ToCpp       GetCpp<pkgCache::PkgFileIterator>
+# define PyPackageIndexFile_ToCpp  GetCpp<pkgIndexFile*>
+//# define PyPackageList_ToCpp       GetCpp<PkgListStruct> // NOT EXPORTED.
+# define PyPackageManager_ToCpp    GetCpp<pkgPackageManager*>
+//# define PyPackageRecords_ToCpp    GetCpp<PkgRecordsStruct> // NOT EXPORTED
+# define PyPolicy_ToCpp            GetCpp<pkgPolicy*>
+# define PyProblemResolver_ToCpp   GetCpp<pkgProblemResolver*>
+# define PySourceList_ToCpp        GetCpp<pkgSourceList*>
+//# define PySourceRecords_ToCpp     GetCpp<PkgSrcRecordsStruct> // NOT EXPORTED
+# define PyTagFile_ToCpp           GetCpp<pkgTagFile>
+# define PyTagSection_ToCpp        GetCpp<pkgTagSection>
+# define PyVersion_ToCpp           GetCpp<pkgCache::VerIterator>
+
+// Python object creation, using two inline template functions and one variadic
+// macro per type.
+template<class Cpp>
+inline PyObject *FromCpp(PyTypeObject *pytype, Cpp obj, bool Delete=false)
+{
+    CppPyObject<Cpp> *Obj = CppPyObject_NEW<Cpp>(pytype, obj);
+    Obj->NoDelete = (!Delete);
+    return Obj;
+}
+
+template<class Cpp>
+inline PyObject *FromCppOwned(PyTypeObject *pytype, Cpp const &obj,
+                              bool Delete=false, PyObject *Owner=NULL)
+{
+    CppOwnedPyObject<Cpp> *Obj = CppOwnedPyObject_NEW<Cpp>(Owner, pytype, obj);
+    Obj->NoDelete = (!Delete);
+    return Obj;
+}
+
+# define PyAcquire_FromCpp(...)          FromCpp<pkgAcquire*>(&PyAcquire_Type, ##__VA_ARGS__)
+# define PyAcquireFile_FromCpp(...)      FromCppOwned<pkgAcqFile*>(&PyAcquireFile_Type, ##__VA_ARGS__)
+# define PyAcquireItem_FromCpp(...)      FromCppOwned<pkgAcquire::Item*>(&PyAcquireItemType,##__VA_ARGS__)
+# define PyActionGroup_FromCpp(...)      FromCppOwned<pkgDepCache::ActionGroup*>(&PyActionGroup_Type,##__VA_ARGS__)
+# define PyCache_FromCpp(...)            FromCppOwned<pkgCache*>(&PyCache_Type,##__VA_ARGS__)
+# define PyCacheFile_FromCpp(...)        FromCpp<pkgCacheFile*>(&PyCacheFile_Type,##__VA_ARGS__)
+# define PyCdrom_FromCpp(...)            FromCpp<pkgCdrom*>(&PyCdromType,##__VA_ARGS__)
+# define PyConfiguration_FromCpp(...)    FromCppOwned<Configuration*>(&PyConfiguration_Type, ##__VA_ARGS__)
+# define PyDepCache_FromCpp(...)         FromCppOwned<pkgDepCache*>(&PyDepCache_Type,##__VA_ARGS__)
+# define PyDependency_FromCpp(...)       FromCppOwned<pkgCache::DepIterator>(&PyDependency_Type,##__VA_ARGS__)
+//# define PyDependencyList_FromCpp(...)   FromCppOwned<RDepListStruct>(&PyDependencyList_Type,##__VA_ARGS__)
+# define PyDescription_FromCpp(...)      FromCppOwned<pkgCache::DescIterator>(&PyDescription_Type,##__VA_ARGS__)
+# define PyHashes_FromCpp(...)           FromCpp<Hashes>(&PyHashes_Type,##__VA_ARGS__)
+# define PyHashString_FromCpp(...)       FromCpp<HashString*>(&PyHashString_Type,##__VA_ARGS__)
+# define PyIndexRecords_FromCpp(...)     FromCpp<indexRecords*>(&PyIndexRecords_Type,##__VA_ARGS__)
+# define PyMetaIndex_FromCpp(...)        FromCppOwned<metaIndex*>(&PyMetaIndex_Type,##__VA_ARGS__)
+# define PyPackage_FromCpp(...)          FromCppOwned<pkgCache::PkgIterator>(&PyPackage_Type,##__VA_ARGS__)
+# define PyPackageIndexFile_FromCpp(...) FromCppOwned<pkgIndexFile*>(&PyPackageIndexFile_Type,##__VA_ARGS__)
+# define PyPackageFile_FromCpp(...)      FromCppOwned<pkgCache::PkgFileIterator>(&PyPackageFile_Type,##__VA_ARGS__)
+//# define PyPackageList_FromCpp(...)      FromCppOwned<PkgListStruct>(&PyPackageList_Type,##__VA_ARGS__)
+# define PyPackageManager_FromCpp(...)   FromCpp<pkgPackageManager*>(&PyPackageManagerType,##__VA_ARGS__)
+//# define PyPackageRecords_FromCpp(...)   FromCppOwned<PkgRecordsStruct>(&PyPackageRecords_Type,##__VA_ARGS__)
+# define PyPolicy_FromCpp(...)           FromCppOwned<pkgPolicy*>(&PyPolicy_Type,##__VA_ARGS__)
+# define PyProblemResolver_FromCpp(...)  FromCppOwned<pkgProblemResolver*>(&PyProblemResolver_Type,##__VA_ARGS__)
+# define PySourceList_FromCpp(...)       FromCpp<pkgSourceList*>(&PySourceList_Type,##__VA_ARGS__)
+//# define PySourceRecords_FromCpp(...)    FromCpp<PkgSrcRecordsStruct>(&PySourceRecords_Type,##__VA_ARGS__)
+//# define PyTagFile_FromCpp(...)          FromCppOwned<pkgTagFile>(&PyTagFile_Type,##__VA_ARGS__)
+# define PyTagSection_FromCpp(...)       FromCppOwned<pkgTagSection>(&PyTagSection_Type,##__VA_ARGS__)
+# define PyVersion_FromCpp(...)          FromCppOwned<pkgCache::VerIterator>(&PyVersion_Type,##__VA_ARGS__)
+#endif