feat: add std::variant constructor and conversion operator to sdbus::…

…Variant (#429) Signed-off-by: Anthony Brandon <[email protected]>
Kistler-Group · Apr 4, 2024 · 334fcb8 · 334fcb8
1 parent b9088cc
commit 334fcb8
Show file tree

Hide file tree

Showing 2 changed files with 54 additions and 0 deletions.
diff --git a/include/sdbus-c++/Types.h b/include/sdbus-c++/Types.h
@@ -65,6 +65,14 @@ namespace sdbus {
             msg_.seal();
         }
 
+        template <typename... _Elements>
+        Variant(const std::variant<_Elements...>& value)
+            : Variant()
+        {
+            msg_ << value;
+            msg_.seal();
+        }
+
         template <typename _ValueType>
         _ValueType get() const
         {
@@ -83,6 +91,15 @@ namespace sdbus {
             return get<_ValueType>();
         }
 
+        template <typename... _Elements>
+        operator std::variant<_Elements...>() const
+        {
+            std::variant<_Elements...> result;
+            msg_.rewind(false);
+            msg_ >> result;
+            return result;
+        }
+
         template <typename _Type>
         bool containsValueOfType() const
         {

diff --git a/tests/unittests/Types_test.cpp b/tests/unittests/Types_test.cpp
@@ -72,6 +72,19 @@ TEST(AVariant, CanBeConstructedFromAComplexValue)
     ASSERT_NO_THROW(sdbus::Variant{value});
 }
 
+TEST(AVariant, CanBeConstructedFromAnStdVariant)
+{
+    using ComplexType = std::vector<sdbus::Struct<std::string, double>>;
+    using StdVariantType = std::variant<std::string, uint64_t, ComplexType>;
+    ComplexType value{{"hello"s, ANY_DOUBLE}, {"world"s, ANY_DOUBLE}};
+    StdVariantType stdVariant{value};
+
+    sdbus::Variant sdbusVariant{stdVariant};
+
+    ASSERT_TRUE(sdbusVariant.containsValueOfType<ComplexType>());
+    ASSERT_THAT(sdbusVariant.get<ComplexType>(), Eq(value));
+}
+
 TEST(AVariant, CanBeCopied)
 {
     auto value = "hello"s;
@@ -130,6 +143,30 @@ TEST(AVariant, ReturnsTrueWhenAskedIfItContainsTheTypeItReallyContains)
     ASSERT_TRUE(variant.containsValueOfType<ComplexType>());
 }
 
+TEST(AVariant, CanBeConvertedIntoAnStdVariant)
+{
+    using ComplexType = std::vector<sdbus::Struct<std::string, double>>;
+    using StdVariantType = std::variant<std::string, uint64_t, ComplexType>;
+    ComplexType value{{"hello"s, ANY_DOUBLE}, {"world"s, ANY_DOUBLE}};
+    sdbus::Variant sdbusVariant{value};
+    StdVariantType stdVariant{sdbusVariant};
+
+    ASSERT_TRUE(std::holds_alternative<ComplexType>(stdVariant));
+    ASSERT_THAT(std::get<ComplexType>(stdVariant), Eq(value));
+}
+
+TEST(AVariant, IsImplicitlyInterchangeableWithStdVariant)
+{
+    using ComplexType = std::vector<sdbus::Struct<std::string, double>>;
+    using StdVariantType = std::variant<std::string, uint64_t, ComplexType>;
+    ComplexType value{{"hello"s, ANY_DOUBLE}, {"world"s, ANY_DOUBLE}};
+    StdVariantType stdVariant{value};
+
+    auto stdVariantCopy = [](const sdbus::Variant &v) -> StdVariantType { return v; }(stdVariant);
+
+    ASSERT_THAT(stdVariantCopy, Eq(stdVariant));
+}
+
 TEST(ASimpleVariant, ReturnsFalseWhenAskedIfItContainsTypeItDoesntReallyContain)
 {
     int value = 5;