[Add] Possibility to create a GenericOperator from any Operator

Context

One envisionned use-case is to be able to replace actual Operator obejcts with GenericOperator that would behave differently even regarding the size of inputs/outputs Tensors.

For example, a Conv that works on 4-bits packed data, which input/output size would be different from the standard Conv operator because of memory alignments. This would be useful for the export of sub 8-bits kernels in the Cortex-M export.

Major modifications

Add possibility to create a GenericOperator from any Operator.

• add: toGenericOp() recipe to convert operator into GenericOperator
• add: Operator::inputCategory() getter for input categories
• add: comparison operator= to DynamicAttributes
• add: GenericOperator constructor from Operator
• add: unit-tests for toGenericOperator() recipe
• upd: make std::array and std::pair recursively hashable in DynamicAttributes
• upd: make almost every StaticAttributes convertible to DynamicAttributes

include/aidge/utils/DynamicAttributes.hpp

@@ -34,6 +34,12 @@ namespace py = pybind11;
 
 
 namespace Aidge {
+// Detection idiom to check if a type T has a less-than operator
+template <typename T, typename = void>
+struct has_less_than_operator : std::false_type {};
+
+template <typename T>
+struct has_less_than_operator<T, std::void_t<decltype(std::declval<T>() < std::declval<T>())>> : std::true_type {};
 
 ///\todo store also a fix-sized code that indicates the type
 ///\todo managing complex types or excluding non-trivial, non-aggregate types
@@ -344,6 +350,14 @@ public:
         }
     };
 
+    template<typename T>
+    static inline typename std::enable_if<!has_less_than_operator<T>::value, void>::type makeTypeConditionallyAvailable() {}
+
+    template<typename T>
+    static inline typename std::enable_if<has_less_than_operator<T>::value, void>::type makeTypeConditionallyAvailable() {
+        mAnyUtils.emplace(typeid(T), std::unique_ptr<AnyUtils<T>>(new AnyUtils<T>()));
+    }
+
     // Stores typed utils functions for each attribute type ever used
     static std::map<std::type_index, std::unique_ptr<AnyUtils_>> mAnyUtils;
 };
@@ -407,6 +421,19 @@ namespace std {
             return seed;
         }
     };
+
+    // Special case for std::array
+    template <typename T, std::size_t N>
+    struct hash<std::array<T, N>> {
+        std::size_t operator()(const std::array<T, N>& iterable) const {
+            std::size_t seed = 0;
+            for (const auto& v : iterable) {
+                // Recursively hash the value pointed by the iterator
+                Aidge::hash_combine(seed, std::hash<T>()(v));
+            }
+            return seed;
+        }
+    };
 }
 
 namespace future_std {