Adding upstream version 2.7.6.upstream/2.7.6

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 188 insertions, 0 deletions

diff --git a/python/cachegroup.cc b/python/cachegroup.cc
new file mode 100644
index 0000000..4fc6c37
--- /dev/null
+++ b/python/cachegroup.cc
@@ -0,0 +1,188 @@
+/*
+ * cachegroup.cc - Wrapper around pkgCache::GrpIterator
+ *
+ * Copyright 2011 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.h>
+#include "apt_pkgmodule.h"
+#include "generic.h"
+#include <apt-pkg/pkgcache.h>
+
+struct PyGroup : CppPyObject<pkgCache::GrpIterator> {
+    pkgCache::PkgIterator current;
+    int nextIndex;
+};
+
+static PyObject *group_new(PyTypeObject *type,PyObject *args,
+                                  PyObject *kwds)
+{
+    PyObject *pyCache;
+    char *name;
+    char *kwlist[] = {"cache", "name", NULL};
+    if (PyArg_ParseTupleAndKeywords(args, kwds, "O!s", kwlist,
+                                    &PyCache_Type, &pyCache,
+                                    &name) == 0)
+        return 0;
+
+    pkgCache *cache = GetCpp<pkgCache *>(pyCache);
+
+    pkgCache::GrpIterator grp = cache->FindGrp(name);
+
+    if (!grp.end()) {
+        return PyGroup_FromCpp(grp, true, pyCache);
+    } else {
+        PyErr_SetString(PyExc_KeyError, name);
+        return NULL;
+    }
+}
+
+static const char group_find_package_doc[] =
+    "find_package(architecture: str) -> Package\n\n"
+    "Return a package for the given architecture, or None if none exists";
+static PyObject *group_find_package(PyObject *self,PyObject *args)
+{
+    pkgCache::GrpIterator grp = GetCpp<pkgCache::GrpIterator>(self);
+    PyObject *owner = GetOwner<pkgCache::GrpIterator>(self);
+    
+    char *architecture;
+    if (PyArg_ParseTuple(args, "s", &architecture) == 0)
+        return 0;
+
+    pkgCache::PkgIterator pkg = grp.FindPkg(architecture);
+
+    if (pkg.end()) {
+        Py_RETURN_NONE;
+    } else {
+        return PyPackage_FromCpp(pkg, true, owner ? owner : self);
+    }
+}
+
+static const char group_find_preferred_package_doc[] =
+    "find_preferred_package(prefer_non_virtual: bool = True) -> Package\n\n"
+    "Return a package for the best architecture, either the native one\n"
+    "or the first found one. If none exists, return None. If non_virtual\n"
+    "is True, prefer non-virtual packages over virtual ones.";
+static PyObject *group_find_preferred_package(PyObject *self,PyObject *args,
+                                              PyObject *kwds)
+{
+    pkgCache::GrpIterator grp = GetCpp<pkgCache::GrpIterator>(self);
+    PyObject *owner = GetOwner<pkgCache::GrpIterator>(self);
+    char nonvirtual = 1;
+    char *kwlist[] = {"prefer_non_virtual", NULL};
+    if (PyArg_ParseTupleAndKeywords(args, kwds, "|b", kwlist, &nonvirtual) == 0)
+        return 0;
+    pkgCache::PkgIterator pkg = grp.FindPreferredPkg(nonvirtual);
+
+    if (pkg.end()) {
+        Py_RETURN_NONE;
+    } else {
+        return PyPackage_FromCpp(pkg, true, owner);
+    }
+}
+
+static PyMethodDef group_methods[] = {
+    {"find_package",group_find_package,METH_VARARGS,group_find_package_doc},
+    {"find_preferred_package",(PyCFunction) group_find_preferred_package,
+     METH_VARARGS|METH_KEYWORDS,group_find_preferred_package_doc},
+    {}
+};
+
+static PyObject *group_seq_item(PyObject *pySelf,Py_ssize_t index)
+{
+    PyGroup *self = static_cast<PyGroup *>(pySelf);
+    pkgCache::GrpIterator grp = GetCpp<pkgCache::GrpIterator>(self);
+    PyObject *owner = GetOwner<pkgCache::GrpIterator>(self);
+
+    if (self->nextIndex > index || self->nextIndex == 0)  {
+        self->nextIndex = 1;
+        new (&self->current) pkgCache::PkgIterator(grp.PackageList());
+    }
+        
+    if (self->nextIndex != index + 1) {
+        while (self->nextIndex <= index && !self->current.end()) {
+            self->current = grp.NextPkg(self->current);
+            self->nextIndex++;
+        }
+    }
+
+    if (self->current.end())
+        return PyErr_Format(PyExc_IndexError, "Out of range: %zd", index);
+
+    return PyPackage_FromCpp(self->current, true, owner);
+}
+
+
+static PySequenceMethods group_as_sequence =
+{
+   0,
+   0,                // concat
+   0,                // repeat
+   group_seq_item,
+   0,                // slice
+   0,                // assign item
+   0                 // assign slice
+};
+
+
+static const char group_doc[] = "Group(cache, name)\n\n"
+    "Group of packages with the same name.\n\n"
+    "Provides access to all packages sharing a name. Can be used this\n"
+    "like a list, or by using the special find_*() methods. If you use\n"
+    "it as a sequence, make sure to access it linearly, as this uses a\n"
+    "linked list internally.";
+PyTypeObject PyGroup_Type = {
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
+    "apt_pkg.Group",                     // tp_name
+    sizeof(PyGroup),                     // tp_basicsize
+    0,                                   // tp_itemsize
+    // Methods
+    CppDealloc<pkgCache::GrpIterator>,   // tp_dealloc
+    0,                                   // tp_print
+    0,                                   // tp_getattr
+    0,                                   // tp_setattr
+    0,                                   // tp_compare
+    0,                                   // tp_repr
+    0,                                   // tp_as_number
+    &group_as_sequence,                  // tp_as_sequence
+    0,                                   // tp_as_mapping
+    0,                                   // tp_hash
+    0,                                   // tp_call
+    0,                                   // tp_str
+    0,                                   // tp_getattro
+    0,                                   // tp_setattro
+    0,                                   // tp_as_buffer
+    Py_TPFLAGS_DEFAULT,                  // tp_flags
+    group_doc,                           // tp_doc
+    0,                                   // tp_traverse
+    0,                                   // tp_clear
+    0,                                   // tp_richcompare
+    0,                                   // tp_weaklistoffset
+    0,                                   // tp_iter
+    0,                                   // tp_iternext
+    group_methods,                       // tp_methods
+    0,                                   // tp_members
+    0,                                   // 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
+    group_new,                           // tp_new
+};