packages: Add a combined function to get/set string arguments

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

diff --git a/src/libpakfire/include/pakfire/package.h b/src/libpakfire/include/pakfire/package.h
index 732f961e3ec02e4fa1f749669f5d0ceb55a7ca57..83d13f953438f3c5063bc327dd2f585b3290fd10 100644 (file)
--- a/src/libpakfire/include/pakfire/package.h
+++ b/src/libpakfire/include/pakfire/package.h
@@ -31,6 +31,22 @@ struct pakfire_package;
 #include <pakfire/pakfire.h>
 #include <pakfire/repo.h>
 
+enum pakfire_package_key {
+       PAKFIRE_PKG_NAME,
+       PAKFIRE_PKG_EVR,
+       PAKFIRE_PKG_ARCH,
+       PAKFIRE_PKG_NEVRA,
+       PAKFIRE_PKG_UUID,
+       PAKFIRE_PKG_SUMMARY,
+       PAKFIRE_PKG_DESCRIPTION,
+       PAKFIRE_PKG_LICENSE,
+       PAKFIRE_PKG_URL,
+       PAKFIRE_PKG_GROUPS,
+       PAKFIRE_PKG_VENDOR,
+       PAKFIRE_PKG_DISTRO,
+       PAKFIRE_PKG_MAINTAINER,
+};
+
 struct pakfire_package* pakfire_package_create(struct pakfire* pakfire, struct pakfire_repo* repo,
        const char* name, const char* evr, const char* arch);
 
@@ -50,6 +66,11 @@ 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_string(struct pakfire_package* pkg,
+       const enum pakfire_package_key key);
+int pakfire_package_set_string(struct pakfire_package* pkg,
+       const enum pakfire_package_key key, const char* value);
+
 const char* pakfire_package_get_uuid(struct pakfire_package* pkg);
 void pakfire_package_set_uuid(struct pakfire_package* pkg, const char* uuid);
 const unsigned char* pakfire_package_get_digest(struct pakfire_package* pkg,

diff --git a/src/libpakfire/libpakfire.sym b/src/libpakfire/libpakfire.sym
index a433327d574d8082d827ebd916c877d16fef5895..edb3e2067e64ce14280c93453f1ff8a40392e282 100644 (file)
--- a/src/libpakfire/libpakfire.sym
+++ b/src/libpakfire/libpakfire.sym
@@ -203,6 +203,7 @@ global:
        pakfire_package_get_source_evr;
        pakfire_package_get_source_name;
        pakfire_package_get_source_package;
+       pakfire_package_get_string;
        pakfire_package_get_suggests;
        pakfire_package_get_summary;
        pakfire_package_get_supplements;
@@ -232,6 +233,7 @@ global:
        pakfire_package_set_source_arch;
        pakfire_package_set_source_evr;
        pakfire_package_set_source_name;
+       pakfire_package_set_string;
        pakfire_package_set_summary;
        pakfire_package_set_url;
        pakfire_package_set_uuid;

diff --git a/src/libpakfire/package.c b/src/libpakfire/package.c
index e0f9fc3eaede1687489e80a52d751beb2334b514..0e376fb9d674d80997d5d459ce9941b141eb8ae1 100644 (file)
--- a/src/libpakfire/package.c
+++ b/src/libpakfire/package.c
@@ -306,40 +306,165 @@ static void pakfire_package_internalize_repo(struct pakfire_package* pkg) {
        }
 }
 
