[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/operator/GenericOperator.hpp

@@ -75,6 +75,10 @@ public:
     inline void addAttr(const std::string& name, const T& value) const
     { mAttributes -> template addAttr<T>(name, value); }
 
+    inline void setAttrs(const std::map<std::string, future_std::any>& attrs) {
+        *mAttributes = attrs;
+    }
+
     // Helper functions that can be used with setForwardDims():
     static const ComputeDimsFunc Identity;
     static const ComputeDimsFunc InputIdentity(IOIndex_t inputIdx, IOIndex_t nbOutputs);
@@ -84,9 +88,9 @@ public:
 };
 
 /**
- * @brief Fictive custom operator not associated with any implementation.
+ * @brief Generic operator not associated with any implementation.
  * Allows to import unknown operators and simulate new ones.
- * @param type Type of the fictive operator.
+ * @param type Type of the generic operator.
  * @param inputCategory List inputs with their category
  * @param nbOut Number of output data.
  * @param name (optional) name of the Operator.
@@ -96,9 +100,9 @@ std::shared_ptr<Node> GenericOperator(const std::string& type, const std::vector
                                              const std::string& name = "");
 
 /**
- * @brief Fictive custom operator not associated with any implementation.
+ * @brief Generic operator not associated with any implementation.
  * Allows to import unknown operators and simulate new ones.
- * @param type Type of the fictive operator.
+ * @param type Type of the generic operator.
  * @param nbData Number of input data.
  * @param nbParam Number of parameters.
  * @param nbOut Number of output data.
@@ -107,6 +111,18 @@ std::shared_ptr<Node> GenericOperator(const std::string& type, const std::vector
  */
 std::shared_ptr<Node> GenericOperator(const std::string& type, IOIndex_t nbData, IOIndex_t nbParam, IOIndex_t nbOut,
                                              const std::string& name = "");
+
+/**
+ * @brief Generic operator not associated with any implementation.
+ * Create a generic operator from another existing operator.
+ * @param type Type of the generic operator.
+ * @param op Original operator from witch one wants to derive a generic operator.
+ * @param name (optional) name of the Operator.
+ * @return std::shared_ptr<Node> Node associated with the Generic Operator.
+ */
+std::shared_ptr<Aidge::Node> GenericOperator(const std::string& type,
+                                            std::shared_ptr<OperatorTensor> op,
+                                            const std::string& name = "");
 }  // namespace Aidge
 
 #endif /* AIDGE_CORE_OPERATOR_GENERICOPERATOR_H_ */