relationlist: Refactor create

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

diff --git a/src/_pakfire/package.c b/src/_pakfire/package.c
index df1ff161d328514fe7a82c2bb22f9e16db771942..3a7a09f3cfc393ca42e3047eefd7371c8cb15202 100644 (file)
--- a/src/_pakfire/package.c
+++ b/src/_pakfire/package.c
@@ -492,7 +492,11 @@ static PakfireRelationList PyList_AsRelationList(Pakfire pakfire, PyObject* valu
        }
 
        const int length = PySequence_Length(value);
-       PakfireRelationList relationlist = pakfire_relationlist_create(pakfire);
+       PakfireRelationList relationlist;
+
+       int r = pakfire_relationlist_create(&relationlist, pakfire);
+       if (r)
+               return NULL;
 
        for (int i = 0; i < length; i++) {
                PyObject* item = PySequence_GetItem(value, i);

diff --git a/src/libpakfire/archive.c b/src/libpakfire/archive.c
index 19c2891b59a1b8fa644b4f3e9cd24cfa4e54b02d..4c34b8592a825fdb2f27ee4eeee3d3e0684083eb 100644 (file)
--- a/src/libpakfire/archive.c
+++ b/src/libpakfire/archive.c
@@ -1373,61 +1373,47 @@ PAKFIRE_EXPORT PakfirePackage pakfire_archive_make_package(PakfireArchive archiv
        }
 
        // Relations
-
        PakfireRelationList l;
 
-       char* prerequires = pakfire_archive_get(archive, "dependencies.prerequires");
-       if (prerequires) {
-               l = pakfire_relationlist_create_from_string(archive->pakfire, prerequires);
-               pakfire_package_set_prerequires(pkg, l);
-               pakfire_relationlist_unref(l);
-               pakfire_free(prerequires);
-       }
-
-       char* requires = pakfire_archive_get(archive, "dependencies.requires");
-       if (requires) {
-               l = pakfire_relationlist_create_from_string(archive->pakfire, requires);
-               pakfire_package_set_requires(pkg, l);
-               pakfire_relationlist_unref(l);
-               pakfire_free(requires);
-       }
+       const struct __relation {
+               const char* type;
+               void (*func)(PakfirePackage, PakfireRelationList);
+       } relations[] = {
+               { "dependencies.provides", pakfire_package_set_provides },
+               { "dependencies.prerequires", pakfire_package_set_prerequires },
+               { "dependencies.requires", pakfire_package_set_requires },
+               { "dependencies.conflicts", pakfire_package_set_conflicts },
+               { "dependencies.obsoletes", pakfire_package_set_obsoletes },
+               { "dependencies.recommends", pakfire_package_set_recommends },
+               { "dependencies.suggests", pakfire_package_set_suggests },
+               { NULL, NULL },
+       };
+
+       for (const struct __relation* relation = relations; relation->type; relation++) {
+               char* relations = pakfire_archive_get(archive, relation->type);
+               if (!relations)
+                       continue;
 
-       char* provides = pakfire_archive_get(archive, "dependencies.provides");
-       if (provides) {
-               l = pakfire_relationlist_create_from_string(archive->pakfire, provides);
-               pakfire_package_set_provides(pkg, l);
-               pakfire_relationlist_unref(l);
-               pakfire_free(provides);
-       }
+               // Parse all relations
+               int r = pakfire_relationlist_create_from_string(&l, archive->pakfire, relations);
+               if (r)
+                       goto ERROR;
 
-       char* obsoletes = pakfire_archive_get(archive, "dependencies.obsoletes");
-       if (obsoletes) {
-               l = pakfire_relationlist_create_from_string(archive->pakfire, obsoletes);
-               pakfire_package_set_obsoletes(pkg, l);
-               pakfire_relationlist_unref(l);
-               pakfire_free(obsoletes);
-       }
+               free(relations);
 
-       char* recommends = pakfire_archive_get(archive, "dependencies.recommends");
-       if (recommends) {
-               l = pakfire_relationlist_create_from_string(archive->pakfire, recommends);
-               pakfire_package_set_recommends(pkg, l);
-               pakfire_relationlist_unref(l);
-               pakfire_free(recommends);
-       }
+               // Assign to package
+               relation->func(pkg, l);
 
-       char* suggests = pakfire_archive_get(archive, "dependencies.suggests");
-       if (suggests) {
-               l = pakfire_relationlist_create_from_string(archive->pakfire, suggests);
-               pakfire_package_set_suggests(pkg, l);
                pakfire_relationlist_unref(l);
-               pakfire_free(suggests);
        }
 
        // Import filelist
        pakfire_package_set_filelist(pkg, archive->filelist);
 
        return pkg;
+
+ERROR:
+       return NULL;
 }
 
 struct pakfire_scriptlet* pakfire_archive_get_scriptlet(

diff --git a/src/libpakfire/include/pakfire/relationlist.h b/src/libpakfire/include/pakfire/relationlist.h
index f6f1e728852e27d4bba653bfcda01fd00469e1bc..99e73bab4e3df77a7e522c47467acfb011644e65 100644 (file)
--- a/src/libpakfire/include/pakfire/relationlist.h
+++ b/src/libpakfire/include/pakfire/relationlist.h
@@ -23,8 +23,9 @@
 
 #include <pakfire/types.h>
 
-PakfireRelationList pakfire_relationlist_create(Pakfire pakfire);
-PakfireRelationList pakfire_relationlist_create_from_string(Pakfire pakfire, const char* s);
+int pakfire_relationlist_create(PakfireRelationList* list, Pakfire pakfire);
+int pakfire_relationlist_create_from_string(PakfireRelationList* list,
+       Pakfire pakfire, const char* s);
 
 PakfireRelationList pakfire_relationlist_ref(PakfireRelationList relationlist);
 PakfireRelationList pakfire_relationlist_unref(PakfireRelationList relationlist);
@@ -36,7 +37,7 @@ PakfireRelation pakfire_relationlist_get_clone(PakfireRelationList relationlist,
 
 #ifdef PAKFIRE_PRIVATE
 
-PakfireRelationList pakfire_relationlist_from_queue(Pakfire pakfire, Queue q);
+int pakfire_relationlist_from_queue(PakfireRelationList* list, Pakfire pakfire, Queue q);
 void pakfire_relationlist_clone_to_queue(PakfireRelationList relationlist, Queue* q);
 
 #endif

diff --git a/src/libpakfire/package.c b/src/libpakfire/package.c
index 843e3754ca8be180fb6a505b101f3c2c09904185..636f16e945586bb418ba5313771db747870587e2 100644 (file)
--- a/src/libpakfire/package.c
+++ b/src/libpakfire/package.c
@@ -519,10 +519,15 @@ static PakfireRelationList pakfire_package_get_relationlist(PakfirePackage pkg,
        Solvable* s = get_solvable(pkg);
        solvable_lookup_idarray(s, type, &q);
 
-       PakfireRelationList relationlist = pakfire_relationlist_from_queue(pkg->pakfire, q);
+       PakfireRelationList list;
+       int r = pakfire_relationlist_from_queue(&list, pkg->pakfire, q);
+
        queue_free(&q);
 
-       return relationlist;
+       if (r)
+               return NULL;
+
+       return list;
 }
 
 static void pakfire_package_set_relationlist(PakfirePackage pkg, Id type, PakfireRelationList relationlist) {

diff --git a/src/libpakfire/relationlist.c b/src/libpakfire/relationlist.c
index 65618ea3ec01393d48488106ec41707b63e639d5..5b7c4420788cadc4639e6aa9be9d93b936c8f027 100644 (file)
--- a/src/libpakfire/relationlist.c
+++ b/src/libpakfire/relationlist.c
@@ -18,6 +18,8 @@
 #                                                                             #
 #############################################################################*/
 
+#include <errno.h>
+
 #include <solv/pooltypes.h>
 #include <solv/queue.h>
 
@@ -35,44 +37,44 @@ struct _PakfireRelationList {
        int nrefs;
 };
 
-PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_create(Pakfire pakfire) {
-       PakfireRelationList relationlist = pakfire_calloc(1, sizeof(*relationlist));
-       if (relationlist) {
-               DEBUG(pakfire, "Allocated RelationList at %p\n", relationlist);
-               relationlist->nrefs = 1;
+PAKFIRE_EXPORT int pakfire_relationlist_create(PakfireRelationList* list, Pakfire pakfire) {
+       PakfireRelationList l = pakfire_calloc(1, sizeof(*l));
+       if (!l)
+               return ENOMEM;
 
-               relationlist->pakfire = pakfire_ref(pakfire);
-               queue_init(&relationlist->queue);
-       }
+       DEBUG(pakfire, "Allocated RelationList at %p\n", l);
+       l->pakfire = pakfire_ref(pakfire);
+       l->nrefs = 1;
 
-       return relationlist;
+       queue_init(&l->queue);
+
+       *list = l;
+       return 0;
 }
 
-PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_create_from_string(Pakfire pakfire, const char* s) {
-       PakfireRelationList relationlist = pakfire_relationlist_create(pakfire);
-       if (!relationlist)
-               return NULL;
+PAKFIRE_EXPORT int pakfire_relationlist_create_from_string(PakfireRelationList* list, Pakfire pakfire, const char* s) {
+       int r = pakfire_relationlist_create(list, pakfire);
+       if (r)
+               return r;
 
        // Split input by newline
-       char** list = pakfire_split_string(s, '\n');
-       if (!list)
-               return relationlist;
+       char** elements = pakfire_split_string(s, '\n');
+       if (!elements)
+               return 1;
 
-       char** item = list;
-       while (*item) {
-               PakfireRelation rel = pakfire_relation_create_from_string(relationlist->pakfire, *item);
+       for (char** element = elements; *element; element++) {
+               PakfireRelation rel = pakfire_relation_create_from_string(pakfire, *element);
                if (rel) {
-                       pakfire_relationlist_add(relationlist, rel);
+                       pakfire_relationlist_add(*list, rel);
                        pakfire_relation_unref(rel);
                }
 
-               //pakfire_free(*item);
-               item++;
+               pakfire_free(*element);
        }
 
-       pakfire_free(list);
+       pakfire_free(elements);
 
-       return relationlist;
+       return 0;
 }
 
 PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_ref(PakfireRelationList relationlist) {
@@ -108,17 +110,18 @@ PAKFIRE_EXPORT int pakfire_relationlist_count(PakfireRelationList relationlist)
        return relationlist->queue.count;
 }
 
-PAKFIRE_EXPORT PakfireRelationList pakfire_relationlist_from_queue(Pakfire pakfire, Queue q) {
-       PakfireRelationList relationlist = pakfire_relationlist_create(pakfire);
-       if (relationlist) {
-               // Release old queue
-               queue_free(&relationlist->queue);
+PAKFIRE_EXPORT int pakfire_relationlist_from_queue(PakfireRelationList* list, Pakfire pakfire, Queue q) {
+       int r = pakfire_relationlist_create(list, pakfire);
+       if (r)
+               return r;
 
-               // Copy the queue
-               queue_init_clone(&relationlist->queue, &q);
-       }
+       // Release old queue
+       queue_free(&(*list)->queue);
 
-       return relationlist;
+       // Copy the queue
+       queue_init_clone(&(*list)->queue, &q);
+
+       return 0;
 }
 
 PAKFIRE_EXPORT PakfireRelation pakfire_relationlist_get_clone(PakfireRelationList relationlist, int index) {