-static unsigned long long pakfire_package_get_num(struct pakfire_package* pkg, Id type) {
+static void pakfire_package_has_changed(struct pakfire_package* pkg) {
+       struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
+       if (repo) {
+               pakfire_repo_has_changed(repo);
+               pakfire_repo_unref(repo);
+       }
+}
+
+PAKFIRE_EXPORT const char* pakfire_package_get_string(
+               struct pakfire_package* pkg, const enum pakfire_package_key key) {
+       const char* ret = NULL;
+       int r;
+
        pakfire_package_internalize_repo(pkg);
 
+       Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
        Solvable* s = get_solvable(pkg);
-       return solvable_lookup_num(s, type, 0);
-}
 
-static void pakfire_package_set_num(struct pakfire_package* pkg, Id type, unsigned long long value) {
-       Solvable* s = get_solvable(pkg);
+       switch (key) {
+               case PAKFIRE_PKG_NAME:
+                       return pool_id2str(pool, s->name);
 
-       solvable_set_num(s, type, value);
-}
+               case PAKFIRE_PKG_EVR:
+                       return pool_id2str(pool, s->evr);
 
-static const char* pakfire_package_get_string(struct pakfire_package* pkg, Id key) {
-       pakfire_package_internalize_repo(pkg);
+               case PAKFIRE_PKG_ARCH:
+                       return pool_id2str(pool, s->arch);
 
-       Solvable* s = get_solvable(pkg);
+               case PAKFIRE_PKG_NEVRA:
+                       if (*pkg->nevra) {
+                               r = pakfire_string_set(pkg->nevra, pool_solvable2str(pool, s));
+                               if (r)
+                                       return NULL;
+                       }
 
-       const char* str = solvable_lookup_str(s, key);
-       if (!str || !*str)
-               return NULL;
+                       return pkg->nevra;
 
-       return str;
+               case PAKFIRE_PKG_UUID:
+                       ret = solvable_lookup_str(s, SOLVABLE_PKGID);
+                       break;
+
+               case PAKFIRE_PKG_SUMMARY:
+                       ret = solvable_lookup_str(s, SOLVABLE_SUMMARY);
+                       break;
+
+               case PAKFIRE_PKG_DESCRIPTION:
+                       ret = solvable_lookup_str(s, SOLVABLE_DESCRIPTION);
+                       break;
+
+               case PAKFIRE_PKG_LICENSE:
+                       ret = solvable_lookup_str(s, SOLVABLE_LICENSE);
+                       break;
+
+               case PAKFIRE_PKG_URL:
+                       ret = solvable_lookup_str(s, SOLVABLE_URL);
+                       break;
+
+               case PAKFIRE_PKG_GROUPS:
+                       ret = solvable_lookup_str(s, SOLVABLE_GROUP);
+                       break;
+
+               case PAKFIRE_PKG_VENDOR:
+                       ret = solvable_lookup_str(s, SOLVABLE_VENDOR);
+                       break;
+
+               case PAKFIRE_PKG_DISTRO:
+                       ret = solvable_lookup_str(s, SOLVABLE_DISTRIBUTION);
+                       break;
+
+               case PAKFIRE_PKG_MAINTAINER:
+                       ret = solvable_lookup_str(s, SOLVABLE_PACKAGER);
+                       break;
+       }
+
+       return ret;
 }
 
-static void pakfire_package_set_string(struct pakfire_package* pkg, int key, const char* value) {
+int pakfire_package_set_string(
+               struct pakfire_package* pkg, const enum pakfire_package_key key, const char* value) {
+       Id id = ID_NULL;
+
+       switch (key) {
+               // Do not allow to change name, evr, or arch
+               case PAKFIRE_PKG_NAME:
+               case PAKFIRE_PKG_EVR:
+               case PAKFIRE_PKG_ARCH:
+               case PAKFIRE_PKG_NEVRA:
+                       errno = EINVAL;
+                       return 1;
+
+               case PAKFIRE_PKG_UUID:
+                       id = SOLVABLE_PKGID;
+                       break;
+
+               case PAKFIRE_PKG_SUMMARY:
+                       id = SOLVABLE_SUMMARY;
+                       break;
+
+               case PAKFIRE_PKG_DESCRIPTION:
+                       id = SOLVABLE_DESCRIPTION;
+                       break;
+
+               case PAKFIRE_PKG_LICENSE:
+                       id = SOLVABLE_LICENSE;
+                       break;
+
+               case PAKFIRE_PKG_URL:
+                       id = SOLVABLE_URL;
+                       break;
+
+               case PAKFIRE_PKG_GROUPS:
+                       id = SOLVABLE_GROUP;
+                       break;
+
+               case PAKFIRE_PKG_VENDOR:
+                       id = SOLVABLE_VENDOR;
+                       break;
+
+               case PAKFIRE_PKG_DISTRO:
+                       id = SOLVABLE_DISTRIBUTION;
+                       break;
+
+               case PAKFIRE_PKG_MAINTAINER:
+                       id = SOLVABLE_PACKAGER;
+                       break;
+       }
+
+       // Check if we have found a valid ID
+       if (id == ID_NULL) {
+               errno = EINVAL;
+               return 1;
+       }
+
        Solvable* s = get_solvable(pkg);
 
        // Unset on empty string
        if (!value || !*value)
-               solvable_unset(s, key);
+               solvable_unset(s, id);
 
        // Store string
-       solvable_set_str(s, key, value);
+       solvable_set_str(s, id, value);
+
+       // Mark the package as changed
+       pakfire_package_has_changed(pkg);
+
+       return 0;
+}
+
+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(struct pakfire_package* pkg, Id type, unsigned long long value) {
+       Solvable* s = get_solvable(pkg);
+
+       solvable_set_num(s, type, value);
 }
 
 static char** pakfire_package_get_string_array(struct pakfire_package* pkg, Id key) {

diff --git a/tests/libpakfire/package.c b/tests/libpakfire/package.c
index b7b6cd7b98120fec9890e63a81ca4e08e2f90263..76428701a14ffd0090c23229c1df54014d00a06d 100644 (file)
--- a/tests/libpakfire/package.c
+++ b/tests/libpakfire/package.c
@@ -31,9 +31,13 @@ static int test_create(const struct test* t) {
 
        ASSERT(pkg = pakfire_package_create(t->pakfire, NULL, "test", "1.0-1", "src"));
 
-       ASSERT_STRING_EQUALS(pakfire_package_get_name(pkg), "test");
-       ASSERT_STRING_EQUALS(pakfire_package_get_evr(pkg), "1.0-1");
-       ASSERT_STRING_EQUALS(pakfire_package_get_arch(pkg), "src");
+       ASSERT_STRING_EQUALS(pakfire_package_get_string(pkg, PAKFIRE_PKG_NAME), "test");
+       ASSERT_STRING_EQUALS(pakfire_package_get_string(pkg, PAKFIRE_PKG_EVR), "1.0-1");
+       ASSERT_STRING_EQUALS(pakfire_package_get_string(pkg, PAKFIRE_PKG_ARCH), "src");
+
+       // Summary
+       ASSERT_SUCCESS(pakfire_package_set_string(pkg, PAKFIRE_PKG_SUMMARY, "SUMMARY"));
+       ASSERT_STRING_EQUALS(pakfire_package_get_string(pkg, PAKFIRE_PKG_SUMMARY), "SUMMARY");
 
        // Everything passed
        r = EXIT_SUCCESS;