Refactor tuple_g_variant_helpers

... to be a bit more extensible.

Change-Id: I2c37833fd8c5296d2d81413316173a35910e7a8f

diff --git a/sessiond/src/tuple_g_variant_helpers.hpp b/sessiond/src/tuple_g_variant_helpers.hpp
index f720676..a772e33 100644 (file)
--- a/sessiond/src/tuple_g_variant_helpers.hpp
+++ b/sessiond/src/tuple_g_variant_helpers.hpp
@@ -65,23 +65,30 @@ constexpr std::string type_of_g_variant()
        return std::string("(") + concat_gvariant_types<Ts ...>() + ")";
 }
 
-template <size_t I, typename T>
-std::tuple<T> tuple_from_g_variant_inner(GVariant *variant)
+template <typename T>
+T value_from_g_variant_one_inner(GVariant *variant)
 {
        char output_type[2] = { type_of_g_variant_one<T>() };
        T output_slot;
-       g_variant_get_child(variant, I, output_type, &output_slot);
-       return std::make_tuple(output_slot);
+       g_variant_get(variant, output_type, &output_slot);
+       return output_slot;
+}
+
+template <size_t I, typename T>
+std::tuple<T> tuple_from_g_variant_inner(GVariant *variant)
+{
+       GVariant *i = g_variant_get_child_value(variant, I);
+       T output = value_from_g_variant_one_inner<T>(i);
+       return std::make_tuple(output);
 }
 
 template <size_t I, typename T, typename T1, typename... Ts>
 std::tuple<T, T1, Ts...> tuple_from_g_variant_inner(GVariant *variant)
 {
-       char output_type[2] = { type_of_g_variant_one<T>() };
-       T output_slot;
-       g_variant_get_child(variant, I, output_type, &output_slot);
+       GVariant *i = g_variant_get_child_value(variant, I);
+       T output = value_from_g_variant_one_inner<T>(i);
        auto rest = tuple_from_g_variant_inner<I + 1, T1, Ts...>(variant);
-       return std::tuple_cat(std::make_tuple(output_slot), std::move(rest));
+       return std::tuple_cat(std::make_tuple(output), std::move(rest));
 }
 
 template <typename... Ts>
@@ -93,10 +100,34 @@ std::tuple<Ts...> tuple_from_g_variant(GVariant *variant)
        return tuple_from_g_variant_inner<0, Ts...>(variant);
 }
 
+template <typename T>
+GVariant *value_to_g_variant_one_inner(const T &value)
+{
+       char input_type[2] = { type_of_g_variant_one<T>() };
+       return g_variant_new(input_type, value);
+}
+
+template <size_t I, typename T>
+void fill_g_variant_one_table_inner(GVariant **table, const T &value)
+{
+       table[I] = value_to_g_variant_one_inner<T>(value);
+}
+
+template <size_t I, typename T, typename T1, typename... Ts>
+void fill_g_variant_one_table_inner(GVariant **table, const T &value, const T1 &next_value, const Ts &...vals)
+{
+       table[I] = value_to_g_variant_one_inner<T>(value);
+       fill_g_variant_one_table_inner<I + 1, T1, Ts...>(table, next_value, vals...);
+}
+
 template <typename... Ts>
-GVariant *vals_to_g_variant(Ts... vals)
+GVariant *vals_to_g_variant(const Ts &...vals)
 {
-       return g_variant_new(type_of_g_variant<Ts...>().c_str(), vals...);
+       GVariant *table[sizeof...(vals)];
+       fill_g_variant_one_table_inner<0, Ts...>(table, vals...);
+       return g_variant_new_tuple(table, sizeof...(vals));
+       // Note that there is no need to free the GVariants in table,
+       // as they were floating and consumed by g_variant_new_tuple.
 }
 
 template <typename... Ts>