Add std::string and std::string_view support to tuple_g_variant_helpers

std::string is supported in both cases. std::string_view is only allowed
in input and not in output.

Change-Id: Ib7d23a434309943e475e70b6a2ace943e55ec8ae

diff --git a/sessiond/src/tuple_g_variant_helpers.hpp b/sessiond/src/tuple_g_variant_helpers.hpp
index a772e33..52fac01 100644 (file)
--- a/sessiond/src/tuple_g_variant_helpers.hpp
+++ b/sessiond/src/tuple_g_variant_helpers.hpp
@@ -47,6 +47,18 @@ constexpr inline char type_of_g_variant_one<uint64_t>()
        return 'x';
 }
 
+template<>
+constexpr inline char type_of_g_variant_one<std::string>()
+{
+       return 's';
+}
+
+template<>
+constexpr inline char type_of_g_variant_one<std::string_view>()
+{
+       return 's';
+}
+
 template <typename T>
 constexpr static std::string concat_gvariant_types()
 {
@@ -68,12 +80,25 @@ constexpr std::string type_of_g_variant()
 template <typename T>
 T value_from_g_variant_one_inner(GVariant *variant)
 {
+       // This case is disallowed due to lifetime mess potential.
+       // Implament at your own responsibility!
+       static_assert(!std::is_same<T, std::string_view>::value, "You probably meant std::string");
+
+       // Out of completeness:
+       static_assert(!std::is_same<T, std::string>::value, "Implemented elsewhere");
+
        char output_type[2] = { type_of_g_variant_one<T>() };
        T output_slot;
        g_variant_get(variant, output_type, &output_slot);
        return output_slot;
 }
 
+template<>
+std::string value_from_g_variant_one_inner<std::string>(GVariant *variant)
+{
+       return std::string(g_variant_get_string(variant, NULL));
+}
+
 template <size_t I, typename T>
 std::tuple<T> tuple_from_g_variant_inner(GVariant *variant)
 {
@@ -103,10 +128,26 @@ std::tuple<Ts...> tuple_from_g_variant(GVariant *variant)
 template <typename T>
 GVariant *value_to_g_variant_one_inner(const T &value)
 {
+       // Out of completeness:
+       static_assert(!std::is_same<T, std::string>::value, "Implemented elsewhere");
+       static_assert(!std::is_same<T, std::string_view>::value, "Implemented elsewhere");
+
        char input_type[2] = { type_of_g_variant_one<T>() };
        return g_variant_new(input_type, value);
 }
 
+template <>
+GVariant *value_to_g_variant_one_inner<std::string>(const std::string &value)
+{
+       return g_variant_new_string(value.c_str());
+}
+
+template <>
+GVariant *value_to_g_variant_one_inner<std::string_view>(const std::string_view &value)
+{
+       return g_variant_new_string(value.data());
+}
+
 template <size_t I, typename T>
 void fill_g_variant_one_table_inner(GVariant **table, const T &value)
 {