package: Change type from PakfirePackage to struct pakfire_package

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

diff --git a/src/_pakfire/archive.c b/src/_pakfire/archive.c
index bc0bd21a0fabac5bfdc4d1fa5a05716b5e9901ca..e4496b907e4a4ec4b3ea015ffb1529123f3642e4 100644 (file)
--- a/src/_pakfire/archive.c
+++ b/src/_pakfire/archive.c
@@ -145,7 +145,7 @@ static PyObject* Archive_get_package(ArchiveObject* self) {
                return NULL;
 
        // Make the package
-       PakfirePackage pkg = pakfire_archive_make_package(self->archive, repo);
+       struct pakfire_package* pkg = pakfire_archive_make_package(self->archive, repo);
 
        // Make the Python object
        PyObject* ret = new_package(&PackageType, pkg);

diff --git a/src/_pakfire/package.c b/src/_pakfire/package.c
index d3ea4bef400cedfdea053d1b53be75d4e4df741b..f34ab766520fffe7d686dcba0218b82c669ffff0 100644 (file)
--- a/src/_pakfire/package.c
+++ b/src/_pakfire/package.c
@@ -31,7 +31,7 @@
 #include "repo.h"
 #include "util.h"
 
-PyObject* new_package(PyTypeObject* type, PakfirePackage pkg) {
+PyObject* new_package(PyTypeObject* type, struct pakfire_package* pkg) {
        PackageObject* self = (PackageObject *)type->tp_alloc(type, 0);
        if (self) {
                self->package = pakfire_package_ref(pkg);

diff --git a/src/_pakfire/package.h b/src/_pakfire/package.h
index dd4aa40876d75e6c5b5de9839326d2e1185ce8ab..e7942c8698354b70111ef7bf20ada48205bf5d50 100644 (file)
--- a/src/_pakfire/package.h
+++ b/src/_pakfire/package.h
@@ -23,18 +23,17 @@
 
 #include <Python.h>
 
-#include <pakfire/types.h>
-#include <solv/pooltypes.h>
+#include <pakfire/package.h>
 
 #include "pakfire.h"
 
 typedef struct {
        PyObject_HEAD
-       PakfirePackage package;
+       struct pakfire_package* package;
 } PackageObject;
 
 extern PyTypeObject PackageType;
 
-PyObject* new_package(PyTypeObject* type, PakfirePackage pkg);
+PyObject* new_package(PyTypeObject* type, struct pakfire_package* pkg);
 
 #endif /* PYTHON_PAKFIRE_PACKAGE_H */

diff --git a/src/_pakfire/repo.c b/src/_pakfire/repo.c
index e592c8dad3a021ff571e3c9ffb8c20413e0d81dd..8fe48581e46277c953f91bdbec838536339625c9 100644 (file)
--- a/src/_pakfire/repo.c
+++ b/src/_pakfire/repo.c
@@ -283,7 +283,7 @@ static PyObject* Repo__add_package(RepoObject* self, PyObject* args) {
                return NULL;
 
        Pakfire pakfire = pakfire_repo_get_pakfire(self->repo);
-       PakfirePackage pkg = pakfire_package_create(pakfire, self->repo, name, evr, arch);
+       struct pakfire_package* pkg = pakfire_package_create(pakfire, self->repo, name, evr, arch);
 
        PyObject* obj = new_package(&PackageType, pkg);
 
@@ -300,7 +300,7 @@ static PyObject* Repo_add_archive(RepoObject* self, PyObject* args) {
                return NULL;
 
        // Add package
-       PakfirePackage pkg = pakfire_repo_add_archive(self->repo, archive->archive);
+       struct pakfire_package* pkg = pakfire_repo_add_archive(self->repo, archive->archive);
        assert(pkg);
 
        // Create Python object

diff --git a/src/_pakfire/util.c b/src/_pakfire/util.c
index db8c136fb3f1c1e460c790d7b6d77c35c24c5589..5c655b3bad0b1ab39e8c6568ca8d58b95fb6c200 100644 (file)
--- a/src/_pakfire/util.c
+++ b/src/_pakfire/util.c
@@ -88,7 +88,7 @@ PyObject* PyList_FromPackageList(struct pakfire_packagelist* packagelist) {
 
        int count = pakfire_packagelist_count(packagelist);
        for (int i = 0; i < count; i++) {
-               PakfirePackage package = pakfire_packagelist_get(packagelist, i);
+               struct pakfire_package* package = pakfire_packagelist_get(packagelist, i);
 
                PyObject* item = new_package(&PackageType, package);
                PyList_Append(list, item);

diff --git a/src/libpakfire/archive.c b/src/libpakfire/archive.c
index ee43dfad0bb9f5dd18feaf9a3fbf20c093bd8957..375b34b33ecfbc089cc717b622952204f4612aed 100644 (file)
--- a/src/libpakfire/archive.c
+++ b/src/libpakfire/archive.c
@@ -66,7 +66,7 @@ struct _PakfireArchive {
 
        char path[PATH_MAX];
        FILE* f;
-       PakfirePackage package;
+       struct pakfire_package* package;
 
        // metadata
        unsigned int format;
@@ -459,7 +459,7 @@ PAKFIRE_EXPORT Pakfire pakfire_archive_get_pakfire(PakfireArchive archive) {
        return pakfire_ref(archive->pakfire);
 }
 
-static PakfirePackage pakfire_archive_get_package(PakfireArchive archive) {
+static struct pakfire_package* pakfire_archive_get_package(PakfireArchive archive) {
        if (!archive->package) {
                PakfireRepo repo = pakfire_get_repo(archive->pakfire, "@dummy");
                if (!repo)
@@ -835,7 +835,7 @@ static int pakfire_archive_extraction_path(PakfireArchive archive,
                char* path, size_t length, const char* prefix) {
        char buffer[PATH_MAX];
 
-       PakfirePackage pkg = pakfire_archive_get_package(archive);
+       struct pakfire_package* pkg = pakfire_archive_get_package(archive);
        if (!pkg)
                return 1;
 
@@ -871,7 +871,7 @@ static int pakfire_archive_extract_progressbar(
                PakfireArchive archive, struct pakfire_progressbar** progressbar) {
        int r = 1;
 
-       PakfirePackage pkg = pakfire_archive_get_package(archive);
+       struct pakfire_package* pkg = pakfire_archive_get_package(archive);
        if (!pkg)
                goto ERROR;
 
@@ -1487,7 +1487,7 @@ PAKFIRE_EXPORT size_t pakfire_archive_get_size(PakfireArchive archive) {
 /*
        Copy all metadata from this archive to the package object
 */
-PAKFIRE_EXPORT PakfirePackage pakfire_archive_make_package(PakfireArchive archive, PakfireRepo repo) {
+PAKFIRE_EXPORT struct pakfire_package* pakfire_archive_make_package(PakfireArchive archive, PakfireRepo repo) {
        char* name = pakfire_archive_get(archive, "package", "name");
        char* arch = pakfire_archive_get(archive, "package", "arch");
 
@@ -1523,7 +1523,7 @@ PAKFIRE_EXPORT PakfirePackage pakfire_archive_make_package(PakfireArchive archiv
                free(type);
        }
 
-       PakfirePackage pkg = pakfire_package_create(
+       struct pakfire_package* pkg = pakfire_package_create(
                archive->pakfire, repo, name, evr, (arch) ? arch : "src"
        );
 
@@ -1638,7 +1638,7 @@ PAKFIRE_EXPORT PakfirePackage pakfire_archive_make_package(PakfireArchive archiv
 
        const struct __relation {
                const char* type;
-               void (*func)(PakfirePackage, const char* dep);
+               void (*func)(struct pakfire_package*, const char* dep);
        } relations[] = {
                { "provides", pakfire_package_add_provides },
                { "prerequires", pakfire_package_add_prerequires },

diff --git a/src/libpakfire/build.c b/src/libpakfire/build.c
index 285ec9161423cbce6af8e6e768976e32567e3b77..b17bee95a2b3094a57dc90141b348d5e13f78ff6 100644 (file)
--- a/src/libpakfire/build.c
+++ b/src/libpakfire/build.c
@@ -241,7 +241,7 @@ static int find_dependency(char** haystack, const char* needle) {
 }
 
 static int pakfire_build_find_dependencies(Pakfire pakfire,
-               PakfirePackage pkg, PakfireFilelist filelist, const char* buildroot) {
+               struct pakfire_package* pkg, PakfireFilelist filelist, const char* buildroot) {
        char** provides = NULL;
        char** requires = NULL;
        char path[PATH_MAX];
@@ -348,7 +348,7 @@ static int append_to_array(const char*** array, const char* s) {
 }
 
 static int pakfire_build_package_add_files(Pakfire pakfire, PakfireParser makefile,
-               const char* buildroot, const char* namespace, PakfirePackage pkg,
+               const char* buildroot, const char* namespace, struct pakfire_package* pkg,
                struct pakfire_packager* packager) {
        PakfireFilelist filelist = NULL;
        char path[PATH_MAX];
@@ -443,7 +443,7 @@ ERROR:
        return r;
 }
 
-static int pakfire_build_add_scriptlet_requires(Pakfire pakfire, PakfirePackage pkg,
+static int pakfire_build_add_scriptlet_requires(Pakfire pakfire, struct pakfire_package* pkg,
                struct pakfire_scriptlet* scriptlet) {
        char** prerequires = NULL;
        char path[PATH_MAX];
@@ -507,7 +507,7 @@ ERROR:
        return r;
 }
 
-static int pakfire_build_package_add_scriptlet(Pakfire pakfire, PakfirePackage pkg,
+static int pakfire_build_package_add_scriptlet(Pakfire pakfire, struct pakfire_package* pkg,
                struct pakfire_packager* packager, const char* type, const char* data) {
        struct pakfire_scriptlet* scriptlet = NULL;
        char* shell = NULL;
@@ -550,7 +550,7 @@ ERROR:
 }
 
 static int pakfire_build_package_add_scriptlets(Pakfire pakfire, PakfireParser makefile,
-               const char* namespace, PakfirePackage pkg, struct pakfire_packager* packager) {
+               const char* namespace, struct pakfire_package* pkg, struct pakfire_packager* packager) {
        char name[NAME_MAX];
        int r;
 
@@ -580,7 +580,7 @@ static int pakfire_build_package_add_scriptlets(Pakfire pakfire, PakfireParser m
 static int pakfire_build_package(Pakfire pakfire, PakfireParser makefile,
                const char* id, const char* buildroot, const char* namespace, const char* target) {
        PakfireRepo repo = NULL;
-       PakfirePackage pkg = NULL;
+       struct pakfire_package* pkg = NULL;
        struct pakfire_packager* packager = NULL;
 
        int r = 1;

diff --git a/src/libpakfire/db.c b/src/libpakfire/db.c
index 900e69e3a6f2327e90dfee7a80b724efa094dba7..e9afcf92be624c12ddf6a15c90ea117ff3298e2c 100644 (file)
--- a/src/libpakfire/db.c
+++ b/src/libpakfire/db.c
@@ -666,7 +666,7 @@ static void pakfire_db_add_userinstalled(Pakfire pakfire, const char* name) {
        queue_push2(&pool->pooljobs, SOLVER_USERINSTALLED|SOLVER_SOLVABLE_NAME, id);
 }
 
-static int pakfire_db_add_dependencies(struct pakfire_db* db, unsigned long id, PakfirePackage pkg) {
+static int pakfire_db_add_dependencies(struct pakfire_db* db, unsigned long id, struct pakfire_package* pkg) {
        sqlite3_stmt* stmt = NULL;
        int r = 1;
 
@@ -682,7 +682,7 @@ static int pakfire_db_add_dependencies(struct pakfire_db* db, unsigned long id,
 
        const struct __relation {
                const char* type;
-               char** (*func)(PakfirePackage);
+               char** (*func)(struct pakfire_package*);
        } relations[] = {
                { "provides", pakfire_package_get_provides },
                { "prerequires", pakfire_package_get_prerequires },
@@ -1001,7 +1001,7 @@ END:
 }
 
 int pakfire_db_add_package(struct pakfire_db* db,
-               PakfirePackage pkg, PakfireArchive archive, int userinstalled) {
+               struct pakfire_package* pkg, PakfireArchive archive, int userinstalled) {
        sqlite3_stmt* stmt = NULL;
        int r;
 
@@ -1242,7 +1242,7 @@ ROLLBACK:
        return 1;
 }
 
-int pakfire_db_remove_package(struct pakfire_db* db, PakfirePackage pkg) {
+int pakfire_db_remove_package(struct pakfire_db* db, struct pakfire_package* pkg) {
        sqlite3_stmt* stmt = NULL;
        int r = 1;
 
@@ -1290,7 +1290,7 @@ ERROR:
 }
 
 struct pakfire_scriptlet* pakfire_db_get_scriptlet(struct pakfire_db* db,
-               PakfirePackage pkg, const char* type) {
+               struct pakfire_package* pkg, const char* type) {
        struct pakfire_scriptlet* scriptlet = NULL;
        sqlite3_stmt* stmt = NULL;
        int r = 1;
@@ -1352,7 +1352,7 @@ ERROR:
 }
 
 static int pakfire_db_load_package(struct pakfire_db* db, PakfireRepo repo, sqlite3_stmt* stmt) {
-       PakfirePackage pkg = NULL;
+       struct pakfire_package* pkg = NULL;
        int r = 1;
 
        // Name
@@ -1483,7 +1483,7 @@ static int pakfire_db_load_package(struct pakfire_db* db, PakfireRepo repo, sqli
 
        const struct dependency {
                unsigned int field;
-               void (*func)(PakfirePackage pkg, const char* dep);
+               void (*func)(struct pakfire_package* pkg, const char* dep);
        } dependencies[] = {
                { 19, pakfire_package_add_provides },
                { 20, pakfire_package_add_prerequires },
@@ -1698,7 +1698,7 @@ ERROR:
 }
 
 int pakfire_db_package_filelist(struct pakfire_db* db, PakfireFilelist* filelist,
-               PakfirePackage pkg) {
+               struct pakfire_package* pkg) {
        PakfireFilelist fl = NULL;
        sqlite3_stmt* stmt = NULL;
        int r = 1;

diff --git a/src/libpakfire/dist.c b/src/libpakfire/dist.c
index f5ea45a9ae555cb6b27aeb9e4632a0ff2e5b35a2..c0cc1ee250e7f3e5cccf688b2218dc50f80eb496 100644 (file)
--- a/src/libpakfire/dist.c
+++ b/src/libpakfire/dist.c
@@ -240,7 +240,7 @@ ERROR:
 }
 
 static int pakfire_dist_add_source(Pakfire pakfire, struct pakfire_packager* packager,
-               PakfirePackage pkg, struct pakfire_downloader* downloader,
+               struct pakfire_package* pkg, struct pakfire_downloader* downloader,
                struct pakfire_mirrorlist* mirrorlist, const char* filename) {
        int r;
        char archive_path[PATH_MAX];
@@ -264,7 +264,7 @@ static int pakfire_dist_add_source(Pakfire pakfire, struct pakfire_packager* pac
 }
 
 static int pakfire_dist_add_sources(Pakfire pakfire, struct pakfire_packager* packager,
-               PakfirePackage pkg, PakfireParser makefile) {
+               struct pakfire_package* pkg, PakfireParser makefile) {
        // Fetch sources
        char** sources = pakfire_parser_get_split(makefile, NULL, "sources", ' ');
 
@@ -371,7 +371,7 @@ PAKFIRE_EXPORT int pakfire_dist(Pakfire pakfire, const char* path, const char* t
        struct pakfire_parser_error* error = NULL;
 
        struct pakfire_packager* packager = NULL;
-       PakfirePackage pkg = NULL;
+       struct pakfire_package* pkg = NULL;
        PakfireRepo repo = NULL;
 
        // Load makefile

diff --git a/src/libpakfire/include/pakfire/archive.h b/src/libpakfire/include/pakfire/archive.h
index 2975543cfe8d2c9fc6e262a19989b6c7037f505b..a5ab3c2fdbe0627db192e2db58c2c0037413c294 100644 (file)
--- a/src/libpakfire/include/pakfire/archive.h
+++ b/src/libpakfire/include/pakfire/archive.h
@@ -23,6 +23,7 @@
 
 #include <stddef.h>
 
+#include <pakfire/package.h>
 #include <pakfire/scriptlet.h>
 #include <pakfire/types.h>
 
@@ -64,7 +65,7 @@ void pakfire_archive_signature_unref(PakfireArchiveSignature signature);
 const char* pakfire_archive_signature_get_data(PakfireArchiveSignature signature);
 
 size_t pakfire_archive_get_size(PakfireArchive archive);
-PakfirePackage pakfire_archive_make_package(PakfireArchive archive, PakfireRepo repo);
+struct pakfire_package* pakfire_archive_make_package(PakfireArchive archive, PakfireRepo repo);
 
 #define PAKFIRE_ARCHIVE_FN_CHECKSUMS           "chksums"
 #define PAKFIRE_ARCHIVE_FN_FILELIST                    "filelist"

diff --git a/src/libpakfire/include/pakfire/db.h b/src/libpakfire/include/pakfire/db.h
index 9e89592bc7d15f90f7e6f35cb80077e4f64cc6b8..10f700c6f5848489da5b8e7dcf639d944ed52982 100644 (file)
--- a/src/libpakfire/include/pakfire/db.h
+++ b/src/libpakfire/include/pakfire/db.h
@@ -25,6 +25,7 @@
 
 #include <sys/types.h>
 
+#include <pakfire/package.h>
 #include <pakfire/scriptlet.h>
 #include <pakfire/types.h>
 
@@ -44,17 +45,17 @@ int pakfire_db_check(struct pakfire_db* db);
 
 ssize_t pakfire_db_packages(struct pakfire_db* db);
 
-int pakfire_db_add_package(struct pakfire_db* db, PakfirePackage pkg,
+int pakfire_db_add_package(struct pakfire_db* db, struct pakfire_package* pkg,
        PakfireArchive archive, int userinstalled);
-int pakfire_db_remove_package(struct pakfire_db* db, PakfirePackage pkg);
+int pakfire_db_remove_package(struct pakfire_db* db, struct pakfire_package* pkg);
 
 int pakfire_db_load(struct pakfire_db* db, PakfireRepo repo);
 
 struct pakfire_scriptlet* pakfire_db_get_scriptlet(
-       struct pakfire_db* db, PakfirePackage pkg, const char* type);
+       struct pakfire_db* db, struct pakfire_package* pkg, const char* type);
 
 int pakfire_db_package_filelist(struct pakfire_db* db, PakfireFilelist* filelist,
-       PakfirePackage pkg);
+       struct pakfire_package* pkg);
 
 #endif
 

diff --git a/src/libpakfire/include/pakfire/package.h b/src/libpakfire/include/pakfire/package.h
index 53d5aea65727c8ea7d1d7869402485391cc579fd..31613fe804795c5f3fe4c76bdf98ab3ac66bd548 100644 (file)
--- a/src/libpakfire/include/pakfire/package.h
+++ b/src/libpakfire/include/pakfire/package.h
@@ -27,84 +27,86 @@
 #include <pakfire/packagelist.h>
 #include <pakfire/types.h>
 
-PakfirePackage pakfire_package_create(Pakfire pakfire, PakfireRepo repo,
+struct pakfire_package;
+
+struct pakfire_package* pakfire_package_create(Pakfire pakfire, PakfireRepo repo,
        const char* name, const char* evr, const char* arch);
 
-PakfirePackage pakfire_package_ref(PakfirePackage pkg);
-PakfirePackage pakfire_package_unref(PakfirePackage pkg);
-Pakfire pakfire_package_get_pakfire(PakfirePackage pkg);
-
-int pakfire_package_eq(PakfirePackage pkg1, PakfirePackage pkg2);
-int pakfire_package_cmp(PakfirePackage pkg1, PakfirePackage pkg2);
-int pakfire_package_evr_cmp(PakfirePackage pkg1, PakfirePackage pkg2);
-
-const char* pakfire_package_get_nevra(PakfirePackage pkg);
-const char* pakfire_package_get_name(PakfirePackage pkg);
-void pakfire_package_set_name(PakfirePackage pkg, const char* name);
-const char* pakfire_package_get_evr(PakfirePackage pkg);
-void pakfire_package_set_evr(PakfirePackage pkg, const char* evr);
-const char* pakfire_package_get_arch(PakfirePackage pkg);
-void pakfire_package_set_arch(PakfirePackage pkg, const char* arch);
-
-const char* pakfire_package_get_uuid(PakfirePackage pkg);
-void pakfire_package_set_uuid(PakfirePackage pkg, const char* uuid);
-const char* pakfire_package_get_checksum(PakfirePackage pkg);
-void pakfire_package_set_checksum(PakfirePackage pkg, const char* checksum);
-const char* pakfire_package_get_summary(PakfirePackage pkg);
-void pakfire_package_set_summary(PakfirePackage pkg, const char* summary);
-const char* pakfire_package_get_description(PakfirePackage pkg);
-void pakfire_package_set_description(PakfirePackage pkg, const char* description);
-const char* pakfire_package_get_license(PakfirePackage pkg);
-void pakfire_package_set_license(PakfirePackage pkg, const char* license);
-const char* pakfire_package_get_url(PakfirePackage pkg);
-void pakfire_package_set_url(PakfirePackage pkg, const char* url);
-char* pakfire_package_get_groups(PakfirePackage pkg);
-void pakfire_package_set_groups(PakfirePackage pkg, const char* groups);
-const char* pakfire_package_get_vendor(PakfirePackage pkg);
-void pakfire_package_set_vendor(PakfirePackage pkg, const char* vendor);
-const char* pakfire_package_get_maintainer(PakfirePackage pkg);
-void pakfire_package_set_maintainer(PakfirePackage pkg, const char* maintainer);
-const char* pakfire_package_get_filename(PakfirePackage pkg);
-const char* pakfire_package_get_path(PakfirePackage pkg);
-void pakfire_package_set_path(PakfirePackage pkg, const char* path);
-void pakfire_package_set_filename(PakfirePackage pkg, const char* filename);
-int pakfire_package_is_installed(PakfirePackage pkg);
-unsigned long long pakfire_package_get_downloadsize(PakfirePackage pkg);
-void pakfire_package_set_downloadsize(PakfirePackage pkg, unsigned long long downloadsize);
-unsigned long long pakfire_package_get_installsize(PakfirePackage pkg);
-void pakfire_package_set_installsize(PakfirePackage pkg, unsigned long long installsize);
-unsigned long long pakfire_package_get_size(PakfirePackage pkg);
-const char* pakfire_package_get_build_host(PakfirePackage pkg);
-void pakfire_package_set_build_host(PakfirePackage pkg, const char* build_host);
-const char* pakfire_package_get_build_id(PakfirePackage pkg);
-void pakfire_package_set_build_id(PakfirePackage pkg, const char* build_id);
-time_t pakfire_package_get_build_time(PakfirePackage pkg);
-void pakfire_package_set_build_time(PakfirePackage pkg, time_t build_time);
-time_t pakfire_package_get_install_time(PakfirePackage pkg);
-void pakfire_package_set_install_time(PakfirePackage pkg, time_t install_time);
-
-char** pakfire_package_get_provides(PakfirePackage pkg);
-char** pakfire_package_get_prerequires(PakfirePackage pkg);
-char** pakfire_package_get_requires(PakfirePackage pkg);
-char** pakfire_package_get_conflicts(PakfirePackage pkg);
-char** pakfire_package_get_obsoletes(PakfirePackage pkg);
-char** pakfire_package_get_recommends(PakfirePackage pkg);
-char** pakfire_package_get_suggests(PakfirePackage pkg);
-char** pakfire_package_get_supplements(PakfirePackage pkg);
-char** pakfire_package_get_enhances(PakfirePackage pkg);
-
-int pakfire_package_get_reverse_requires(PakfirePackage pkg,
+struct pakfire_package* pakfire_package_ref(struct pakfire_package* pkg);
+struct pakfire_package* pakfire_package_unref(struct pakfire_package* pkg);
+Pakfire pakfire_package_get_pakfire(struct pakfire_package* pkg);
+
+int pakfire_package_eq(struct pakfire_package* pkg1, struct pakfire_package* pkg2);
+int pakfire_package_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2);
+int pakfire_package_evr_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2);
+
+const char* pakfire_package_get_nevra(struct pakfire_package* pkg);
+const char* pakfire_package_get_name(struct pakfire_package* pkg);
+void pakfire_package_set_name(struct pakfire_package* pkg, const char* name);
+const char* pakfire_package_get_evr(struct pakfire_package* pkg);
+void pakfire_package_set_evr(struct pakfire_package* pkg, const char* evr);
+const char* pakfire_package_get_arch(struct pakfire_package* pkg);
+void pakfire_package_set_arch(struct pakfire_package* pkg, const char* arch);
+
+const char* pakfire_package_get_uuid(struct pakfire_package* pkg);
+void pakfire_package_set_uuid(struct pakfire_package* pkg, const char* uuid);
+const char* pakfire_package_get_checksum(struct pakfire_package* pkg);
+void pakfire_package_set_checksum(struct pakfire_package* pkg, const char* checksum);
+const char* pakfire_package_get_summary(struct pakfire_package* pkg);
+void pakfire_package_set_summary(struct pakfire_package* pkg, const char* summary);
+const char* pakfire_package_get_description(struct pakfire_package* pkg);
+void pakfire_package_set_description(struct pakfire_package* pkg, const char* description);
+const char* pakfire_package_get_license(struct pakfire_package* pkg);
+void pakfire_package_set_license(struct pakfire_package* pkg, const char* license);
+const char* pakfire_package_get_url(struct pakfire_package* pkg);
+void pakfire_package_set_url(struct pakfire_package* pkg, const char* url);
+char* pakfire_package_get_groups(struct pakfire_package* pkg);
+void pakfire_package_set_groups(struct pakfire_package* pkg, const char* groups);
+const char* pakfire_package_get_vendor(struct pakfire_package* pkg);
+void pakfire_package_set_vendor(struct pakfire_package* pkg, const char* vendor);
+const char* pakfire_package_get_maintainer(struct pakfire_package* pkg);
+void pakfire_package_set_maintainer(struct pakfire_package* pkg, const char* maintainer);
+const char* pakfire_package_get_filename(struct pakfire_package* pkg);
+const char* pakfire_package_get_path(struct pakfire_package* pkg);
+void pakfire_package_set_path(struct pakfire_package* pkg, const char* path);
+void pakfire_package_set_filename(struct pakfire_package* pkg, const char* filename);
+int pakfire_package_is_installed(struct pakfire_package* pkg);
+unsigned long long pakfire_package_get_downloadsize(struct pakfire_package* pkg);
+void pakfire_package_set_downloadsize(struct pakfire_package* pkg, unsigned long long downloadsize);
+unsigned long long pakfire_package_get_installsize(struct pakfire_package* pkg);
+void pakfire_package_set_installsize(struct pakfire_package* pkg, unsigned long long installsize);
+unsigned long long pakfire_package_get_size(struct pakfire_package* pkg);
+const char* pakfire_package_get_build_host(struct pakfire_package* pkg);
+void pakfire_package_set_build_host(struct pakfire_package* pkg, const char* build_host);
+const char* pakfire_package_get_build_id(struct pakfire_package* pkg);
+void pakfire_package_set_build_id(struct pakfire_package* pkg, const char* build_id);
+time_t pakfire_package_get_build_time(struct pakfire_package* pkg);
+void pakfire_package_set_build_time(struct pakfire_package* pkg, time_t build_time);
+time_t pakfire_package_get_install_time(struct pakfire_package* pkg);
+void pakfire_package_set_install_time(struct pakfire_package* pkg, time_t install_time);
+
+char** pakfire_package_get_provides(struct pakfire_package* pkg);
+char** pakfire_package_get_prerequires(struct pakfire_package* pkg);
+char** pakfire_package_get_requires(struct pakfire_package* pkg);
+char** pakfire_package_get_conflicts(struct pakfire_package* pkg);
+char** pakfire_package_get_obsoletes(struct pakfire_package* pkg);
+char** pakfire_package_get_recommends(struct pakfire_package* pkg);
+char** pakfire_package_get_suggests(struct pakfire_package* pkg);
+char** pakfire_package_get_supplements(struct pakfire_package* pkg);
+char** pakfire_package_get_enhances(struct pakfire_package* pkg);
+
+int pakfire_package_get_reverse_requires(struct pakfire_package* pkg,
        struct pakfire_packagelist** list);
 
-PakfireRepo pakfire_package_get_repo(PakfirePackage pkg);
+PakfireRepo pakfire_package_get_repo(struct pakfire_package* pkg);
 
-char* pakfire_package_dump(PakfirePackage pkg, int flags);
+char* pakfire_package_dump(struct pakfire_package* pkg, int flags);
 
-PakfireArchive pakfire_package_get_archive(PakfirePackage pkg);
+PakfireArchive pakfire_package_get_archive(struct pakfire_package* pkg);
 
-PakfireFilelist pakfire_package_get_filelist(PakfirePackage pkg);
-int pakfire_package_set_filelist(PakfirePackage pkg, PakfireFilelist filelist);
-int pakfire_package_set_filelist_from_string(PakfirePackage pkg, const char* files);
+PakfireFilelist pakfire_package_get_filelist(struct pakfire_package* pkg);
+int pakfire_package_set_filelist(struct pakfire_package* pkg, PakfireFilelist filelist);
+int pakfire_package_set_filelist_from_string(struct pakfire_package* pkg, const char* files);
 
 enum pakfire_package_dump_flags {
        PAKFIRE_PKG_DUMP_FILELIST = 1 << 0,
@@ -115,25 +117,25 @@ enum pakfire_package_dump_flags {
 
 #include <solv/pooltypes.h>
 
-PakfirePackage pakfire_package_create_from_solvable(Pakfire pakfire, Id id);
+struct pakfire_package* pakfire_package_create_from_solvable(Pakfire pakfire, Id id);
 
-uint64_t pakfire_package_get_dbid(PakfirePackage pkg);
-void pakfire_package_set_dbid(PakfirePackage pkg, uint64_t id);
+uint64_t pakfire_package_get_dbid(struct pakfire_package* pkg);
+void pakfire_package_set_dbid(struct pakfire_package* pkg, uint64_t id);
 
-Id pakfire_package_id(PakfirePackage pkg);
-int pakfire_package_is_source(PakfirePackage pkg);
+Id pakfire_package_id(struct pakfire_package* pkg);
+int pakfire_package_is_source(struct pakfire_package* pkg);
 
 char* pakfire_package_join_evr(const char* e, const char* v, const char* r);
 
-void pakfire_package_add_provides(PakfirePackage pkg, const char* dep);
-void pakfire_package_add_prerequires(PakfirePackage pkg, const char* dep);
-void pakfire_package_add_requires(PakfirePackage pkg, const char* dep);
-void pakfire_package_add_conflicts(PakfirePackage pkg, const char* dep);
-void pakfire_package_add_obsoletes(PakfirePackage pkg, const char* dep);
-void pakfire_package_add_recommends(PakfirePackage pkg, const char* dep);
-void pakfire_package_add_suggests(PakfirePackage pkg, const char* dep);
-void pakfire_package_add_supplements(PakfirePackage pkg, const char* dep);
-void pakfire_package_add_enhances(PakfirePackage pkg, const char* dep);
+void pakfire_package_add_provides(struct pakfire_package* pkg, const char* dep);
+void pakfire_package_add_prerequires(struct pakfire_package* pkg, const char* dep);
+void pakfire_package_add_requires(struct pakfire_package* pkg, const char* dep);
+void pakfire_package_add_conflicts(struct pakfire_package* pkg, const char* dep);
+void pakfire_package_add_obsoletes(struct pakfire_package* pkg, const char* dep);
+void pakfire_package_add_recommends(struct pakfire_package* pkg, const char* dep);
+void pakfire_package_add_suggests(struct pakfire_package* pkg, const char* dep);
+void pakfire_package_add_supplements(struct pakfire_package* pkg, const char* dep);
+void pakfire_package_add_enhances(struct pakfire_package* pkg, const char* dep);
 
 #endif
 

diff --git a/src/libpakfire/include/pakfire/packagelist.h b/src/libpakfire/include/pakfire/packagelist.h
index beba42a6802e2621ddd6ebca337cab9e01328c71..64a01d1466dcee4f418df8825599115bf8aa7ebd 100644 (file)
--- a/src/libpakfire/include/pakfire/packagelist.h
+++ b/src/libpakfire/include/pakfire/packagelist.h
@@ -21,6 +21,7 @@
 #ifndef PAKFIRE_PACKAGELIST_H
 #define PAKFIRE_PACKAGELIST_H
 
+#include <pakfire/package.h>
 #include <pakfire/types.h>
 
 struct pakfire_packagelist;
@@ -31,10 +32,10 @@ struct pakfire_packagelist* pakfire_packagelist_unref(struct pakfire_packagelist
 
 size_t pakfire_packagelist_count(struct pakfire_packagelist* list);
 void pakfire_packagelist_sort(struct pakfire_packagelist* list);
-PakfirePackage pakfire_packagelist_get(struct pakfire_packagelist* list, unsigned int index);
+struct pakfire_package* pakfire_packagelist_get(struct pakfire_packagelist* list, unsigned int index);
 
-void pakfire_packagelist_push(struct pakfire_packagelist* list, PakfirePackage pkg);
-void pakfire_packagelist_push_if_not_exists(struct pakfire_packagelist* list, PakfirePackage pkg);
+void pakfire_packagelist_push(struct pakfire_packagelist* list, struct pakfire_package* pkg);
+void pakfire_packagelist_push_if_not_exists(struct pakfire_packagelist* list, struct pakfire_package* pkg);
 
 #ifdef PAKFIRE_PRIVATE
 

diff --git a/src/libpakfire/include/pakfire/packager.h b/src/libpakfire/include/pakfire/packager.h
index 330b16ff13ec21751df494b9cdc9dcbab22b3348..add30c5dd76966a8762eee0c0f913ecb3a260319 100644 (file)
--- a/src/libpakfire/include/pakfire/packager.h
+++ b/src/libpakfire/include/pakfire/packager.h
@@ -23,12 +23,13 @@
 
 #ifdef PAKFIRE_PRIVATE
 
+#include <pakfire/package.h>
 #include <pakfire/scriptlet.h>
 #include <pakfire/types.h>
 
 struct pakfire_packager;
 
-int pakfire_packager_create(struct pakfire_packager** packager, PakfirePackage pkg);
+int pakfire_packager_create(struct pakfire_packager** packager, struct pakfire_package* pkg);
 
 struct pakfire_packager* pakfire_packager_ref(struct pakfire_packager* packager);
 struct pakfire_packager* pakfire_packager_unref(struct pakfire_packager* packager);

diff --git a/src/libpakfire/include/pakfire/parser.h b/src/libpakfire/include/pakfire/parser.h
index 3097fd37f7a71515466848d06d33704d772e7524..709f781a5277761d43aa1caf7fc17f53b25843a1 100644 (file)
--- a/src/libpakfire/include/pakfire/parser.h
+++ b/src/libpakfire/include/pakfire/parser.h
@@ -23,6 +23,7 @@
 
 #include <stdio.h>
 
+#include <pakfire/package.h>
 #include <pakfire/types.h>
 
 enum pakfire_parser_flags {
@@ -64,7 +65,7 @@ const char* pakfire_parser_get_namespace(PakfireParser parser);
 int pakfire_parser_set_namespace(PakfireParser parser, const char* namespace);
 
 int pakfire_parser_create_package(PakfireParser parser,
-       PakfirePackage* pkg, PakfireRepo repo, const char* namespace, const char* default_arch);
+       struct pakfire_package** pkg, PakfireRepo repo, const char* namespace, const char* default_arch);
 
 // Errors
 int pakfire_parser_error_create(struct pakfire_parser_error** error,

diff --git a/src/libpakfire/include/pakfire/repo.h b/src/libpakfire/include/pakfire/repo.h
index ccb4a8fb9199096a9ebcfe082183fa2bcb54b204..b7c8018a1450632b93331400e50cf18a349fc51a 100644 (file)
--- a/src/libpakfire/include/pakfire/repo.h
+++ b/src/libpakfire/include/pakfire/repo.h
@@ -25,6 +25,7 @@
 #include <time.h>
 #include <unistd.h>
 
+#include <pakfire/package.h>
 #include <pakfire/types.h>
 
 PakfireRepo pakfire_repo_create(Pakfire pakfire, const char* name);
@@ -71,7 +72,7 @@ int pakfire_repo_read_solv_fp(PakfireRepo repo, FILE *f, int flags);
 int pakfire_repo_write_solv(PakfireRepo repo, const char* filename, int flags);
 int pakfire_repo_write_solv_fp(PakfireRepo repo, FILE *f, int flags);
 
-PakfirePackage pakfire_repo_add_archive(PakfireRepo repo, PakfireArchive archive);
+struct pakfire_package* pakfire_repo_add_archive(PakfireRepo repo, PakfireArchive archive);
 
 // Cache
 

diff --git a/src/libpakfire/include/pakfire/request.h b/src/libpakfire/include/pakfire/request.h
index af640abcfef593da7a13943eefc27ff64b5eda6f..6ad4fb79f2e846ebb64abbfd0fa13a0535d28c95 100644 (file)
--- a/src/libpakfire/include/pakfire/request.h
+++ b/src/libpakfire/include/pakfire/request.h
@@ -21,6 +21,7 @@
 #ifndef PAKFIRE_REQUEST_H
 #define PAKFIRE_REQUEST_H
 
+#include <pakfire/package.h>
 #include <pakfire/problem.h>
 #include <pakfire/transaction.h>
 #include <pakfire/types.h>
@@ -50,19 +51,19 @@ int pakfire_request_solve(struct pakfire_request* request,
        struct pakfire_transaction** transaction, struct pakfire_problem*** problems);
 
 int pakfire_request_install(struct pakfire_request* request, const char* what, int flags);
-int pakfire_request_install_package(struct pakfire_request* request, PakfirePackage package);
+int pakfire_request_install_package(struct pakfire_request* request, struct pakfire_package* package);
 
 int pakfire_request_erase(struct pakfire_request* request, const char* what, int flags);
-int pakfire_request_erase_package(struct pakfire_request* request, PakfirePackage package, int flags);
+int pakfire_request_erase_package(struct pakfire_request* request, struct pakfire_package* package, int flags);
 
 int pakfire_request_upgrade(struct pakfire_request* request, const char* what, int flags);
-int pakfire_request_upgrade_package(struct pakfire_request* request, PakfirePackage package);
+int pakfire_request_upgrade_package(struct pakfire_request* request, struct pakfire_package* package);
 
 int pakfire_request_upgrade_all(struct pakfire_request* request);
 int pakfire_request_sync(struct pakfire_request* request, int flags);
 
 int pakfire_request_lock(struct pakfire_request* request, const char* what);
-int pakfire_request_lock_package(struct pakfire_request* request, PakfirePackage package);
+int pakfire_request_lock_package(struct pakfire_request* request, struct pakfire_package* package);
 
 int pakfire_request_verify(struct pakfire_request* request, int flags);
 

diff --git a/src/libpakfire/include/pakfire/types.h b/src/libpakfire/include/pakfire/types.h
index f33dec2a6e061d9a4fb0b62386f9654dd0df7de4..be7193c6e53335d83c8fc00022989fef62d1975b 100644 (file)
--- a/src/libpakfire/include/pakfire/types.h
+++ b/src/libpakfire/include/pakfire/types.h
@@ -28,7 +28,6 @@ typedef struct _PakfireArchive* PakfireArchive;
 typedef struct _PakfireArchiveSignature* PakfireArchiveSignature;
 typedef struct _PakfireFilelist* PakfireFilelist;
 typedef struct _PakfireKey* PakfireKey;
-typedef struct _PakfirePackage* PakfirePackage;
 typedef struct _PakfireParser* PakfireParser;
 typedef struct _PakfireRepo* PakfireRepo;
 typedef struct _PakfireSolution* PakfireSolution;

diff --git a/src/libpakfire/include/pakfire/util.h b/src/libpakfire/include/pakfire/util.h
index 85f4fb5b60a6fd8ff11da3e1d963a9c889906a51..4d78f5b2f3d98f9d899da6e10a6be86e91838d5e 100644 (file)
--- a/src/libpakfire/include/pakfire/util.h
+++ b/src/libpakfire/include/pakfire/util.h
@@ -30,11 +30,12 @@
 
 #include <solv/pooltypes.h>
 
+#include <pakfire/package.h>
 #include <pakfire/types.h>
 
 Id pakfire_parse_dep(Pakfire pakfire, const char* s);
-void pakfire_parse_deps(Pakfire pakfire, PakfirePackage pkg,
-       void (*func)(PakfirePackage pkg, const char* dep), const char* deps);
+void pakfire_parse_deps(Pakfire pakfire, struct pakfire_package* pkg,
+       void (*func)(struct pakfire_package* pkg, const char* dep), const char* deps);
 
 #define pakfire_string_format(s, fmt, ...) snprintf(s, sizeof(s) - 1, fmt, __VA_ARGS__)
 #define pakfire_string_set(s, value) pakfire_string_format(s, "%s", value)

diff --git a/src/libpakfire/package.c b/src/libpakfire/package.c
index 54ad798f701215b232420e34fe172651488ebbaf..954ac84a52f62d9e1cb81f4b189081eb595566a2 100644 (file)
--- a/src/libpakfire/package.c
+++ b/src/libpakfire/package.c
@@ -42,7 +42,7 @@
 #include <pakfire/repo.h>
 #include <pakfire/util.h>
 
-struct _PakfirePackage {
+struct pakfire_package {
        Pakfire pakfire;
        int nrefs;
 
@@ -56,15 +56,15 @@ struct _PakfirePackage {
        char path[PATH_MAX];
 };
 
-static void pakfire_package_add_self_provides(Pakfire pakfire, PakfirePackage pkg, const char* name, const char* evr) {
+static void pakfire_package_add_self_provides(Pakfire pakfire, struct pakfire_package* pkg, const char* name, const char* evr) {
        char buffer[1024];
        pakfire_string_format(buffer, "%s = %s", name, evr);
 
        pakfire_package_add_provides(pkg, buffer);
 }
 
-PakfirePackage pakfire_package_create_from_solvable(Pakfire pakfire, Id id) {
-       PakfirePackage pkg = calloc(1, sizeof(*pkg));
+struct pakfire_package* pakfire_package_create_from_solvable(Pakfire pakfire, Id id) {
+       struct pakfire_package* pkg = calloc(1, sizeof(*pkg));
        if (!pkg)
                return NULL;
 
@@ -77,12 +77,12 @@ PakfirePackage pakfire_package_create_from_solvable(Pakfire pakfire, Id id) {
        return pkg;
 }
 
-PAKFIRE_EXPORT PakfirePackage pakfire_package_create(Pakfire pakfire, PakfireRepo repo, const char* name, const char* evr, const char* arch) {
+PAKFIRE_EXPORT struct pakfire_package* pakfire_package_create(Pakfire pakfire, PakfireRepo repo, const char* name, const char* evr, const char* arch) {
        Id id = pakfire_repo_add_solvable(repo);
        if (!id)
                return NULL;
 
-       PakfirePackage pkg = pakfire_package_create_from_solvable(pakfire, id);
+       struct pakfire_package* pkg = pakfire_package_create_from_solvable(pakfire, id);
        if (!pkg)
                return NULL;
 
@@ -99,7 +99,7 @@ PAKFIRE_EXPORT PakfirePackage pakfire_package_create(Pakfire pakfire, PakfireRep
        return pkg;
 }
 
-static void pakfire_package_free(PakfirePackage pkg) {
+static void pakfire_package_free(struct pakfire_package* pkg) {
        if (pkg->repo)
                pakfire_repo_unref(pkg->repo);
 
@@ -107,13 +107,13 @@ static void pakfire_package_free(PakfirePackage pkg) {
        free(pkg);
 }
 
-PAKFIRE_EXPORT PakfirePackage pakfire_package_ref(PakfirePackage pkg) {
+PAKFIRE_EXPORT struct pakfire_package* pakfire_package_ref(struct pakfire_package* pkg) {
        pkg->nrefs++;
 
        return pkg;
 }
 
-PAKFIRE_EXPORT PakfirePackage pakfire_package_unref(PakfirePackage pkg) {
+PAKFIRE_EXPORT struct pakfire_package* pakfire_package_unref(struct pakfire_package* pkg) {
        if (--pkg->nrefs > 0)
                return pkg;
 
@@ -121,21 +121,21 @@ PAKFIRE_EXPORT PakfirePackage pakfire_package_unref(PakfirePackage pkg) {
        return NULL;
 }
 
-PAKFIRE_EXPORT Pakfire pakfire_package_get_pakfire(PakfirePackage pkg) {
+PAKFIRE_EXPORT Pakfire pakfire_package_get_pakfire(struct pakfire_package* pkg) {
        return pakfire_ref(pkg->pakfire);
 }
 
-static Solvable* get_solvable(PakfirePackage pkg) {
+static Solvable* get_solvable(struct pakfire_package* pkg) {
        Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
 
        return pool_id2solvable(pool, pkg->id);
 }
 
-PAKFIRE_EXPORT int pakfire_package_eq(PakfirePackage pkg1, PakfirePackage pkg2) {
+PAKFIRE_EXPORT int pakfire_package_eq(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
        return pkg1->id == pkg2->id;
 }
 
-PAKFIRE_EXPORT int pakfire_package_cmp(PakfirePackage pkg1, PakfirePackage pkg2) {
+PAKFIRE_EXPORT int pakfire_package_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
        Pool* pool = pakfire_get_solv_pool(pkg1->pakfire);
 
        Solvable* s1 = get_solvable(pkg1);
@@ -175,7 +175,7 @@ PAKFIRE_EXPORT int pakfire_package_cmp(PakfirePackage pkg1, PakfirePackage pkg2)
        return strcmp(str1, str2);
 }
 
-PAKFIRE_EXPORT int pakfire_package_evr_cmp(PakfirePackage pkg1, PakfirePackage pkg2) {
+PAKFIRE_EXPORT int pakfire_package_evr_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
        Pool* pool = pakfire_get_solv_pool(pkg1->pakfire);
 
        Solvable* s1 = get_solvable(pkg1);
@@ -184,11 +184,11 @@ PAKFIRE_EXPORT int pakfire_package_evr_cmp(PakfirePackage pkg1, PakfirePackage p
        return pool_evrcmp(pool, s1->evr, s2->evr, EVRCMP_COMPARE);
 }
 
-Id pakfire_package_id(PakfirePackage pkg) {
+Id pakfire_package_id(struct pakfire_package* pkg) {
        return pkg->id;
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_nevra(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_nevra(struct pakfire_package* pkg) {
        if (!*pkg->nevra) {
                Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
                Solvable* s = get_solvable(pkg);
@@ -199,28 +199,28 @@ PAKFIRE_EXPORT const char* pakfire_package_get_nevra(PakfirePackage pkg) {
        return pkg->nevra;
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_name(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_name(struct pakfire_package* pkg) {
        Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
        Solvable* s = get_solvable(pkg);
 
        return pool_id2str(pool, s->name);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_name(PakfirePackage pkg, const char* name) {
+PAKFIRE_EXPORT void pakfire_package_set_name(struct pakfire_package* pkg, const char* name) {
        Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
        Solvable* s = get_solvable(pkg);
 
        s->name = pool_str2id(pool, name, 1);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_evr(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_evr(struct pakfire_package* pkg) {
        Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
        Solvable* s = get_solvable(pkg);
 
        return pool_id2str(pool, s->evr);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_evr(PakfirePackage pkg, const char* evr) {
+PAKFIRE_EXPORT void pakfire_package_set_evr(struct pakfire_package* pkg, const char* evr) {
        Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
        Solvable* s = get_solvable(pkg);
 
@@ -254,21 +254,21 @@ char* pakfire_package_join_evr(const char* e, const char* v, const char* r) {
        return buffer;
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_arch(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_arch(struct pakfire_package* pkg) {
        Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
        Solvable* s = get_solvable(pkg);
 
        return pool_id2str(pool, s->arch);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_arch(PakfirePackage pkg, const char* arch) {
+PAKFIRE_EXPORT void pakfire_package_set_arch(struct pakfire_package* pkg, const char* arch) {
        Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
        Solvable* s = get_solvable(pkg);
 
        s->arch = pool_str2id(pool, arch, 1);
 }
 
-int pakfire_package_is_source(PakfirePackage pkg) {
+int pakfire_package_is_source(struct pakfire_package* pkg) {
        const char* arch = pakfire_package_get_arch(pkg);
        if (!arch)
                return 1;
@@ -276,7 +276,7 @@ int pakfire_package_is_source(PakfirePackage pkg) {
        return (strcmp(arch, "src") == 0);
 }
 
-static void pakfire_package_internalize_repo(PakfirePackage pkg) {
+static void pakfire_package_internalize_repo(struct pakfire_package* pkg) {
        PakfireRepo repo = pakfire_package_get_repo(pkg);
        if (repo) {
                pakfire_repo_internalize(repo);
@@ -284,20 +284,20 @@ static void pakfire_package_internalize_repo(PakfirePackage pkg) {
        }
 }
 
-static unsigned long long pakfire_package_get_num(PakfirePackage pkg, Id type) {
+static unsigned long long pakfire_package_get_num(struct pakfire_package* pkg, Id type) {
        pakfire_package_internalize_repo(pkg);
 
        Solvable* s = get_solvable(pkg);
        return solvable_lookup_num(s, type, 0);
 }
 
-static void pakfire_package_set_num(PakfirePackage pkg, Id type, unsigned long long value) {
+static void pakfire_package_set_num(struct pakfire_package* pkg, Id type, unsigned long long value) {
        Solvable* s = get_solvable(pkg);
 
        solvable_set_num(s, type, value);
 }
 
-static const char* pakfire_package_get_string(PakfirePackage pkg, int key) {
+static const char* pakfire_package_get_string(struct pakfire_package* pkg, int key) {
        pakfire_package_internalize_repo(pkg);
 
        Solvable* s = get_solvable(pkg);
@@ -312,7 +312,7 @@ static const char* pakfire_package_get_string(PakfirePackage pkg, int key) {
        return str;
 }
 
-static void pakfire_package_set_string(PakfirePackage pkg, int key, const char* value) {
+static void pakfire_package_set_string(struct pakfire_package* pkg, int key, const char* value) {
        Solvable* s = get_solvable(pkg);
 
        if (!value)
@@ -321,7 +321,7 @@ static void pakfire_package_set_string(PakfirePackage pkg, int key, const char*
        solvable_set_poolstr(s, key, value);
 }
 
-static char** pakfire_package_get_string_array(PakfirePackage pkg, Id key) {
+static char** pakfire_package_get_string_array(struct pakfire_package* pkg, Id key) {
        char** strings = NULL;
 
        Queue ids;
@@ -351,7 +351,7 @@ static char** pakfire_package_get_string_array(PakfirePackage pkg, Id key) {
        return strings;
 }
 
-static void pakfire_package_add_string_array(PakfirePackage pkg, Id key, const char* value) {
+static void pakfire_package_add_string_array(struct pakfire_package* pkg, Id key, const char* value) {
        if (!value)
                return;
 
@@ -359,63 +359,63 @@ static void pakfire_package_add_string_array(PakfirePackage pkg, Id key, const c
        solvable_add_poolstr_array(s, key, value);
 }
 
-uint64_t pakfire_package_get_dbid(PakfirePackage pkg) {
+uint64_t pakfire_package_get_dbid(struct pakfire_package* pkg) {
        return pakfire_package_get_num(pkg, RPM_RPMDBID);
 }
 
-void pakfire_package_set_dbid(PakfirePackage pkg, uint64_t id) {
+void pakfire_package_set_dbid(struct pakfire_package* pkg, uint64_t id) {
        pakfire_package_set_num(pkg, RPM_RPMDBID, id);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_uuid(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_uuid(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_PKGID);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_uuid(PakfirePackage pkg, const char* uuid) {
+PAKFIRE_EXPORT void pakfire_package_set_uuid(struct pakfire_package* pkg, const char* uuid) {
        pakfire_package_set_string(pkg, SOLVABLE_PKGID, uuid);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_checksum(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_checksum(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_CHECKSUM);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_checksum(PakfirePackage pkg, const char* checksum) {
+PAKFIRE_EXPORT void pakfire_package_set_checksum(struct pakfire_package* pkg, const char* checksum) {
        pakfire_package_set_string(pkg, SOLVABLE_CHECKSUM, checksum);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_summary(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_summary(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_SUMMARY);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_summary(PakfirePackage pkg, const char* summary) {
+PAKFIRE_EXPORT void pakfire_package_set_summary(struct pakfire_package* pkg, const char* summary) {
        pakfire_package_set_string(pkg, SOLVABLE_SUMMARY, summary);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_description(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_description(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_DESCRIPTION);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_description(PakfirePackage pkg, const char* description) {
+PAKFIRE_EXPORT void pakfire_package_set_description(struct pakfire_package* pkg, const char* description) {
        pakfire_package_set_string(pkg, SOLVABLE_DESCRIPTION, description);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_license(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_license(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_LICENSE);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_license(PakfirePackage pkg, const char* license) {
+PAKFIRE_EXPORT void pakfire_package_set_license(struct pakfire_package* pkg, const char* license) {
        pakfire_package_set_string(pkg, SOLVABLE_LICENSE, license);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_url(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_url(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_URL);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_url(PakfirePackage pkg, const char* url) {
+PAKFIRE_EXPORT void pakfire_package_set_url(struct pakfire_package* pkg, const char* url) {
        pakfire_package_set_string(pkg, SOLVABLE_URL, url);
 }
 
-PAKFIRE_EXPORT char* pakfire_package_get_groups(PakfirePackage pkg) {
+PAKFIRE_EXPORT char* pakfire_package_get_groups(struct pakfire_package* pkg) {
        char** groups = pakfire_package_get_string_array(pkg, SOLVABLE_GROUP);
        if (!groups)
                return NULL;
@@ -430,7 +430,7 @@ PAKFIRE_EXPORT char* pakfire_package_get_groups(PakfirePackage pkg) {
        return string;
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_groups(PakfirePackage pkg, const char* groups) {
+PAKFIRE_EXPORT void pakfire_package_set_groups(struct pakfire_package* pkg, const char* groups) {
        char** list = pakfire_split_string(groups, ' ');
        if (!list)
                return;
@@ -443,23 +443,23 @@ PAKFIRE_EXPORT void pakfire_package_set_groups(PakfirePackage pkg, const char* g
        free(list);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_vendor(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_vendor(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_VENDOR);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_vendor(PakfirePackage pkg, const char* vendor) {
+PAKFIRE_EXPORT void pakfire_package_set_vendor(struct pakfire_package* pkg, const char* vendor) {
        pakfire_package_set_string(pkg, SOLVABLE_VENDOR, vendor);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_maintainer(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_maintainer(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_PACKAGER);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_maintainer(PakfirePackage pkg, const char* maintainer) {
+PAKFIRE_EXPORT void pakfire_package_set_maintainer(struct pakfire_package* pkg, const char* maintainer) {
        pakfire_package_set_string(pkg, SOLVABLE_PACKAGER, maintainer);
 }
 
-static int pakfire_package_make_cache_path(PakfirePackage pkg) {
+static int pakfire_package_make_cache_path(struct pakfire_package* pkg) {
        const char* filename = pakfire_package_get_filename(pkg);
        const char* checksum = pakfire_package_get_checksum(pkg);
 
@@ -470,7 +470,7 @@ static int pakfire_package_make_cache_path(PakfirePackage pkg) {
                "%c%c/%s/%s", checksum[0], checksum[1], checksum + 2, filename);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_path(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_path(struct pakfire_package* pkg) {
        int r;
 
        if (!*pkg->path) {
@@ -491,7 +491,7 @@ PAKFIRE_EXPORT const char* pakfire_package_get_path(PakfirePackage pkg) {
        return pkg->path;
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_path(PakfirePackage pkg, const char* path) {
+PAKFIRE_EXPORT void pakfire_package_set_path(struct pakfire_package* pkg, const char* path) {
        char* basename = pakfire_basename(path);
        char* dirname  = pakfire_dirname(path);
 
@@ -522,7 +522,7 @@ static const char* evr2vr(const char* evr) {
        return evr;
 }
 
-static const char* pakfire_package_make_filename(PakfirePackage pkg) {
+static const char* pakfire_package_make_filename(struct pakfire_package* pkg) {
        if (!*pkg->filename) {
                const char* name = pakfire_package_get_name(pkg);
                const char* evr  = pakfire_package_get_evr(pkg);
@@ -539,7 +539,7 @@ static const char* pakfire_package_make_filename(PakfirePackage pkg) {
        return pkg->filename;
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_filename(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_filename(struct pakfire_package* pkg) {
        const char* filename = pakfire_package_get_string(pkg, SOLVABLE_MEDIAFILE);
 
        // Generate the filename if not set
@@ -549,74 +549,74 @@ PAKFIRE_EXPORT const char* pakfire_package_get_filename(PakfirePackage pkg) {
        return filename;
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_filename(PakfirePackage pkg, const char* filename) {
+PAKFIRE_EXPORT void pakfire_package_set_filename(struct pakfire_package* pkg, const char* filename) {
        pakfire_package_set_string(pkg, SOLVABLE_MEDIAFILE, filename);
 }
 
-PAKFIRE_EXPORT int pakfire_package_is_installed(PakfirePackage pkg) {
+PAKFIRE_EXPORT int pakfire_package_is_installed(struct pakfire_package* pkg) {
        Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
        Solvable* s = get_solvable(pkg);
 
        return pool->installed == s->repo;
 }
 
-PAKFIRE_EXPORT unsigned long long pakfire_package_get_downloadsize(PakfirePackage pkg) {
+PAKFIRE_EXPORT unsigned long long pakfire_package_get_downloadsize(struct pakfire_package* pkg) {
        return pakfire_package_get_num(pkg, SOLVABLE_DOWNLOADSIZE);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_downloadsize(PakfirePackage pkg, unsigned long long downloadsize) {
+PAKFIRE_EXPORT void pakfire_package_set_downloadsize(struct pakfire_package* pkg, unsigned long long downloadsize) {
        return pakfire_package_set_num(pkg, SOLVABLE_DOWNLOADSIZE, downloadsize);
 }
 
-PAKFIRE_EXPORT unsigned long long pakfire_package_get_installsize(PakfirePackage pkg) {
+PAKFIRE_EXPORT unsigned long long pakfire_package_get_installsize(struct pakfire_package* pkg) {
        return pakfire_package_get_num(pkg, SOLVABLE_INSTALLSIZE);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_installsize(PakfirePackage pkg, unsigned long long installsize) {
+PAKFIRE_EXPORT void pakfire_package_set_installsize(struct pakfire_package* pkg, unsigned long long installsize) {
        return pakfire_package_set_num(pkg, SOLVABLE_INSTALLSIZE, installsize);
 }
 
-PAKFIRE_EXPORT unsigned long long pakfire_package_get_size(PakfirePackage pkg) {
+PAKFIRE_EXPORT unsigned long long pakfire_package_get_size(struct pakfire_package* pkg) {
        if (pakfire_package_is_installed(pkg))
                return pakfire_package_get_installsize(pkg);
 
        return pakfire_package_get_downloadsize(pkg);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_build_host(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_build_host(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_BUILDHOST);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_build_host(PakfirePackage pkg, const char* build_host) {
+PAKFIRE_EXPORT void pakfire_package_set_build_host(struct pakfire_package* pkg, const char* build_host) {
        pakfire_package_set_string(pkg, SOLVABLE_BUILDHOST, build_host);
 }
 
-PAKFIRE_EXPORT const char* pakfire_package_get_build_id(PakfirePackage pkg) {
+PAKFIRE_EXPORT const char* pakfire_package_get_build_id(struct pakfire_package* pkg) {
        return pakfire_package_get_string(pkg, SOLVABLE_BUILDVERSION);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_build_id(PakfirePackage pkg, const char* build_id) {
+PAKFIRE_EXPORT void pakfire_package_set_build_id(struct pakfire_package* pkg, const char* build_id) {
        pakfire_package_set_string(pkg, SOLVABLE_BUILDVERSION, build_id);
 }
 
-PAKFIRE_EXPORT time_t pakfire_package_get_build_time(PakfirePackage pkg) {
+PAKFIRE_EXPORT time_t pakfire_package_get_build_time(struct pakfire_package* pkg) {
        return pakfire_package_get_num(pkg, SOLVABLE_BUILDTIME);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_build_time(PakfirePackage pkg, time_t build_time) {
+PAKFIRE_EXPORT void pakfire_package_set_build_time(struct pakfire_package* pkg, time_t build_time) {
        pakfire_package_set_num(pkg, SOLVABLE_BUILDTIME, build_time);
 }
 
-PAKFIRE_EXPORT time_t pakfire_package_get_install_time(PakfirePackage pkg) {
+PAKFIRE_EXPORT time_t pakfire_package_get_install_time(struct pakfire_package* pkg) {
        return pakfire_package_get_num(pkg, SOLVABLE_INSTALLTIME);
 }
 
-PAKFIRE_EXPORT void pakfire_package_set_install_time(PakfirePackage pkg, time_t install_time) {
+PAKFIRE_EXPORT void pakfire_package_set_install_time(struct pakfire_package* pkg, time_t install_time) {
        pakfire_package_set_num(pkg, SOLVABLE_INSTALLTIME, install_time);
 }
 
 static char** pakfire_package_get_relationlist(
-               PakfirePackage pkg, Id type, Id marker) {
+               struct pakfire_package* pkg, Id type, Id marker) {
        char** array = NULL;
 
        Queue q;
@@ -650,7 +650,7 @@ ERROR:
        return array;
 }
 
-static void pakfire_package_add_dep(PakfirePackage pkg, Id type,
+static void pakfire_package_add_dep(struct pakfire_package* pkg, Id type,
                const char* dep, Id marker) {
        Solvable* s = get_solvable(pkg);
 
@@ -662,79 +662,79 @@ static void pakfire_package_add_dep(PakfirePackage pkg, Id type,
        solvable_add_deparray(s, type, id, marker);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_provides(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_provides(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_PROVIDES, -SOLVABLE_FILEMARKER);
 }
 
-void pakfire_package_add_provides(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_provides(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_PROVIDES, dep, -SOLVABLE_FILEMARKER);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_prerequires(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_prerequires(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_REQUIRES, SOLVABLE_PREREQMARKER);
 }
 
-void pakfire_package_add_prerequires(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_prerequires(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_REQUIRES, dep, SOLVABLE_PREREQMARKER);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_requires(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_requires(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_REQUIRES, -SOLVABLE_PREREQMARKER);
 }
 
-void pakfire_package_add_requires(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_requires(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_REQUIRES, dep, -SOLVABLE_PREREQMARKER);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_conflicts(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_conflicts(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_CONFLICTS, 0);
 }
 
-void pakfire_package_add_conflicts(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_conflicts(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_CONFLICTS, dep, 0);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_obsoletes(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_obsoletes(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_OBSOLETES, 0);
 }
 
-void pakfire_package_add_obsoletes(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_obsoletes(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_OBSOLETES, dep, 0);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_recommends(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_recommends(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_RECOMMENDS, 0);
 }
 
-void pakfire_package_add_recommends(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_recommends(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_RECOMMENDS, dep, 0);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_suggests(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_suggests(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_SUGGESTS, 0);
 }
 
-void pakfire_package_add_suggests(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_suggests(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_SUGGESTS, dep, 0);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_supplements(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_supplements(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_SUPPLEMENTS, 0);
 }
 
-void pakfire_package_add_supplements(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_supplements(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_SUPPLEMENTS, dep, 0);
 }
 
-PAKFIRE_EXPORT char** pakfire_package_get_enhances(PakfirePackage pkg) {
+PAKFIRE_EXPORT char** pakfire_package_get_enhances(struct pakfire_package* pkg) {
        return pakfire_package_get_relationlist(pkg, SOLVABLE_ENHANCES, 0);
 }
 
-void pakfire_package_add_enhances(PakfirePackage pkg, const char* dep) {
+void pakfire_package_add_enhances(struct pakfire_package* pkg, const char* dep) {
        pakfire_package_add_dep(pkg, SOLVABLE_ENHANCES, dep, 0);
 }
 
-PAKFIRE_EXPORT int pakfire_package_get_reverse_requires(PakfirePackage pkg,
+PAKFIRE_EXPORT int pakfire_package_get_reverse_requires(struct pakfire_package* pkg,
                struct pakfire_packagelist** list) {
        Queue matches;
        queue_init(&matches);
@@ -758,7 +758,7 @@ ERROR:
        return r;
 }
 
-PAKFIRE_EXPORT PakfireRepo pakfire_package_get_repo(PakfirePackage pkg) {
+PAKFIRE_EXPORT PakfireRepo pakfire_package_get_repo(struct pakfire_package* pkg) {
        if (!pkg->repo) {
                Solvable* s = get_solvable(pkg);
 
@@ -808,7 +808,7 @@ static int pakfire_sort_dependencies(const void* p1, const void* p2) {
        return strcmp(dep1, dep2);
 }
 
-PAKFIRE_EXPORT char* pakfire_package_dump(PakfirePackage pkg, int flags) {
+PAKFIRE_EXPORT char* pakfire_package_dump(struct pakfire_package* pkg, int flags) {
        char* string = "";
 
        // Name
@@ -905,7 +905,7 @@ PAKFIRE_EXPORT char* pakfire_package_dump(PakfirePackage pkg, int flags) {
 
                const struct relation {
                        const char* name;
-                       char** (*get)(PakfirePackage pkg);
+                       char** (*get)(struct pakfire_package* pkg);
                } relations[] = {
                        { _("Provides"),     pakfire_package_get_provides, },
                        { _("Pre-Requires"), pakfire_package_get_prerequires, },
@@ -968,7 +968,7 @@ PAKFIRE_EXPORT char* pakfire_package_dump(PakfirePackage pkg, int flags) {
        return string;
 }
 
-PAKFIRE_EXPORT PakfireArchive pakfire_package_get_archive(PakfirePackage pkg) {
+PAKFIRE_EXPORT PakfireArchive pakfire_package_get_archive(struct pakfire_package* pkg) {
        PakfireArchive archive;
 
        // Otherwise open the archive from the cache
@@ -985,7 +985,7 @@ PAKFIRE_EXPORT PakfireArchive pakfire_package_get_archive(PakfirePackage pkg) {
        return NULL;
 }
 
-static int pakfire_package_fetch_legacy_filelist(PakfirePackage pkg, PakfireFilelist filelist) {
+static int pakfire_package_fetch_legacy_filelist(struct pakfire_package* pkg, PakfireFilelist filelist) {
        pakfire_package_internalize_repo(pkg);
 
        PakfireRepo repo = pakfire_package_get_repo(pkg);
@@ -1026,7 +1026,7 @@ static int pakfire_package_fetch_legacy_filelist(PakfirePackage pkg, PakfireFile
        return 0;
 }
 
-static int pakfire_package_fetch_filelist(PakfirePackage pkg, PakfireFilelist filelist) {
+static int pakfire_package_fetch_filelist(struct pakfire_package* pkg, PakfireFilelist filelist) {
        int r;
 
        pakfire_package_internalize_repo(pkg);
@@ -1066,7 +1066,7 @@ static int pakfire_package_fetch_filelist(PakfirePackage pkg, PakfireFilelist fi
        return 0;
 }
 
-PAKFIRE_EXPORT PakfireFilelist pakfire_package_get_filelist(PakfirePackage pkg) {
+PAKFIRE_EXPORT PakfireFilelist pakfire_package_get_filelist(struct pakfire_package* pkg) {
        PakfireFilelist filelist;
 
        int r = pakfire_filelist_create(&filelist, pkg->pakfire);
@@ -1082,7 +1082,7 @@ PAKFIRE_EXPORT PakfireFilelist pakfire_package_get_filelist(PakfirePackage pkg)
        return filelist;
 }
 
-static int pakfire_package_append_file(PakfirePackage pkg, const char* path) {
+static int pakfire_package_append_file(struct pakfire_package* pkg, const char* path) {
        // Fetch repodata
        PakfireRepo repo = pakfire_package_get_repo(pkg);
        Repodata* repodata = pakfire_repo_get_repodata(repo);
@@ -1106,7 +1106,7 @@ static int pakfire_package_append_file(PakfirePackage pkg, const char* path) {
        return 0;
 }
 
-PAKFIRE_EXPORT int pakfire_package_set_filelist(PakfirePackage pkg, PakfireFilelist filelist) {
+PAKFIRE_EXPORT int pakfire_package_set_filelist(struct pakfire_package* pkg, PakfireFilelist filelist) {
        int r;
 
        for (unsigned int i = 0; i < pakfire_filelist_size(filelist); i++) {
@@ -1127,7 +1127,7 @@ PAKFIRE_EXPORT int pakfire_package_set_filelist(PakfirePackage pkg, PakfireFilel
        return 0;
 }
 
-int pakfire_package_set_filelist_from_string(PakfirePackage pkg, const char* files) {
+int pakfire_package_set_filelist_from_string(struct pakfire_package* pkg, const char* files) {
        // Total length of the input string
        size_t size = strlen(files);
 

diff --git a/src/libpakfire/packagelist.c b/src/libpakfire/packagelist.c
index ecb2e9e0cb954f73cc92b0d9c00e318e7d2aa287..01e28a18c96c44a5859645009a42976d8c2ac23e 100644 (file)
--- a/src/libpakfire/packagelist.c
+++ b/src/libpakfire/packagelist.c
@@ -39,7 +39,7 @@ struct pakfire_packagelist {
        Pakfire pakfire;
        int nrefs;
 
-       PakfirePackage* elements;
+       struct pakfire_package** elements;
        size_t count;
 };
 
@@ -63,7 +63,7 @@ int pakfire_packagelist_create_from_queue(struct pakfire_packagelist** list, Pak
                return r;
 
        for (int i = 0; i < q->count; i++) {
-               PakfirePackage pkg = pakfire_package_create_from_solvable(pakfire, q->elements[i]);
+               struct pakfire_package* pkg = pakfire_package_create_from_solvable(pakfire, q->elements[i]);
                pakfire_packagelist_push(*list, pkg);
                pakfire_package_unref(pkg);
        }
@@ -101,21 +101,21 @@ PAKFIRE_EXPORT size_t pakfire_packagelist_count(struct pakfire_packagelist* list
 }
 
 PAKFIRE_EXPORT int _packagelist_cmp(const void* pkg1, const void* pkg2) {
-       return pakfire_package_cmp(*(PakfirePackage*)pkg1, *(PakfirePackage*)pkg2);
+       return pakfire_package_cmp(*(struct pakfire_package**)pkg1, *(struct pakfire_package**)pkg2);
 }
 
 PAKFIRE_EXPORT void pakfire_packagelist_sort(struct pakfire_packagelist* list) {
        qsort(list->elements, list->count, sizeof(*list->elements), _packagelist_cmp);
 }
 
-PAKFIRE_EXPORT PakfirePackage pakfire_packagelist_get(struct pakfire_packagelist* list, unsigned int index) {
+PAKFIRE_EXPORT struct pakfire_package* pakfire_packagelist_get(struct pakfire_packagelist* list, unsigned int index) {
        if (index < list->count)
                return pakfire_package_ref(list->elements[index]);
 
        return NULL;
 }
 
-static int pakfire_packagelist_has(struct pakfire_packagelist* list, PakfirePackage pkg) {
+static int pakfire_packagelist_has(struct pakfire_packagelist* list, struct pakfire_package* pkg) {
        for (unsigned int i = 0; i < list->count; i++) {
                if (pakfire_package_eq(pkg, list->elements[i]))
                        return 1;
@@ -124,12 +124,12 @@ static int pakfire_packagelist_has(struct pakfire_packagelist* list, PakfirePack
        return 0;
 }
 
-PAKFIRE_EXPORT void pakfire_packagelist_push(struct pakfire_packagelist* list, PakfirePackage pkg) {
+PAKFIRE_EXPORT void pakfire_packagelist_push(struct pakfire_packagelist* list, struct pakfire_package* pkg) {
        list->elements = solv_extend(list->elements, list->count, 1, sizeof(pkg), BLOCK_SIZE);
        list->elements[list->count++] = pakfire_package_ref(pkg);
 }
 
-PAKFIRE_EXPORT void pakfire_packagelist_push_if_not_exists(struct pakfire_packagelist* list, PakfirePackage pkg) {
+PAKFIRE_EXPORT void pakfire_packagelist_push_if_not_exists(struct pakfire_packagelist* list, struct pakfire_package* pkg) {
        if (pakfire_packagelist_has(list, pkg))
                return;
 

diff --git a/src/libpakfire/packager.c b/src/libpakfire/packager.c
index 5dd576bd2352d40b1e326d6b7885881384293bad..607a03e682682fde9ebb2073e8e7008645d4ec67 100644 (file)
--- a/src/libpakfire/packager.c
+++ b/src/libpakfire/packager.c
@@ -47,7 +47,7 @@ struct pakfire_packager {
        int nrefs;
        time_t time_created;
 
-       PakfirePackage pkg;
+       struct pakfire_package* pkg;
        char filename[PATH_MAX];
 
        // Reader
@@ -253,7 +253,7 @@ static void pakfire_packager_free(struct pakfire_packager* packager) {
 }
 
 int pakfire_packager_create(struct pakfire_packager** packager,
-               PakfirePackage pkg) {
+               struct pakfire_package* pkg) {
        struct pakfire_packager* p = calloc(1, sizeof(*p));
        if (!p)
                return ENOMEM;
@@ -449,7 +449,7 @@ static int pakfire_packager_write_format(struct pakfire_packager* packager,
 }
 
 static char* pakfire_package_make_metadata(struct pakfire_packager* packager) {
-       PakfirePackage pkg = packager->pkg;
+       struct pakfire_package* pkg = packager->pkg;
 
        char* buffer = NULL;
        int r;
@@ -589,7 +589,7 @@ static char* pakfire_package_make_metadata(struct pakfire_packager* packager) {
 
        const struct dependencies {
                const char* type;
-               char** (*func)(PakfirePackage pkg);
+               char** (*func)(struct pakfire_package* pkg);
        } dependencies[] = {
                { "prerequires", pakfire_package_get_prerequires },
                { "requires",    pakfire_package_get_requires },

diff --git a/src/libpakfire/pakfire.c b/src/libpakfire/pakfire.c
index 017ccc57f1e59957e5b6d26b2d0ae7c3265851ca..31763e9c618193eadae9be9c76a072ffe0d9fb6b 100644 (file)
--- a/src/libpakfire/pakfire.c
+++ b/src/libpakfire/pakfire.c
@@ -1308,7 +1308,7 @@ static struct pakfire_packagelist* pakfire_pool_dataiterator(Pakfire pakfire, co
        Dataiterator di;
        dataiterator_init(&di, pakfire->pool, 0, 0, key, what, di_flags);
        while (dataiterator_step(&di)) {
-               PakfirePackage pkg = pakfire_package_create_from_solvable(pakfire, di.solvid);
+               struct pakfire_package* pkg = pakfire_package_create_from_solvable(pakfire, di.solvid);
                pakfire_packagelist_push_if_not_exists(list, pkg);
        }
        dataiterator_free(&di);
@@ -1336,7 +1336,7 @@ static struct pakfire_packagelist* pakfire_search_name(Pakfire pakfire, const ch
                        Solvable* s = pool_id2solvable(pakfire->pool, p);
 
                        if (s->name == id) {
-                               PakfirePackage pkg = pakfire_package_create_from_solvable(pakfire, p);
+                               struct pakfire_package* pkg = pakfire_package_create_from_solvable(pakfire, p);
                                pakfire_packagelist_push_if_not_exists(list, pkg);
                        }
                }
@@ -1364,7 +1364,7 @@ static struct pakfire_packagelist* pakfire_search_provides(Pakfire pakfire, cons
                Id p, pp;
                Pool* pool = pakfire->pool;
                FOR_PROVIDES(p, pp, id) {
-                       PakfirePackage pkg = pakfire_package_create_from_solvable(pakfire, p);
+                       struct pakfire_package* pkg = pakfire_package_create_from_solvable(pakfire, p);
                        pakfire_packagelist_push_if_not_exists(list, pkg);
                }
 

diff --git a/src/libpakfire/parser.c b/src/libpakfire/parser.c
index a0de7048741fc507c274a1e2a801be0216b58132..fa4c74f3d5e2b7a9d403ce1a6184473286b390d0 100644 (file)
--- a/src/libpakfire/parser.c
+++ b/src/libpakfire/parser.c
@@ -868,7 +868,7 @@ ERROR:
 }
 
 PAKFIRE_EXPORT int pakfire_parser_create_package(PakfireParser parser,
-               PakfirePackage* pkg, PakfireRepo repo, const char* namespace, const char* default_arch) {
+               struct pakfire_package** pkg, PakfireRepo repo, const char* namespace, const char* default_arch) {
        int r = 1;
 
        char* name = NULL;
@@ -964,7 +964,7 @@ PAKFIRE_EXPORT int pakfire_parser_create_package(PakfireParser parser,
        // Assign more attributes
        const struct attribute {
                const char* name;
-               void(*func)(PakfirePackage pkg, const char* value);
+               void(*func)(struct pakfire_package* pkg, const char* value);
        } attributes[] = {
                { "summary", pakfire_package_set_summary, },
                { "description", pakfire_package_set_description, },
@@ -996,7 +996,7 @@ PAKFIRE_EXPORT int pakfire_parser_create_package(PakfireParser parser,
        } else {
                const struct relation {
                        const char* type;
-                       void (*func)(PakfirePackage, const char* dep);
+                       void (*func)(struct pakfire_package*, const char* dep);
                } relations[] = {
                        { "provides", pakfire_package_add_provides },
                        { "prerequires", pakfire_package_add_prerequires },

diff --git a/src/libpakfire/repo.c b/src/libpakfire/repo.c
index 4c4528b00156693ddf2a5defdeae890868ea9681..8b90d55ef1c236ab10a70c3e93a9d0abbfb69beb 100644 (file)
--- a/src/libpakfire/repo.c
+++ b/src/libpakfire/repo.c
@@ -798,7 +798,7 @@ PAKFIRE_EXPORT int pakfire_repo_write_solv_fp(PakfireRepo repo, FILE *f, int fla
        return repo_write(repo->repo, f);
 }
 
-PAKFIRE_EXPORT PakfirePackage pakfire_repo_add_archive(PakfireRepo repo, PakfireArchive archive) {
+PAKFIRE_EXPORT struct pakfire_package* pakfire_repo_add_archive(PakfireRepo repo, PakfireArchive archive) {
        return pakfire_archive_make_package(archive, repo);
 }
 
@@ -834,7 +834,7 @@ static int pakfire_repo_scan_file(PakfireRepo repo, const char* path) {
                return r;
 
        // Import package into the repository
-       PakfirePackage pkg = pakfire_archive_make_package(archive, repo);
+       struct pakfire_package* pkg = pakfire_archive_make_package(archive, repo);
        if (!pkg) {
                pakfire_archive_unref(archive);
                return errno;

diff --git a/src/libpakfire/request.c b/src/libpakfire/request.c
index 4cd7ac4ff9440c1f9d4967abf2f7b6862b33b96f..19d3f3f4c88b5cebdc3883b22d762f01e7460c53 100644 (file)
--- a/src/libpakfire/request.c
+++ b/src/libpakfire/request.c
@@ -317,7 +317,7 @@ static int pakfire_request_is_url(const char* what) {
 }
 
 static int pakfire_request_add_package(struct pakfire_request* request, int action,
-               PakfirePackage pkg, int flags) {
+               struct pakfire_package* pkg, int flags) {
        // Get the solvable ID
        Id id = pakfire_package_id(pkg);
 
@@ -401,7 +401,7 @@ static int pakfire_request_add_archive(struct pakfire_request* request, int acti
                return 1;
 
        // Add it to the repository
-       PakfirePackage pkg = pakfire_repo_add_archive(repo, archive);
+       struct pakfire_package* pkg = pakfire_repo_add_archive(repo, archive);
        if (!pkg)
                goto ERROR;
 
@@ -509,7 +509,7 @@ PAKFIRE_EXPORT int pakfire_request_install(struct pakfire_request* request,
 }
 
 PAKFIRE_EXPORT int pakfire_request_install_package(
-               struct pakfire_request* request, PakfirePackage package) {
+               struct pakfire_request* request, struct pakfire_package* package) {
        return pakfire_request_add_package(request, SOLVER_INSTALL, package, 0);
 }
 
@@ -528,7 +528,7 @@ PAKFIRE_EXPORT int pakfire_request_erase(struct pakfire_request* request, const
 }
 
 PAKFIRE_EXPORT int pakfire_request_erase_package(
-               struct pakfire_request* request, PakfirePackage package, int flags) {
+               struct pakfire_request* request, struct pakfire_package* package, int flags) {
        return pakfire_request_add_package(request, SOLVER_ERASE, package, erase_flags(flags));
 }
 
@@ -537,7 +537,7 @@ PAKFIRE_EXPORT int pakfire_request_upgrade(struct pakfire_request* request, cons
 }
 
 PAKFIRE_EXPORT int pakfire_request_upgrade_package(
-               struct pakfire_request* request, PakfirePackage package) {
+               struct pakfire_request* request, struct pakfire_package* package) {
        return pakfire_request_add_package(request, SOLVER_UPDATE, package, 0);
 }
 
@@ -563,7 +563,7 @@ PAKFIRE_EXPORT int pakfire_request_lock(struct pakfire_request* request, const c
        return pakfire_request_add(request, SOLVER_LOCK, what, 0);
 }
 
-PAKFIRE_EXPORT int pakfire_request_lock_package(struct pakfire_request* request, PakfirePackage package) {
+PAKFIRE_EXPORT int pakfire_request_lock_package(struct pakfire_request* request, struct pakfire_package* package) {
        return pakfire_request_add_package(request, SOLVER_LOCK, package, 0);
 }
 

diff --git a/src/libpakfire/transaction.c b/src/libpakfire/transaction.c
index 0d2ba8591d6815471575cd989c0f2ddbb5e32abc..a2cf3b72b719a46c74d6a0ecf260cbc72a5a48e9 100644 (file)
--- a/src/libpakfire/transaction.c
+++ b/src/libpakfire/transaction.c
@@ -48,12 +48,12 @@ struct pakfire_transaction {
        char** userinstalled;
 
        PakfireArchive* archives;
-       PakfirePackage* packages;
+       struct pakfire_package** packages;
        size_t num;
 };
 
 static pakfire_step_type_t pakfire_transaction_get_step_type(
-               struct pakfire_transaction* transaction, PakfirePackage pkg) {
+               struct pakfire_transaction* transaction, struct pakfire_package* pkg) {
        int type = transaction_type(transaction->transaction, pakfire_package_id(pkg),
                SOLVER_TRANSACTION_SHOW_ACTIVE|SOLVER_TRANSACTION_CHANGE_IS_REINSTALL);
 
@@ -306,7 +306,7 @@ static void pakfire_transaction_add_line(char*** lines, size_t width, const char
                name, arch, version, repo, size);
 }
 
-static void pakfire_transaction_add_package(char*** lines, size_t width, PakfirePackage pkg) {
+static void pakfire_transaction_add_package(char*** lines, size_t width, struct pakfire_package* pkg) {
        char size[128];
 
        PakfireRepo repo = pakfire_package_get_repo(pkg);
@@ -326,7 +326,7 @@ static void pakfire_transaction_add_package(char*** lines, size_t width, Pakfire
 }
 
 static void pakfire_transaction_add_package_change(char*** lines, size_t width,
-               PakfirePackage old_pkg, PakfirePackage new_pkg) {
+               struct pakfire_package* old_pkg, struct pakfire_package* new_pkg) {
        // Print the new package first
        pakfire_transaction_add_package(lines, width, new_pkg);
 
@@ -494,9 +494,9 @@ PAKFIRE_EXPORT char* pakfire_transaction_dump(struct pakfire_transaction* transa
 
                // List all packages
                for (int j = 0; j < pkgs.count; j++) {
-                       PakfirePackage old_pkg = pakfire_package_create_from_solvable(
+                       struct pakfire_package* old_pkg = pakfire_package_create_from_solvable(
                                transaction->pakfire, pkgs.elements[j]);
-                       PakfirePackage new_pkg = NULL;
+                       struct pakfire_package* new_pkg = NULL;
 
                        switch (class) {
                                case SOLVER_TRANSACTION_UPGRADED:
@@ -556,7 +556,7 @@ PAKFIRE_EXPORT char* pakfire_transaction_dump(struct pakfire_transaction* transa
 }
 
 static int pakfire_transaction_verify(struct pakfire_transaction* transaction,
-               PakfirePackage pkg, PakfireArchive archive) {
+               struct pakfire_package* pkg, PakfireArchive archive) {
        // Nothing to do if this step does not have an archive
        if (!archive)
                return 0;
@@ -574,7 +574,7 @@ static int pakfire_transaction_verify(struct pakfire_transaction* transaction,
 }
 
 static int pakfire_transaction_run_script(struct pakfire_transaction* transaction,
-               struct pakfire_db* db, const char* type, PakfirePackage pkg, PakfireArchive archive) {
+               struct pakfire_db* db, const char* type, struct pakfire_package* pkg, PakfireArchive archive) {
        struct pakfire_scriptlet* scriptlet = NULL;
 
        // Fetch scriptlet from archive if possible
@@ -596,7 +596,7 @@ static int pakfire_transaction_run_script(struct pakfire_transaction* transactio
 }
 
 static int pakfire_transaction_extract(struct pakfire_transaction* transaction,
-               PakfirePackage pkg, PakfireArchive archive) {
+               struct pakfire_package* pkg, PakfireArchive archive) {
        // Extract payload to the root of the Pakfire instance
        int r = pakfire_archive_extract(archive, NULL);
        if (r) {
@@ -621,7 +621,7 @@ static int pakfire_transaction_extract(struct pakfire_transaction* transaction,
 }
 
 static int pakfire_transaction_erase(struct pakfire_transaction* transaction,
-               struct pakfire_db* db, PakfirePackage pkg) {
+               struct pakfire_db* db, struct pakfire_package* pkg) {
        PakfireFilelist filelist = NULL;
        int r;
 
@@ -677,7 +677,7 @@ static const char* pakfire_action_type_string(pakfire_action_type_t type) {
 }
 
 static int pakfire_transaction_package_is_userinstalled(
-               struct pakfire_transaction* transaction, PakfirePackage pkg) {
+               struct pakfire_transaction* transaction, struct pakfire_package* pkg) {
        // No packages on the list
        if (!transaction->userinstalled)
                return 0;
@@ -695,7 +695,7 @@ static int pakfire_transaction_package_is_userinstalled(
 }
 
 static int pakfire_transaction_run_step(struct pakfire_transaction* transaction,
-               struct pakfire_db* db, const pakfire_action_type_t action, PakfirePackage pkg, PakfireArchive archive) {
+               struct pakfire_db* db, const pakfire_action_type_t action, struct pakfire_package* pkg, PakfireArchive archive) {
        if (!pkg) {
                errno = EINVAL;
                return 1;
@@ -871,7 +871,7 @@ static int pakfire_transaction_run_steps(struct pakfire_transaction* transaction
 
 static int pakfire_transaction_open_archives(struct pakfire_transaction* transaction) {
        for (unsigned int i = 0; i < transaction->num; i++) {
-               PakfirePackage pkg = transaction->packages[i];
+               struct pakfire_package* pkg = transaction->packages[i];
 
                // Fetch the type
                pakfire_step_type_t type = pakfire_transaction_get_step_type(transaction, pkg);
@@ -959,7 +959,7 @@ ERROR:
 }
 
 static int pakfire_transaction_download_package(struct pakfire_transaction* transaction,
-               struct pakfire_downloader* downloader, PakfirePackage pkg) {
+               struct pakfire_downloader* downloader, struct pakfire_package* pkg) {
        int r = 1;
        PakfireRepo repo = NULL;
        struct pakfire_mirrorlist* mirrorlist = NULL;
@@ -1003,7 +1003,7 @@ ERROR:
 }
 
 static int pakfire_transaction_package_needs_download(
-               struct pakfire_transaction* transaction, PakfirePackage pkg) {
+               struct pakfire_transaction* transaction, struct pakfire_package* pkg) {
        pakfire_step_type_t type = pakfire_transaction_get_step_type(transaction, pkg);
        switch (type) {
                case PAKFIRE_STEP_INSTALL:
@@ -1045,7 +1045,7 @@ PAKFIRE_EXPORT int pakfire_transaction_download(struct pakfire_transaction* tran
 
        // Add all packages that need to be downloaded
        for (unsigned int i = 0; i < transaction->num; i++) {
-               PakfirePackage pkg = transaction->packages[i];
+               struct pakfire_package* pkg = transaction->packages[i];
 
                if (!pakfire_transaction_package_needs_download(transaction, pkg))
                        continue;

diff --git a/src/libpakfire/util.c b/src/libpakfire/util.c
index ec1ef369e41bc6e9bcae2c3006a5bf3996f070be..f3e16b2ed42fe559c9354387f5720e6f999051b9 100644 (file)
--- a/src/libpakfire/util.c
+++ b/src/libpakfire/util.c
@@ -42,6 +42,7 @@
 
 #include <pakfire/constants.h>
 #include <pakfire/logging.h>
+#include <pakfire/package.h>
 #include <pakfire/types.h>
 #include <pakfire/util.h>
 
@@ -133,8 +134,8 @@ Id pakfire_parse_dep(Pakfire pakfire, const char* s) {
        return id;
 }
 
-void pakfire_parse_deps(Pakfire pakfire, PakfirePackage pkg,
-               void (*func)(PakfirePackage pkg, const char* dep), const char* deps) {
+void pakfire_parse_deps(Pakfire pakfire, struct pakfire_package* pkg,
+               void (*func)(struct pakfire_package* pkg, const char* dep), const char* deps) {
        char* p = strdupa(deps);
 
        while (*p) {

diff --git a/tests/libpakfire/archive.c b/tests/libpakfire/archive.c
index 5c152be4d2cf774a724d2f6dfbd864f5014edd87..4ec03a6af4b48823778d92e8744edd0e1f6f1909 100644 (file)
--- a/tests/libpakfire/archive.c
+++ b/tests/libpakfire/archive.c
@@ -100,7 +100,7 @@ static int test_import(const struct test* t) {
        PakfireRepo repo = pakfire_repo_create(t->pakfire, "tmp");
        ASSERT(repo);
 
-       PakfirePackage pkg = pakfire_repo_add_archive(repo, archive);
+       struct pakfire_package* pkg = pakfire_repo_add_archive(repo, archive);
        ASSERT(pkg);
 
        pakfire_repo_unref(repo);

diff --git a/tests/libpakfire/db.c b/tests/libpakfire/db.c
index 929f58017f8bd6540118154d648f23d0fbc3c848..f51aabf92cdb5359898a50ceaca253151ca106ed 100644 (file)
--- a/tests/libpakfire/db.c
+++ b/tests/libpakfire/db.c
@@ -83,7 +83,7 @@ static int test_add_package(const struct test* t) {
        ASSERT(archive);
 
        // Get package
-       PakfirePackage pkg = pakfire_archive_make_package(archive, repo);
+       struct pakfire_package* pkg = pakfire_archive_make_package(archive, repo);
        ASSERT(pkg);
 
        // Try to add the package to the database

diff --git a/tests/libpakfire/makefile.c b/tests/libpakfire/makefile.c
index e3bc9d7712da4b446e50d7b8801be6456d915450..324a5de654f9ae0eaef26a9973fdc5be97d2bd92 100644 (file)
--- a/tests/libpakfire/makefile.c
+++ b/tests/libpakfire/makefile.c
@@ -93,7 +93,7 @@ static int test_macros(const struct test* t) {
 }
 
 static int test_packages(const struct test* t) {
-       PakfirePackage pkg = NULL;
+       struct pakfire_package* pkg = NULL;
 
        PakfireRepo repo = pakfire_repo_create(t->pakfire, "test");
        ASSERT(repo);

diff --git a/tests/libpakfire/packager.c b/tests/libpakfire/packager.c
index 8f3e94a7dbbb2039a983a5ff20adf10718fd899d..3771de44bdfc41b51cddb0cc51a2b0d1ee4904d4 100644 (file)
--- a/tests/libpakfire/packager.c
+++ b/tests/libpakfire/packager.c
@@ -33,7 +33,7 @@ static int test_create(const struct test* t) {
        PakfireRepo repo = pakfire_repo_create(t->pakfire, "test");
        ASSERT(repo);
 
-       PakfirePackage pkg = pakfire_package_create(t->pakfire, repo,
+       struct pakfire_package* pkg = pakfire_package_create(t->pakfire, repo,
                "test", "1.0-1", "src");
        ASSERT(pkg);