Use STRV for SimpleSet rather than GPtrArray

Author: sgallagher

modulemd/modulemd-simpleset.c

@@ -66,17 +66,15 @@ modulemd_simpleset_remove_from_array (gpointer key,
                                       gpointer value,
                                       gpointer user_data)
 {
-  GPtrArray *array;
-  gchar *item;
+  gchar **array;
   g_return_val_if_fail (key, FALSE);
   g_return_val_if_fail (user_data, FALSE);
 
-  array = (GPtrArray *)user_data;
+  array = (gchar **)user_data;
 
-  for (gsize i = 0; i < array->len; i++)
+  for (gsize i = 0; array[i]; i++)
     {
-      item = g_ptr_array_index (array, i);
-      if (g_strcmp0 ((gchar *)key, item) == 0)
+      if (g_strcmp0 ((gchar *)key, array[i]) == 0)
         {
           /* This value should stay in the set */
           return FALSE;
@@ -90,18 +88,17 @@ modulemd_simpleset_remove_from_array (gpointer key,
 
 /**
  * modulemd_simpleset_set:
- * @set: (array zero-terminated=0) (element-type utf8): Extensible metadata block
+ * @set: (array zero-terminated=1): Extensible metadata block
  *
  * Make the contents of the set equal to an array of strings. This function
  * will trigger a signal only if the resulting set is different. It does not
  * guarantee any order to the resulting set, only that it will be unique.
  */
 void
-modulemd_simpleset_set (ModulemdSimpleSet *self, GPtrArray *set)
+modulemd_simpleset_set (ModulemdSimpleSet *self, gchar **set)
 {
   gboolean do_notify = FALSE;
   guint num_removed;
-  gchar *item;
 
   g_return_if_fail (MODULEMD_IS_SIMPLESET (self));
   g_return_if_fail (set);
@@ -116,10 +113,9 @@ modulemd_simpleset_set (ModulemdSimpleSet *self, GPtrArray *set)
     }
 
   /* Add in the whole new set to make sure we have everything */
-  for (gsize i = 0; i < set->len; i++)
+  for (gsize i = 0; set[i]; i++)
     {
-      item = g_ptr_array_index (set, i);
-      if (g_hash_table_add (self->set, g_strdup (item)))
+      if (g_hash_table_add (self->set, g_strdup (set[i])))
         {
           /* This key didn't previously exist */
           do_notify = TRUE;
@@ -137,15 +133,30 @@ modulemd_simpleset_set (ModulemdSimpleSet *self, GPtrArray *set)
  *
  * Retrieves the set as a #GPtrArray of strings
  *
- * Returns: (array zero-terminated=0) (element-type utf8) (transfer container):
+ * Returns: (array zero-terminated=1) (transfer container):
  * A list representing a set of string values.
  */
-GPtrArray *
+gchar **
 modulemd_simpleset_get (ModulemdSimpleSet *self)
 {
+  GPtrArray *sorted_keys = NULL;
+  gchar **keys = NULL;
   g_return_val_if_fail (MODULEMD_IS_SIMPLESET (self), NULL);
 
-  return _modulemd_ordered_str_keys (self->set, _modulemd_strcmp_sort);
+  /* FIXME: Sort this */
+  /* return (gchar **)g_hash_table_get_keys_as_array(self->set, NULL); */
+
+  sorted_keys = _modulemd_ordered_str_keys (self->set, _modulemd_strcmp_sort);
+
+  keys = g_malloc0_n (sorted_keys->len + 1, sizeof(char *));
+  for (gsize i = 0; i < sorted_keys->len; i++)
+    {
+      keys[i] = g_strdup (g_ptr_array_index (sorted_keys, i));
+    }
+  keys[sorted_keys->len] = NULL;
+  g_ptr_array_unref (sorted_keys);
+
+  return keys;
 }
 
 /**
@@ -240,13 +251,13 @@ modulemd_simpleset_class_init (ModulemdSimpleSetClass *klass)
   object_class->finalize = modulemd_simpleset_finalize;
 
   /**
-     * ModulemdSimpleSet:set: (type GLib.PtrArray(utf8)) (transfer container)
+     * ModulemdSimpleSet:set: (transfer container)
      */
   set_properties[SET_PROP_SET] =
     g_param_spec_boxed ("set",
                         "The set represented as an array of strings.",
                         "An ordered list of unique strings in this set",
-                        G_TYPE_PTR_ARRAY,
+                        G_TYPE_STRV,
                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
   g_object_class_install_properties (

modulemd/modulemd-simpleset.h

@@ -42,8 +42,8 @@ guint
 modulemd_simpleset_size (ModulemdSimpleSet *self);
 
 void
-modulemd_simpleset_set (ModulemdSimpleSet *self, GPtrArray *set);
-GPtrArray *
+modulemd_simpleset_set (ModulemdSimpleSet *self, gchar **set);
+gchar **
 modulemd_simpleset_get (ModulemdSimpleSet *self);
 
 void

modulemd/modulemd-yaml-emitter.c

@@ -1558,7 +1558,7 @@ _emit_modulemd_simpleset (yaml_emitter_t *emitter,
   gboolean ret = FALSE;
   gsize i;
   yaml_event_t event;
-  GPtrArray *array = modulemd_simpleset_get (set);
+  gchar **array = modulemd_simpleset_get (set);
   gchar *item;
 
   g_debug ("TRACE: entering _emit_modulemd_simpleset");
@@ -1567,9 +1567,9 @@ _emit_modulemd_simpleset (yaml_emitter_t *emitter,
   YAML_EMITTER_EMIT_WITH_ERROR_RETURN (
     emitter, &event, error, "Error starting simpleset sequence");
 
-  for (i = 0; i < array->len; i++)
+  for (i = 0; array[i]; i++)
     {
-      item = g_strdup (g_ptr_array_index (array, i));
+      item = g_strdup (array[i]);
       MMD_YAML_EMIT_SCALAR (&event, item, YAML_PLAIN_SCALAR_STYLE);
     }
 
@@ -1579,7 +1579,7 @@ _emit_modulemd_simpleset (yaml_emitter_t *emitter,
 
   ret = TRUE;
 error:
-  g_ptr_array_unref (array);
+  g_free (array);
 
   g_debug ("TRACE: exiting _emit_modulemd_simpleset");
   return ret;

modulemd/test-modulemd-simpleset.c

@@ -46,11 +46,11 @@ modulemd_simpleset_tear_down (SimpleSetFixture *fixture,
 }
 
 static gboolean
-_array_contains (GPtrArray *array, const gchar *value)
+_array_contains (gchar **array, const gchar *value)
 {
-  for (gsize i = 0; i < array->len; i++)
+  for (gsize i = 0; array[i]; i++)
     {
-      if (g_strcmp0 (g_ptr_array_index (array, i), value) == 0)
+      if (g_strcmp0 (array[i], value) == 0)
         {
           return TRUE;
         }
@@ -63,41 +63,40 @@ modulemd_simpleset_test_get_set (SimpleSetFixture *fixture,
                                  gconstpointer user_data)
 {
   gsize i = 0;
-  GPtrArray *array = g_ptr_array_new_full (3, g_free);
-  GPtrArray *array2;
-  gchar *entry;
+  gchar **array = g_malloc0_n (4, sizeof(gchar *));
+  gchar **array2;
 
-  entry = g_strdup ("a");
-  g_ptr_array_add (array, entry);
-
-  entry = g_strdup ("b");
-  g_ptr_array_add (array, entry);
+  array[0] = g_strdup ("alpha");
+  array[1] = g_strdup ("bravo");
+  array[2] = NULL;
 
   /* Add duplicate value to ensure uniqueness of resulting set */
-  entry = g_strdup ("a");
-  g_ptr_array_add (array, entry);
+  array[3] = g_strdup ("alpha");
 
   /* Create the set from a strv */
   modulemd_simpleset_set (fixture->set, array);
 
-  for (i = 0; i < array->len; i++)
+  for (i = 0; array[i]; i++)
     {
       g_assert_true (modulemd_simpleset_contains (
-        fixture->set, g_ptr_array_index (array, i)));
+        fixture->set, array[i]));
     }
 
   array2 = modulemd_simpleset_get (fixture->set);
 
-  for (i = 0; i < array->len; i++)
+  for (i = 0; array[i]; i++)
     {
-      g_assert_true (_array_contains (array2, g_ptr_array_index (array, i)));
+      g_assert_true (_array_contains (array2, array[i]));
     }
 
+  /* Verify order */
+  g_assert_cmpstr(array2[0], ==, "alpha");
+  g_assert_cmpstr(array2[1], ==, "bravo");
 
   /* The size of the resulting set should only be two entries,
      * since one of them was a duplicate.
      */
-  g_assert_cmpint (array2->len, ==, 2);
+  g_assert_cmpint (g_strv_length(array2), ==, 2);
 }
 
 int