libpakfire: Make Pakfire the parent object of Relation

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/_pakfire/package.c b/src/_pakfire/package.c
index 0aa303e2af9f6bb5a050444032e4bf9a9422f44e..5d7530b4dcb9f9d7dd02d0472a3f46aed91134c2 100644 (file)
--- a/src/_pakfire/package.c
+++ b/src/_pakfire/package.c
@@ -486,9 +486,9 @@ static PyObject* PyList_FromRelationList(PakfireObject* pakfire, PakfireRelation
 
        for (int i = 0; i < count; i++) {
                PakfireRelation relation = pakfire_relationlist_get_clone(relationlist, i);
-               PyObject* relation_obj = new_relation(pakfire, pakfire_relation_id(relation));
+               PyObject* relation_obj = new_relation(pakfire, pakfire_relation_get_id(relation));
 
-               pakfire_relation_free(relation);
+               pakfire_relation_unref(relation);
                if (relation_obj == NULL)
                        goto fail;
 
@@ -519,7 +519,7 @@ static PakfireRelationList PyList_AsRelationList(PakfireObject* pakfire, PyObjec
                PyObject* item = PySequence_GetItem(value, i);
 
                if (!PyObject_TypeCheck(item, &RelationType)) {
-                       pakfire_relationlist_free(relationlist);
+                       pakfire_relationlist_unref(relationlist);
                        Py_DECREF(item);
 
                        PyErr_SetString(PyExc_AttributeError, "Expected a Relation object");
@@ -539,7 +539,7 @@ static PyObject* Package_get_provides(PackageObject* self) {
        PakfireRelationList relationlist = pakfire_package_get_provides(self->package);
 
        PyObject* list = PyList_FromRelationList(self->pakfire, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return list;
 }
@@ -550,7 +550,7 @@ static int Package_set_provides(PackageObject* self, PyObject* value) {
                return -1;
 
        pakfire_package_set_provides(self->package, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return 0;
 }
@@ -570,7 +570,7 @@ static PyObject* Package_get_requires(PackageObject* self) {
        PakfireRelationList relationlist = pakfire_package_get_requires(self->package);
 
        PyObject* list = PyList_FromRelationList(self->pakfire, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return list;
 }
@@ -581,7 +581,7 @@ static int Package_set_requires(PackageObject* self, PyObject* value) {
                return -1;
 
        pakfire_package_set_requires(self->package, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return 0;
 }
@@ -601,7 +601,7 @@ static PyObject* Package_get_obsoletes(PackageObject* self) {
        PakfireRelationList relationlist = pakfire_package_get_obsoletes(self->package);
 
        PyObject* list = PyList_FromRelationList(self->pakfire, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return list;
 }
@@ -612,7 +612,7 @@ static int Package_set_obsoletes(PackageObject* self, PyObject* value) {
                return -1;
 
        pakfire_package_set_obsoletes(self->package, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return 0;
 }
@@ -632,7 +632,7 @@ static PyObject* Package_get_conflicts(PackageObject* self) {
        PakfireRelationList relationlist = pakfire_package_get_conflicts(self->package);
 
        PyObject* list = PyList_FromRelationList(self->pakfire, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return list;
 }
@@ -643,7 +643,7 @@ static int Package_set_conflicts(PackageObject* self, PyObject* value) {
                return -1;
 
        pakfire_package_set_conflicts(self->package, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return 0;
 }
@@ -663,7 +663,7 @@ static PyObject* Package_get_recommends(PackageObject* self) {
        PakfireRelationList relationlist = pakfire_package_get_recommends(self->package);
 
        PyObject* list = PyList_FromRelationList(self->pakfire, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return list;
 }
@@ -674,7 +674,7 @@ static int Package_set_recommends(PackageObject* self, PyObject* value) {
                return -1;
 
        pakfire_package_set_recommends(self->package, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return 0;
 }
@@ -694,7 +694,7 @@ static PyObject* Package_get_suggests(PackageObject* self) {
        PakfireRelationList relationlist = pakfire_package_get_suggests(self->package);
 
        PyObject* list = PyList_FromRelationList(self->pakfire, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return list;
 }
@@ -705,7 +705,7 @@ static int Package_set_suggests(PackageObject* self, PyObject* value) {
                return -1;
 
        pakfire_package_set_suggests(self->package, relationlist);
-       pakfire_relationlist_free(relationlist);
+       pakfire_relationlist_unref(relationlist);
 
        return 0;
 }

diff --git a/src/_pakfire/relation.c b/src/_pakfire/relation.c
index b0498fd1c942b396e6caff9abd6900a5aa316bab..5085df62bdc16be9237a3ca464222c5360924189 100644 (file)
--- a/src/_pakfire/relation.c
+++ b/src/_pakfire/relation.c
@@ -29,15 +29,13 @@
 #include "package.h"
 #include "relation.h"
 
-static RelationObject* Relation_new_core(PyTypeObject* type, PoolObject* pool) {
+static RelationObject* Relation_new_core(PyTypeObject* type, PakfireObject* pakfire) {
        RelationObject* self = (RelationObject *)type->tp_alloc(type, 0);
        if (!self)
                return NULL;
 
-       if (pool) {
-               self->pool = pool;
-               Py_INCREF(self->pool);
-       }
+       self->pakfire = pakfire;
+       Py_INCREF(self->pakfire);
 
        self->relation = NULL;
 
@@ -58,27 +56,28 @@ static PyObject* Relation_new(PyTypeObject* type, PyObject* args, PyObject* kwds
 }
 
 static void Relation_dealloc(RelationObject* self) {
-       if (self->relation)
-               pakfire_relation_free(self->relation);
+       pakfire_relation_unref(self->relation);
 
        Py_XDECREF(self->pool);
        Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int Relation_init(RelationObject* self, PyObject* args, PyObject* kwds) {
-       PyObject* pool;
+       PakfireObject* pakfire;
        const char* name;
        const char* evr = NULL;
        int cmp_type = 0;
 
-       if (!PyArg_ParseTuple(args, "O!s|is", &PoolType, &pool, &name, &cmp_type, &evr))
+       if (!PyArg_ParseTuple(args, "O!s|is", &PakfireType, &pakfire, &name, &cmp_type, &evr))
                return -1;
 
-       self->pool = (PoolObject *)pool;
-       Py_INCREF(self->pool);
+       self->pakfire = pakfire;
+       Py_INCREF(self->pakfire);
 
-       self->relation = pakfire_relation_create(self->pool->pool, name, cmp_type, evr);
+       self->relation = pakfire_relation_create(self->pakfire->pakfire, name, cmp_type, evr);
        if (!self->relation) {
+               Py_DECREF(self->pakfire);
+
                PyErr_Format(PyExc_ValueError, "No such relation: %s", name);
                return -1;
        }
@@ -87,7 +86,7 @@ static int Relation_init(RelationObject* self, PyObject* args, PyObject* kwds) {
 }
 
 static long Relation_hash(RelationObject* self) {
-       return pakfire_relation_id(self->relation);
+       return pakfire_relation_get_id(self->relation);
 }
 
 static PyObject* Relation_repr(RelationObject* self) {

diff --git a/src/_pakfire/selector.c b/src/_pakfire/selector.c
index 770e26141f887362083289def6dd7a215eba1154..52ee9e72310daf9554c27510f16d86c86cc68599 100644 (file)
--- a/src/_pakfire/selector.c
+++ b/src/_pakfire/selector.c
@@ -28,12 +28,12 @@
 #include <pakfire/types.h>
 
 #include "package.h"
+#include "pakfire.h"
 #include "selector.h"
 
 static PyObject* Selector_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
        SelectorObject* self = (SelectorObject *)type->tp_alloc(type, 0);
        if (self) {
-               self->pool = NULL;
                self->selector = NULL;
        }
 
@@ -43,20 +43,16 @@ static PyObject* Selector_new(PyTypeObject* type, PyObject* args, PyObject* kwds
 static void Selector_dealloc(SelectorObject* self) {
        pakfire_selector_unref(self->selector);
 
-       Py_XDECREF(self->pool);
        Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 static int Selector_init(SelectorObject* self, PyObject* args, PyObject* kwds) {
-       PyObject* pool;
+       PakfireObject* pakfire;
 
-       if (!PyArg_ParseTuple(args, "O!", &PoolType, &pool))
+       if (!PyArg_ParseTuple(args, "O!", &PakfireType, &pakfire))
                return -1;
 
-       self->pool = (PoolObject *)pool;
-       Py_INCREF(self->pool);
-
-       self->selector = pakfire_selector_create(self->pool->pool);
+       self->selector = pakfire_selector_create(pakfire->pakfire);
 
        return 0;
 }
@@ -88,7 +84,7 @@ static PyObject* Selector_get_providers(SelectorObject* self) {
        for (unsigned int i = 0; i < pakfire_packagelist_count(packagelist); i++) {
                PakfirePackage package = pakfire_packagelist_get(packagelist, i);
 
-               PyObject* obj = new_package(self->pool, pakfire_package_id(package));
+               PyObject* obj = new_package(NULL, pakfire_package_id(package));
                PyList_Append(list, obj);
 
                pakfire_package_unref(package);

diff --git a/src/_pakfire/selector.h b/src/_pakfire/selector.h
index 577d83f7120327b001e0ca442c20cbe6a1cd9615..dbeb8ffef8d41a131422ea9c83769d24b49b0c7f 100644 (file)
--- a/src/_pakfire/selector.h
+++ b/src/_pakfire/selector.h
@@ -23,13 +23,10 @@
 
 #include <Python.h>
 
-#include <pakfire/selector.h>
-
-#include "pool.h"
+#include <pakfire/types.h>
 
 typedef struct {
     PyObject_HEAD
-    PoolObject* pool;
     PakfireSelector selector;
 } SelectorObject;
 

diff --git a/src/libpakfire/include/pakfire/relation.h b/src/libpakfire/include/pakfire/relation.h
index 9542a4a8bd599d1894d583cd84618c57c567ae08..9ab8ded1c981293418acd439aa0e157ccc61bb59 100644 (file)
--- a/src/libpakfire/include/pakfire/relation.h
+++ b/src/libpakfire/include/pakfire/relation.h
@@ -28,29 +28,17 @@
 #include <pakfire/pool.h>
 #include <pakfire/types.h>
 
-PakfireRelation pakfire_relation_create(PakfirePool pool, const char* name, int cmp_type, const char* evr);
-PakfireRelation pakfire_relation_create_from_id(PakfirePool pool, Id id);
-void pakfire_relation_free(PakfireRelation relation);
+PakfireRelation pakfire_relation_create(Pakfire pakfire, const char* name, int cmp_type, const char* evr);
+PakfireRelation pakfire_relation_create_from_id(Pakfire pakfire, Id id);
 
-Id pakfire_relation_id(PakfireRelation relation);
+PakfireRelation pakfire_relation_ref(PakfireRelation relation);
+PakfireRelation pakfire_relation_unref(PakfireRelation relation);
+
+Id pakfire_relation_get_id(PakfireRelation relation);
 char* pakfire_relation_str(PakfireRelation relation);
 
 PakfirePackageList pakfire_relation_providers(PakfireRelation relation);
 
 int pakfire_relation2queue(const PakfireRelation relation, Queue* queue, int solver_action);
 
-#ifdef PAKFIRE_PRIVATE
-
-struct _PakfireRelation {
-       Pakfire pakfire;
-       PakfirePool pool;
-       Id id;
-};
-
-static inline Pool* pakfire_relation_solv_pool(PakfireRelation relation) {
-       return pakfire_pool_get_solv_pool(relation->pool);
-}
-
-#endif
-
 #endif /* PAKFIRE_RELATION_H */

diff --git a/src/libpakfire/include/pakfire/relationlist.h b/src/libpakfire/include/pakfire/relationlist.h
index 55d89c560d5a831fd5067eb881a8d56002c0f0d8..5788411b799d357e928cb085874de2620e2f30cc 100644 (file)
--- a/src/libpakfire/include/pakfire/relationlist.h
+++ b/src/libpakfire/include/pakfire/relationlist.h
@@ -21,14 +21,12 @@
 #ifndef PAKFIRE_RELATIONLIST_H
 #define PAKFIRE_RELATIONLIST_H
 
-#include <solv/queue.h>
-
-#include <pakfire/pool.h>
-#include <pakfire/relation.h>
 #include <pakfire/types.h>
 
-PakfireRelationList pakfire_relationlist_create(PakfirePool pool);
-void pakfire_relationlist_free(PakfireRelationList reldeplist);
+PakfireRelationList pakfire_relationlist_create(Pakfire pakfire);
+
+PakfireRelationList pakfire_relationlist_ref(PakfireRelationList relationlist);
+PakfireRelationList pakfire_relationlist_unref(PakfireRelationList relationlist);
 
 void pakfire_relationlist_add(PakfireRelationList relationlist, PakfireRelation relation);
 int pakfire_relationlist_count(PakfireRelationList relationlist);
@@ -37,12 +35,7 @@ PakfireRelation pakfire_relationlist_get_clone(PakfireRelationList relationlist,
 
 #ifdef PAKFIRE_PRIVATE
 
-struct _PakfireRelationList {
-       PakfirePool pool;
-       Queue queue;
-};
-
-PakfireRelationList pakfire_relationlist_from_queue(PakfirePool pool, Queue q);
+PakfireRelationList pakfire_relationlist_from_queue(Pakfire pakfire, Queue q);
 void pakfire_relationlist_clone_to_queue(PakfireRelationList relationlist, Queue* q);
 
 #endif

diff --git a/src/libpakfire/libpakfire.sym b/src/libpakfire/libpakfire.sym
index 304ad984ccf3252d08d02bef3274ea0cbcc983ca..4decbc1bb8db108c66d39eeec77e617199e98fee 100644 (file)
--- a/src/libpakfire/libpakfire.sym
+++ b/src/libpakfire/libpakfire.sym
@@ -258,17 +258,19 @@ global:
        # relation
        pakfire_relation_create;
        pakfire_relation_create_from_id;
-       pakfire_relation_free;
-       pakfire_relation_id;
+       pakfire_relation_get_id;
        pakfire_relation_providers;
+       pakfire_relation_ref;
        pakfire_relation_str;
+       pakfire_relation_unref;
 
        # relationlist
        pakfire_relationlist_add;
        pakfire_relationlist_count;
        pakfire_relationlist_create;
-       pakfire_relationlist_free;
        pakfire_relationlist_get_clone;
+       pakfire_relationlist_ref;
+       pakfire_relationlist_unref;
 
        # request
        pakfire_request_create;

diff --git a/src/libpakfire/package.c b/src/libpakfire/package.c
index 59fda486e7dca6bc0336c3ea8f847e6ad462fff8..5d8f41ade354a2c2fcd2e092144fb5675f7d7bbd 100644 (file)
--- a/src/libpakfire/package.c
+++ b/src/libpakfire/package.c
@@ -64,13 +64,11 @@ static Pool* pakfire_package_get_solv_pool(PakfirePackage pkg) {
 }
 
 static void pakfire_package_add_self_provides(Pakfire pakfire, PakfirePackage pkg, const char* name, const char* evr) {
-       PakfirePool pool = pakfire_get_pool(pakfire);
+       PakfireRelation relation = pakfire_relation_create(pakfire, name, PAKFIRE_EQ, evr);
 
-       PakfireRelation relation = pakfire_relation_create(pool, name, PAKFIRE_EQ, evr);
        pakfire_package_add_provides(pkg, relation);
 
-       pakfire_relation_free(relation);
-       pakfire_pool_unref(pool);
+       pakfire_relation_unref(relation);
 }
 
 PAKFIRE_EXPORT PakfirePackage pakfire_package_create(Pakfire pakfire, Id id) {
@@ -527,10 +525,7 @@ static PakfireRelationList pakfire_package_get_relationlist(PakfirePackage pkg,
        Solvable* s = get_solvable(pkg);
        solvable_lookup_idarray(s, type, &q);
 
-       PakfirePool pool = pakfire_get_pool(pkg->pakfire);
-       PakfireRelationList relationlist = pakfire_relationlist_from_queue(pool, q);
-       pakfire_pool_unref(pool);
-
+       PakfireRelationList relationlist = pakfire_relationlist_from_queue(pkg->pakfire, q);
        queue_free(&q);
 
        return relationlist;
@@ -554,16 +549,16 @@ static void pakfire_package_set_relationlist(PakfirePackage pkg, Id type, Pakfir
        int count = pakfire_relationlist_count(relationlist);
        for (int i = 0; i < count; i++) {
                PakfireRelation relation = pakfire_relationlist_get_clone(relationlist, i);
-               solvable_add_idarray(s, type, relation->id);
+               solvable_add_idarray(s, type, pakfire_relation_get_id(relation));
 
-               pakfire_relation_free(relation);
+               pakfire_relation_unref(relation);
        }
 }
 
 static void pakfire_package_add_relation(PakfirePackage pkg, Id type, PakfireRelation relation) {
        Solvable* s = get_solvable(pkg);
 
-       solvable_add_idarray(s, type, relation->id);
+       solvable_add_idarray(s, type, pakfire_relation_get_id(relation));
 }
 
 PAKFIRE_EXPORT PakfireRelationList pakfire_package_get_provides(PakfirePackage pkg) {
@@ -710,7 +705,7 @@ static void pakfire_package_dump_add_line_relations(char** str, const char* key,
 
                if (relation) {
                        char* dep = pakfire_relation_str(relation);
-                       pakfire_relation_free(relation);
+                       pakfire_relation_unref(relation);
 
                        // Stop here and don't list any files.
                        if (strcmp(PAKFIRE_SOLVABLE_FILEMARKER, dep) == 0)
@@ -814,37 +809,37 @@ PAKFIRE_EXPORT char* pakfire_package_dump(PakfirePackage pkg, int flags) {
                PakfireRelationList provides = pakfire_package_get_provides(pkg);
                if (provides) {
                        pakfire_package_dump_add_line_relations(&string, _("Provides"), provides);
-                       pakfire_relationlist_free(provides);
+                       pakfire_relationlist_unref(provides);
                }
 
                PakfireRelationList requires = pakfire_package_get_requires(pkg);
                if (requires) {
                        pakfire_package_dump_add_line_relations(&string, _("Requires"), requires);
-                       pakfire_relationlist_free(requires);
+                       pakfire_relationlist_unref(requires);
                }
 
                PakfireRelationList conflicts = pakfire_package_get_conflicts(pkg);
                if (conflicts) {
                        pakfire_package_dump_add_line_relations(&string, _("Conflicts"), conflicts);
-                       pakfire_relationlist_free(conflicts);
+                       pakfire_relationlist_unref(conflicts);
                }
 
                PakfireRelationList obsoletes = pakfire_package_get_obsoletes(pkg);
                if (obsoletes) {
                        pakfire_package_dump_add_line_relations(&string, _("Obsoletes"), obsoletes);
-                       pakfire_relationlist_free(obsoletes);
+                       pakfire_relationlist_unref(obsoletes);
                }
 
                PakfireRelationList recommends = pakfire_package_get_recommends(pkg);
                if (recommends) {
                        pakfire_package_dump_add_line_relations(&string, _("Recommends"), recommends);
-                       pakfire_relationlist_free(recommends);
+                       pakfire_relationlist_unref(recommends);
                }
 
                PakfireRelationList suggests = pakfire_package_get_suggests(pkg);
                if (suggests) {
                        pakfire_package_dump_add_line_relations(&string, _("Suggests"), suggests);
-                       pakfire_relationlist_free(suggests);
+                       pakfire_relationlist_unref(suggests);
                }
        }
 

diff --git a/src/libpakfire/relation.c b/src/libpakfire/relation.c
index 0411395a58a1c99d56a9a212ccf0d8c952e8ec0e..0955e216bb5e979f845c69fe04c97069dd0f4de2 100644 (file)
--- a/src/libpakfire/relation.c
+++ b/src/libpakfire/relation.c
@@ -24,13 +24,21 @@
 #include <solv/queue.h>
 #include <solv/solver.h>
 
+#include <pakfire/logging.h>
 #include <pakfire/packagelist.h>
+#include <pakfire/pakfire.h>
 #include <pakfire/pool.h>
 #include <pakfire/private.h>
 #include <pakfire/relation.h>
 #include <pakfire/types.h>
 #include <pakfire/util.h>
 
+struct _PakfireRelation {
+       Pakfire pakfire;
+       Id id;
+       int nrefs;
+};
+
 static int cmptype2relflags(int type) {
        int flags = 0;
 
@@ -44,8 +52,8 @@ static int cmptype2relflags(int type) {
        return flags;
 }
 
-PAKFIRE_EXPORT PakfireRelation pakfire_relation_create(PakfirePool pool, const char* name, int cmp_type, const char* evr) {
-       Pool* p = pakfire_pool_get_solv_pool(pool);
+PAKFIRE_EXPORT PakfireRelation pakfire_relation_create(Pakfire pakfire, const char* name, int cmp_type, const char* evr) {
+       Pool* p = pakfire_get_solv_pool(pakfire);
 
        Id id = pool_str2id(p, name, 1);
 
@@ -60,28 +68,52 @@ PAKFIRE_EXPORT PakfireRelation pakfire_relation_create(PakfirePool pool, const c
                id = pool_rel2id(p, id, ievr, flags, 1);
        }
 
-       return pakfire_relation_create_from_id(pool, id);
+       return pakfire_relation_create_from_id(pakfire, id);
 }
 
-PAKFIRE_EXPORT PakfireRelation pakfire_relation_create_from_id(PakfirePool pool, Id id) {
+PAKFIRE_EXPORT PakfireRelation pakfire_relation_create_from_id(Pakfire pakfire, Id id) {
        PakfireRelation relation = pakfire_calloc(1, sizeof(*relation));
+       if (relation) {
+               DEBUG("Allocated Relation at %p\n", relation);
+               relation->nrefs = 1;
+
+               relation->pakfire = pakfire_ref(pakfire);
+               relation->id = id;
+       }
+
+       return relation;
+}
 
-       relation->pool = pool;
-       relation->id = id;
+PAKFIRE_EXPORT PakfireRelation pakfire_relation_ref(PakfireRelation relation) {
+       relation->nrefs++;
 
        return relation;
 }
 
-PAKFIRE_EXPORT void pakfire_relation_free(PakfireRelation relation) {
+static void pakfire_relation_free(PakfireRelation relation) {
+       pakfire_unref(relation->pakfire);
        pakfire_free(relation);
+
+       DEBUG("Released Relation at %p\n", relation);
+}
+
+PAKFIRE_EXPORT PakfireRelation pakfire_relation_unref(PakfireRelation relation) {
+       if (!relation)
+               return NULL;
+
+       if (--relation->nrefs > 0)
+               return relation;
+
+       pakfire_relation_free(relation);
+       return NULL;
 }
 
-PAKFIRE_EXPORT Id pakfire_relation_id(PakfireRelation relation) {
+PAKFIRE_EXPORT Id pakfire_relation_get_id(PakfireRelation relation) {
        return relation->id;
 }
 
 PAKFIRE_EXPORT char* pakfire_relation_str(PakfireRelation relation) {
-       Pool* pool = pakfire_relation_solv_pool(relation);
+       Pool* pool = pakfire_get_solv_pool(relation->pakfire);
 
        const char* str = pool_dep2str(pool, relation->id);
 

diff --git a/src/libpakfire/relationlist.c b/src/libpakfire/relationlist.c
index 278ac394f85f6e7f45781692b7fa40aebe4117b9..6b48ddc51cb6c026e62bf9f32acb076f822c5791 100644 (file)
--- a/src/libpakfire/relationlist.c
+++ b/src/libpakfire/relationlist.c
@@ -21,6 +21,8 @@
 #include <solv/pooltypes.h>
 #include <solv/queue.h>
 
+#include <pakfire/logging.h>
+#include <pakfire/pakfire.h>
 #include <pakfire/pool.h>
 #include <pakfire/private.h>
 #include <pakfire/relation.h>
@@ -28,33 +30,66 @@
 #include <pakfire/types.h>
 #include <pakfire/util.h>
 
-PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_create(PakfirePool pool) {
+struct _PakfireRelationList {
+       Pakfire pakfire;
+       Queue queue;
+       int nrefs;
+};
+
+PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_create(Pakfire pakfire) {
        PakfireRelationList relationlist = pakfire_calloc(1, sizeof(*relationlist));
        if (relationlist) {
-               relationlist->pool = pool;
+               DEBUG("Allocated RelationList at %p\n", relationlist);
+               relationlist->nrefs = 1;
+
+               relationlist->pakfire = pakfire_ref(pakfire);
                queue_init(&relationlist->queue);
        }
 
        return relationlist;
 }
 
-PAKFIRE_EXPORT void pakfire_relationlist_free(PakfireRelationList relationlist) {
+PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_ref(PakfireRelationList relationlist) {
+       relationlist->nrefs++;
+
+       return relationlist;
+}
+
+static void pakfire_relationlist_free(PakfireRelationList relationlist) {
        queue_free(&relationlist->queue);
+
+       pakfire_unref(relationlist->pakfire);
        pakfire_free(relationlist);
+
+       DEBUG("Released RelationList at %p\n", relationlist);
+}
+
+PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_unref(PakfireRelationList relationlist) {
+       if (!relationlist)
+               return NULL;
+
+       if (--relationlist->nrefs > 0)
+               return relationlist;
+
+       pakfire_relationlist_free(relationlist);
+       return NULL;
 }
 
 PAKFIRE_EXPORT void pakfire_relationlist_add(PakfireRelationList relationlist, PakfireRelation relation) {
-       queue_push(&relationlist->queue, relation->id);
+       queue_push(&relationlist->queue, pakfire_relation_get_id(relation));
 }
 
 PAKFIRE_EXPORT int pakfire_relationlist_count(PakfireRelationList relationlist) {
        return relationlist->queue.count;
 }
 
-PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_from_queue(PakfirePool pool, Queue q) {
-       PakfireRelationList relationlist = pakfire_calloc(1, sizeof(*relationlist));
+PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_from_queue(Pakfire pakfire, Queue q) {
+       PakfireRelationList relationlist = pakfire_relationlist_create(pakfire);
        if (relationlist) {
-               relationlist->pool = pool;
+               // Release old queue
+               queue_free(&relationlist->queue);
+
+               // Copy the queue
                queue_init_clone(&relationlist->queue, &q);
        }
 
@@ -64,7 +99,7 @@ PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_from_queue(PakfirePool p
 PAKFIRE_EXPORT PakfireRelation pakfire_relationlist_get_clone(PakfireRelationList relationlist, int index) {
        Id id = relationlist->queue.elements[index];
 
-       return pakfire_relation_create_from_id(relationlist->pool, id);
+       return pakfire_relation_create_from_id(relationlist->pakfire, id);
 }
 
 PAKFIRE_EXPORT void pakfire_relationlist_clone_to_queue(PakfireRelationList relationlist, Queue* q) {