Implement Layer abstraction for all layers

app/example/CMakeLists.txt

@@ -1 +1 @@
-add_executable(example main.cpp)
+add_executable(example main.cpp)

include/layer/layer.h

@@ -0,0 +1,30 @@
+#ifndef LAYER_H
+#define LAYER_H
+
+#include <list>
+#include <string>
+
+struct LayerAttributes {
+  int id = -1;
+};
+
+class Layer {
+ protected:
+  int id_;
+
+ public:
+  Layer() = default;
+  explicit Layer(const LayerAttributes& attrs) : id_(attrs.id) {}
+  explicit Layer(int id) : id_(id) {}
+  virtual ~Layer() = default;
+  void setID(int id) { id_ = id; }
+  int getID() const { return id_; }
+  virtual std::string getInfoString() const;
+  virtual void exec() = 0;
+
+  virtual std::string get_type_name() const = 0;
+  void addNeighbor(Layer* neighbor);
+  void removeNeighbor(Layer* neighbor);
+  std::list<Layer*> neighbors_;
+};
+#endif

src/layer/ConcatenateLayer.cpp

@@ -0,0 +1,60 @@
+#ifndef ACL_CONCATENATE_LAYER_H
+#define ACL_CONCATENATE_LAYER_H
+
+#include <exception>
+#include <stdexcept>
+#include <string>
+
+#include "layer/layer.h"
+
+class ConcatenateLayer : public Layer {
+ private:
+  NEConcatenateLayer concat_;
+  bool configured_ = false;
+
+ public:
+  ConcatenateLayer(int id) : Layer(id) {}
+
+  void configure(const std::vector<TensorShape>& inputs_shapes,
+                 unsigned int axis, TensorShape& output_shape,
+                 std::vector<Tensor*>& input, Tensor& output) {
+    try {
+      std::vector<const ITensor*> inpcopy;
+      std::vector<const ITensorInfo*> inp_info;
+
+      for (int i = 0; i < input.size(); i++) {
+        input[i]->allocator()->init(
+            TensorInfo(inputs_shapes[i], 1, DataType::F32));
+        input[i]->allocator()->allocate();
+        inp_info.push_back(input[i]->info());
+        inpcopy.push_back(input[i]);
+      }
+
+      output.allocator()->init(TensorInfo(output_shape, 1, DataType::F32));
+
+      if (!NEConcatenateLayer::validate(inp_info, output.info(), axis)) {
+        throw std::runtime_error("ConcatenateLayer: Validation failed");
+      }
+
+      output.allocator()->allocate();
+      concat_.configure(inpcopy, &output, axis);
+
+      configured_ = true;
+    } catch (const std::exception& e) {
+      configured_ = false;
+      std::cerr << "ConcatenateLayer configuration error: " << e.what()
+                << std::endl;
+    }
+  }
+
+  void exec() override {
+    if (!configured_) {
+      throw std::runtime_error("ConcatenateLayer: Layer not configured.");
+    }
+    concat_.run();
+  }
+
+  std::string get_type_name() const override { return "ConcatenateLayer"; }
+};
+
+#endif

src/layer/ConvLayer.cpp

@@ -0,0 +1,58 @@
+#ifndef ACL_CONVOLUTION_LAYER_SIMPLIFIED_H
+#define ACL_CONVOLUTION_LAYER_SIMPLIFIED_H
+
+#include <exception>
+#include <stdexcept>
+#include <string>
+
+#include "layer/layer.h"
+
+class ConvolutionLayer : public Layer {
+ private:
+  NEConvolutionLayer conv_;
+  bool configured_ = false;
+
+ public:
+  ConvolutionLayer(int id) : Layer(id) {}
+
+  void configure(const TensorShape& input_shape,
+                 const TensorShape& weights_shape,
+                 const TensorShape& biases_shape, TensorShape& output_shape,
+                 const PadStrideInfo& info, Tensor& input, Tensor& weights,
+                 Tensor& biases, Tensor& output) {
+    try {
+      input.allocator()->init(TensorInfo(input_shape, 1, DataType::F32));
+      weights.allocator()->init(TensorInfo(weights_shape, 1, DataType::F32));
+      biases.allocator()->init(TensorInfo(biases_shape, 1, DataType::F32));
+      output.allocator()->init(TensorInfo(output_shape, 1, DataType::F32));
+
+      if (!NEConvolutionLayer::validate(input.info(), weights.info(),
+                                        biases.info(), output.info(), info)) {
+        throw std::runtime_error("ConvolutionLayer: Validation failed");
+      }
+
+      input.allocator()->allocate();
+      weights.allocator()->allocate();
+      biases.allocator()->allocate();
+      output.allocator()->allocate();
+
+      conv_.configure(&input, &weights, &biases, &output, info);
+      configured_ = true;
+    } catch (const std::exception& e) {
+      configured_ = false;
+      std::cerr << "ConvolutionLayer configuration error: " << e.what()
+                << std::endl;
+    }
+  }
+
+  void exec() override {
+    if (!configured_) {
+      throw std::runtime_error("ConvolutionLayer: Layer not configured.");
+    }
+    conv_.run();
+  }
+
+  std::string get_type_name() const override { return "ConvolutionLayer"; }
+};
+
+#endif