From 1a497776e60e5d9af72964d01ff47e5c3eb802e6 Mon Sep 17 00:00:00 2001 From: Michael Tremer Date: Tue, 16 Jan 2018 02:34:15 +0100 Subject: [PATCH] libpakfire: Make Pakfire the parent object of Relation Signed-off-by: Michael Tremer --- src/_pakfire/package.c | 30 +++++------ src/_pakfire/relation.c | 25 +++++---- src/_pakfire/selector.c | 14 ++--- src/_pakfire/selector.h | 5 +- src/libpakfire/include/pakfire/relation.h | 24 +++------ src/libpakfire/include/pakfire/relationlist.h | 17 ++----- src/libpakfire/libpakfire.sym | 8 +-- src/libpakfire/package.c | 31 +++++------ src/libpakfire/relation.c | 50 ++++++++++++++---- src/libpakfire/relationlist.c | 51 ++++++++++++++++--- 10 files changed, 146 insertions(+), 109 deletions(-) diff --git a/src/_pakfire/package.c b/src/_pakfire/package.c index 0aa303e2a..5d7530b4d 100644 --- 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 b0498fd1c..5085df62b 100644 --- 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 770e26141..52ee9e723 100644 --- a/src/_pakfire/selector.c +++ b/src/_pakfire/selector.c @@ -28,12 +28,12 @@ #include #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 577d83f71..dbeb8ffef 100644 --- a/src/_pakfire/selector.h +++ b/src/_pakfire/selector.h @@ -23,13 +23,10 @@ #include -#include - -#include "pool.h" +#include 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 9542a4a8b..9ab8ded1c 100644 --- a/src/libpakfire/include/pakfire/relation.h +++ b/src/libpakfire/include/pakfire/relation.h @@ -28,29 +28,17 @@ #include #include -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 55d89c560..5788411b7 100644 --- 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 - -#include -#include #include -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 304ad984c..4decbc1bb 100644 --- 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 59fda486e..5d8f41ade 100644 --- 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 0411395a5..0955e216b 100644 --- a/src/libpakfire/relation.c +++ b/src/libpakfire/relation.c @@ -24,13 +24,21 @@ #include #include +#include #include +#include #include #include #include #include #include +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 278ac394f..6b48ddc51 100644 --- a/src/libpakfire/relationlist.c +++ b/src/libpakfire/relationlist.c @@ -21,6 +21,8 @@ #include #include +#include +#include #include #include #include @@ -28,33 +30,66 @@ #include #include -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) { -- 2.39.5