Fix merge with dev

include/aidge/backend/cpu/operator/AbsImpl.hpp

@@ -24,10 +24,10 @@ namespace Aidge {
 
 // compute kernel registry for forward and backward
 class AbsImplForward_cpu
-    : public Registrable<AbsImplForward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {
+    : public Registrable<AbsImplForward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
 };
 class AbsImplBackward_cpu
-    : public Registrable<AbsImplBackward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {
+    : public Registrable<AbsImplBackward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
 };
 
 class AbsImpl_cpu : public OperatorImpl {
@@ -38,7 +38,7 @@ public:
         return std::make_unique<AbsImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/AndImpl.hpp

@@ -23,10 +23,10 @@
 namespace Aidge {
 // compute kernel registry for forward and backward
 class AndImplForward_cpu
-    : public Registrable<AndImplForward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)> {
+    : public Registrable<AndImplForward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)>> {
 };
 class AndImplBackward_cpu
-    : public Registrable<AndImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)> {
+    : public Registrable<AndImplBackward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)>> {
 };
 
 class AndImpl_cpu : public OperatorImpl {
@@ -37,7 +37,7 @@ public:
         return std::make_unique<AndImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/ArgMaxImpl.hpp

@@ -26,19 +26,19 @@ namespace Aidge {
 class ArgMaxImplForward_cpu
     : public Registrable<ArgMaxImplForward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(std::int32_t,
+                        std::function<void(std::int32_t,
                             DimSize_t,
                             const std::vector<DimSize_t>&,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 class ArgMaxImplBackward_cpu
     : public Registrable<ArgMaxImplBackward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(std::int32_t,
+                        std::function<void(std::int32_t,
                             DimSize_t,
                             const std::vector<DimSize_t>&,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class ArgMaxImpl_cpu : public OperatorImpl {
    public:

include/aidge/backend/cpu/operator/ReduceSumImpl.hpp

@@ -26,19 +26,19 @@ namespace Aidge {
 class ReduceSumImplForward_cpu
     : public Registrable<ReduceSumImplForward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(const std::vector<std::int32_t>&,
+                        std::function<void(const std::vector<std::int32_t>&,
                             DimSize_t,
                             const std::vector<DimSize_t>&,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 class ReduceSumImpl1DBackward_cpu
     : public Registrable<ReduceSumImpl1DBackward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(const std::vector<std::int32_t>&,
+                        std::function<void(const std::vector<std::int32_t>&,
                             DimSize_t,
                             const std::vector<DimSize_t>&,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class ReduceSumImpl_cpu : public OperatorImpl {
    public:

src/operator/AbsImpl.cpp

@@ -19,11 +19,6 @@
 #include "aidge/operator/Abs.hpp"
 #include "aidge/utils/Types.h"
 
-Aidge::Elts_t Aidge::AbsImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
-    // this implementation can be in-place
-    return Elts_t::DataElts(0);
-}
-
 void Aidge::AbsImpl_cpu::forward() {
     const Abs_Op& op = static_cast<const Abs_Op&>(mOp);
 

src/operator/AndImpl.cpp

@@ -23,11 +23,6 @@
 #include "aidge/backend/cpu/operator/AndImpl.hpp"
 #include "aidge/backend/cpu/operator/AndImpl_forward_kernels.hpp"
 
-Aidge::Elts_t Aidge::AndImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
-    // this implementation can be in-place
-    return Elts_t::DataElts(0);
-}
-
 void Aidge::AndImpl_cpu::forward() {
     // Find the correct kernel type
     auto kernelFunc = Registrar<AndImplForward_cpu>::create({