Add to/fromAron() for one-sided optional and test utilities for C++/Python conversion

• ARON conversions (C++): Add overloads for one-sided optional
• Add test utilities for testing C++ to Python conversion of ARON classes

Related to:

• python3-armarx!33 (merged)
• https://git.h2t.iar.kit.edu/sw/armarx/speechx/-/merge_requests/17

source/RobotAPI/libraries/aron/core/aron_conversions.h

@@ -3,12 +3,29 @@
 #include <map>
 #include <memory>
 #include <optional>
+#include <type_traits>
 #include <vector>
 
 #include "Path.h"
 
 namespace armarx::aron
 {
+
+namespace detail
+{
+
+    // Helper concept to avoid ambiguities
+    template<typename DtoT, typename BoT>
+    concept DtoAndBoAreSame = std::is_same<DtoT, BoT>::value;
+
+    template <class ...>
+    struct is_optional : public std::false_type {};
+
+    template <class ...Ts>
+    struct is_optional<std::optional<Ts...>> : public std::true_type {};
+
+}
+
     /**
      * Framework for converting ARON DTOs (Data Transfer Objects) to C++ BOs
      * (Business Objects) and back.
@@ -51,12 +68,6 @@ namespace armarx::aron
      * }
      * @endcode
      */
-
-    // Helper concept to avoid ambiguities
-    template<typename DtoT, typename BoT>
-    concept DtoAndBoAreSame = std::is_same<DtoT, BoT>::value;
-
-
     // Same type
     template <class T>
     void toAron(T& dto, const T& bo)
@@ -139,6 +150,24 @@ namespace armarx::aron
         }
     }
 
+
+    // One-sided optional
+    template <class DtoT, class BoT>
+    requires (not detail::is_optional<BoT>::value)
+    void toAron(std::optional<DtoT>& dto, const BoT& bo)
+    {
+        dto = DtoT{};
+        toAron(*dto, bo);
+    }
+    template <class DtoT, class BoT>
+    requires (not detail::is_optional<DtoT>::value)
+    void fromAron(DtoT& dto, const std::optional<BoT>& bo)
+    {
+        bo = BoT{};
+        fromAron(dto, *bo);
+    }
+
+
     // Flag-controlled optional
     template <class DtoT, class BoT>
     void toAron(DtoT& dto, bool& dtoValid, const BoT& bo, bool boValid)
@@ -154,6 +183,7 @@ namespace armarx::aron
         }
     }
 
+
     template <class DtoT, class BoT>
     void fromAron(const DtoT& dto, bool dtoValid, BoT& bo, bool& boValid)
     {
@@ -222,7 +252,7 @@ namespace armarx::aron
 
     // std::map
     template <class DtoKeyT, class DtoValueT, class BoKeyT, class BoValueT>
-    requires (!(DtoAndBoAreSame<DtoKeyT, BoKeyT> and DtoAndBoAreSame<DtoValueT, BoValueT>))
+    requires (!(detail::DtoAndBoAreSame<DtoKeyT, BoKeyT> and detail::DtoAndBoAreSame<DtoValueT, BoValueT>))
     void toAron(std::map<DtoKeyT, DtoValueT>& dtoMap,
                 const std::map<BoKeyT, BoValueT>& boMap)
     {
@@ -236,7 +266,7 @@ namespace armarx::aron
         }
     }
     template <class DtoKeyT, class DtoValueT, class BoKeyT, class BoValueT>
