[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/data/Data.hpp

@@ -20,6 +20,7 @@
 
 #include "aidge/data/half.hpp"
 #include "aidge/utils/Attributes.hpp"
+#include "aidge/utils/ErrorHandling.hpp"
 
 namespace Aidge {
 enum class DataType {
@@ -91,7 +92,19 @@ DataFormatTranspose getDataFormatTranspose(const DataFormat& src, const DataForm
 
 class Data {
 public:
+    Data() = delete;
+    Data(Data&& other) = default;
+    Data(const Data& other) = default;
     Data(const std::string& type): mType(type) {};
+
+    Data& operator=(const Data& other) {
+        AIDGE_ASSERT(other.mType == mType, "Cannot copy a different type fo Data object.");
+        return *this;
+    };
+    Data& operator=(Data&& other) {
+        AIDGE_ASSERT(other.mType == mType, "Cannot copy a different type fo Data object.");
+        return *this;
+    };
     constexpr const std::string& type() const {
         return mType;
     }