Corrected MSVC errors

include/aidge/operator/Add.hpp

@@ -108,8 +108,9 @@ public:
         assert(static_cast<std::size_t>(inputIdx) < NUM && "wrong inputIdx for Add operator.");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
+        (void) outputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mOutput);
     }
 

include/aidge/operator/AvgPooling.hpp

@@ -108,12 +108,14 @@ public:
     }
 
 
-    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx == 0 && "operators supports only 1 inputs");
+        (void) inputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mInput);
     }
-    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
+        (void) outputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mOutput);
     }
 

include/aidge/operator/BatchNorm.hpp

@@ -107,8 +107,9 @@ public:
         assert(inputIdx < 5 && "operators supports only 5 inputs");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
+        (void) outputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mOutput);
     }
 

include/aidge/operator/Conv.hpp

@@ -121,8 +121,9 @@ public:
         assert(inputIdx < 3 && "Conv Operators supports only 3 inputs");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
         assert((outputIdx == 0) && "Conv Operator has only 1 output");
+        (void) outputIdx; // avoid unused warning
         return mOutput;
     }
 

include/aidge/operator/ConvDepthWise.hpp

@@ -121,8 +121,9 @@ class ConvDepthWise_Op : public Operator,
         assert(inputIdx < 3 && "ConvDepthWise Operators supports only 3 inputs");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
         assert((outputIdx == 0) && "ConvDepthWise Operator has only 1 output");
+        (void) outputIdx; // avoid unused warning
         return mOutput;
     }
 

include/aidge/operator/FC.hpp

@@ -98,7 +98,7 @@ public:
     }
     inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
         assert((outputIdx == 0) && "FC Operator has only 1 output");
-        (void) outputIdx;
+        (void) outputIdx; // avoid unused warning
         return mOutput;
     }
 
@@ -109,7 +109,7 @@ public:
     }
     std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
-        (void) outputIdx;
+        (void) outputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mOutput);
     }
 

include/aidge/operator/LeakyReLU.hpp

@@ -53,8 +53,9 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
+        (void) inputIdx; // avoid unused warning
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         mInput = std::dynamic_pointer_cast<Tensor>(data);
     }
@@ -73,22 +74,26 @@ public:
     inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
-    inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert((inputIdx == 0) && "LeakyReLU Operator has only 1 input");
+        (void) inputIdx; // avoid unused warning
         return mInput;
     }
-    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
         assert((outputIdx == 0) && "LeakyReLU Operator has only 1 output");
+        (void) outputIdx; // avoid unused warning
         return mOutput;
     }
 
 
-    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
+        (void) inputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mInput);
     }
-    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
+        (void) outputIdx; // avoid unused warning
         return mOutput;
     }
 

include/aidge/operator/Matmul.hpp

@@ -55,7 +55,7 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
         assert(inputIdx < 2 && "operators supports only 2 inputs");
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         mInputs[inputIdx] = std::dynamic_pointer_cast<Tensor>(data);
@@ -88,8 +88,9 @@ public:
         assert(inputIdx < 2 && "MatMul Operators has 2 inputs");
         return mInputs[inputIdx];
     }
-    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
         assert((outputIdx == 0) && "MatMul Operators has 1 output");
+        (void) outputIdx; // avoid unused warning
         return mOutput;
     }
 
@@ -98,8 +99,9 @@ public:
         assert(inputIdx < 2 && "operators supports only 2 inputs");
         return std::static_pointer_cast<Data>(mInputs[inputIdx]);
     }
-    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
+        (void) outputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mOutput);
     }
 

include/aidge/operator/Producer.hpp

@@ -73,7 +73,7 @@ public:
     }
     inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
       assert((outputIdx == 0) && "Producer Operator has only 1 output");
-      (void) outputIdx;
+      (void) outputIdx; // avoid unused warning
       return mOutput;
     }
 
@@ -85,7 +85,7 @@ public:
 
     std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
-        (void) outputIdx;
+        (void) outputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mOutput);
     }
 

include/aidge/operator/ReLU.hpp

@@ -42,8 +42,9 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
+        (void) inputIdx; // avoid unused warning
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         mInput = std::dynamic_pointer_cast<Tensor>(data);
     }
@@ -62,22 +63,26 @@ public:
     inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
-    inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert((inputIdx == 0) && "ReLU Operator has only 1 input");
+        (void) inputIdx; // avoid unused warning
         return mInput;
     }