-    requires (!(DtoAndBoAreSame<DtoKeyT, BoKeyT> and DtoAndBoAreSame<DtoValueT, BoValueT>))
+    requires (!(detail::DtoAndBoAreSame<DtoKeyT, BoKeyT> and detail::DtoAndBoAreSame<DtoValueT, BoValueT>))
     void fromAron(const std::map<DtoKeyT, DtoValueT>& dtoMap,
                   std::map<BoKeyT, BoValueT>& boMap)
     {
@@ -252,7 +282,7 @@ namespace armarx::aron
 
 
     template <class DtoKeyT, class DtoValueT, class BoKeyT, class BoValueT>
-    requires (!(DtoAndBoAreSame<DtoKeyT, BoKeyT> and DtoAndBoAreSame<DtoValueT, BoValueT>))
+    requires (!(detail::DtoAndBoAreSame<DtoKeyT, BoKeyT> and detail::DtoAndBoAreSame<DtoValueT, BoValueT>))
     std::map<DtoKeyT, DtoValueT> toAron(const std::map<BoKeyT, BoValueT>& boMap)
     {
         std::map<DtoKeyT, DtoValueT> dtoMap;
@@ -343,20 +373,20 @@ namespace armarx
 
     // std::vector
     template <class DtoT, class BoT>
-    requires (!aron::DtoAndBoAreSame<DtoT, BoT>)
+    requires (!aron::detail::DtoAndBoAreSame<DtoT, BoT>)
     void toAron(std::vector<DtoT>& dtos, const std::vector<BoT>& bos)
     {
         armarx::aron::toAron(dtos, bos);
     }
     template <class DtoT, class BoT>
-    requires (!aron::DtoAndBoAreSame<DtoT, BoT>)
+    requires (!aron::detail::DtoAndBoAreSame<DtoT, BoT>)
     void fromAron(const std::vector<DtoT>& dtos, std::vector<BoT>& bos)
     {
         armarx::aron::fromAron(dtos, bos);
     }
 
     template <class DtoT, class BoT>
-    requires (!aron::DtoAndBoAreSame<DtoT, BoT>)
+    requires (!aron::detail::DtoAndBoAreSame<DtoT, BoT>)
     std::vector<DtoT> toAron(const std::vector<BoT>& bos)
     {
         return armarx::aron::toAron<DtoT, BoT>(bos);
@@ -365,13 +395,13 @@ namespace armarx
 
     // std::map
     template <class DtoKeyT, class DtoValueT, class BoKeyT, class BoValueT>
-    requires (!(aron::DtoAndBoAreSame<DtoKeyT, BoKeyT> and aron::DtoAndBoAreSame<DtoValueT, BoValueT>))
+    requires (!(aron::detail::DtoAndBoAreSame<DtoKeyT, BoKeyT> and aron::detail::DtoAndBoAreSame<DtoValueT, BoValueT>))
     void toAron(std::map<DtoKeyT, DtoValueT>& dtoMap, const std::map<BoKeyT, BoValueT>& boMap)
     {
         armarx::aron::toAron(dtoMap, boMap);
     }
     template <class DtoKeyT, class DtoValueT, class BoKeyT, class BoValueT>
-    requires (!(aron::DtoAndBoAreSame<DtoKeyT, BoKeyT> and aron::DtoAndBoAreSame<DtoValueT, BoValueT>))
+    requires (!(aron::detail::DtoAndBoAreSame<DtoKeyT, BoKeyT> and aron::detail::DtoAndBoAreSame<DtoValueT, BoValueT>))
     void fromAron(const std::map<DtoKeyT, DtoValueT>& dtoMap, std::map<BoKeyT, BoValueT>& boMap)
     {
         armarx::aron::fromAron(dtoMap, boMap);
@@ -379,7 +409,7 @@ namespace armarx
 
 
     template <class DtoKeyT, class DtoValueT, class BoKeyT, class BoValueT>
-    requires (!(aron::DtoAndBoAreSame<DtoKeyT, BoKeyT> and aron::DtoAndBoAreSame<DtoValueT, BoValueT>))
+    requires (!(aron::detail::DtoAndBoAreSame<DtoKeyT, BoKeyT> and aron::detail::DtoAndBoAreSame<DtoValueT, BoValueT>))
     std::map<DtoKeyT, DtoValueT> toAron(const std::map<BoKeyT, BoValueT>& boMap)
     {
         armarx::aron::toAron<DtoKeyT, DtoValueT, BoKeyT, BoValueT>(boMap);