-    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
         assert((outputIdx == 0) && "ReLU Operator has only 1 output");
+        (void) outputIdx; // avoid unused warning
         return mOutput;
     }
 
 
-    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
+        (void) inputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mInput);
     }
-    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
+        (void) outputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mOutput);
     }
 

include/aidge/operator/Softmax.hpp

@@ -42,8 +42,9 @@ public:
         setDatatype(DataType::Float32);
     }
 
-    void associateInput(const IOIndex_t /*inputIdx*/, std::shared_ptr<Data> data) override final {
+    void associateInput(const IOIndex_t inputIdx, std::shared_ptr<Data> data) override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
+        (void) inputIdx; // avoid unused warning
         assert(strcmp(data->type(), Tensor::Type)==0 && "input data must be of Tensor type");
         mInput = std::dynamic_pointer_cast<Tensor>(data);
     }
@@ -62,22 +63,26 @@ public:
     inline Tensor& output(const IOIndex_t /*outputIdx*/) const override final { return *(mOutput.get()); }
 
 
-    inline std::shared_ptr<Tensor> getInput(const IOIndex_t /*inputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getInput(const IOIndex_t inputIdx) const override final {
         assert((inputIdx == 0) && "Softmax Operator has only 1 input");
+        (void) inputIdx; // avoid unused warning
         return mInput;
     }
-    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t /*outputIdx*/) const override final {
+    inline std::shared_ptr<Tensor> getOutput(const IOIndex_t outputIdx) const override final {
         assert((outputIdx == 0) && "Softmax Operator has only 1 output");
+        (void) outputIdx; // avoid unused warning
         return mOutput;
     }
 
 
-    std::shared_ptr<Data> getRawInput(const IOIndex_t /*inputIdx*/) const override final {
+    std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final {
         assert(inputIdx == 0 && "operator supports only 1 input");
+        (void) inputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mInput);
     }
-    std::shared_ptr<Data> getRawOutput(const IOIndex_t /*outputIdx*/) const override final {
+    std::shared_ptr<Data> getRawOutput(const IOIndex_t outputIdx) const override final {
         assert(outputIdx == 0 && "operator supports only 1 output");
+        (void) outputIdx; // avoid unused warning
         return std::static_pointer_cast<Data>(mOutput);
     }
 

python_binding/data/pybind_Tensor.cpp

@@ -98,9 +98,9 @@ void init_Tensor(py::module& m){
     .def_buffer([](Tensor& b) -> py::buffer_info {
         const std::unique_ptr<TensorImpl>& tensorImpl = b.getImpl();
 
-        std::vector<ssize_t> dims;
-        std::vector<ssize_t> strides;
-        ssize_t stride = tensorImpl->scalarSize();
+        std::vector<size_t> dims;
+        std::vector<size_t> strides;
+        size_t stride = tensorImpl->scalarSize();
 
         for (unsigned int dim = b.nbDims(); dim > 0; dim--) {
             dims.push_back(b.dims()[dim-1]);

src/graph/GraphView.cpp

@@ -30,13 +30,13 @@ Aidge::Connector Aidge::GraphView::operator()(
   assert((ctors.size() == static_cast<std::size_t>(inNode->nbDataInputs())) && "Wrong number of arguments.\n");
   for (std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inNode->inputs()) {
     assert((gk_IODefaultIndex == input.second) && "At least one input connection is not free.\n");
-    (void)input; // Suppress ununsed warning
+    (void)input; // avoid unused warning
   }
 
   for (const Connector &ctor : ctors) {
     assert((ctor.node() != nullptr) &&
            "Input Connector must be associated with a node");
-    (void)ctors; // Suppress ununsed warning
+    (void)ctors; // avoid unused warning
   }
   IOIndex_t inID = 0;
   for (const Connector &ctor : ctors) {

src/graph/Node.cpp

@@ -37,7 +37,7 @@ Aidge::Connector Aidge::Node::operator()(const std::vector<Connector> &ctors) {
     assert((ctors.size() == nbDataInputs()) && "Wrong number of arguments.\n");
     for (std::pair<std::shared_ptr<Node>, IOIndex_t> &input : inputs()) {
         assert((gk_IODefaultIndex == input.second) && "At least one input connection is not free.\n");
-        (void) input;
+        (void) input; // avoid unused warning
     }
     IOIndex_t i = 0;
     for (const Connector &ctor : ctors) {