inference-engine/src/inference_engine/ie_network.hpp

   1 // Copyright (C) 2018 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #pragma once
   6
   7 #include <ie_inetwork.hpp>
   8 #include <ie_blob.h>
   9 #include <memory>
  10 #include <string>
  11 #include <vector>
  12 #include <map>
  13
  14 namespace InferenceEngine {
  15 namespace details {
  16
  17 class Network;
  18
  19 class Parameters: public IParameters {
  20 public:
  21     using Ptr = std::shared_ptr<Parameters>;
  22
  23     const std::map<std::string, Parameter>& getParameters() const noexcept override {
  24         return params;
  25     }
  26     const std::map<std::string, Blob::CPtr>& getConstantData() const noexcept override {
  27         return constData;
  28     }
  29
  30     std::map<std::string, Parameter>& getParameters() {
  31         return params;
  32     }
  33     std::map<std::string, Blob::CPtr>& getConstantData() noexcept {
  34         return constData;
  35     }
  36 private:
  37     std::map<std::string, Parameter> params;
  38     std::map<std::string, InferenceEngine::Blob::CPtr> constData;
  39 };
  40
  41 class Layer: public ILayer {
  42 public:
  43     using Ptr = std::shared_ptr<Layer>;
  44
  45     explicit Layer(size_t id): id(id), params(new Parameters()) {}
  46     Layer(const Layer& layer) {
  47         this->outputs = layer.getOutputPorts();
  48         this->inputs = layer.getInputPorts();
  49         this->params = layer.getParameters();
  50         this->subGraph = layer.getGraph();
  51         this->name = layer.getName();
  52         this->type = layer.getType();
  53         this->id = layer.getId();
  54     }
  55     explicit Layer(const ILayer& layer) {
  56         this->outputs = layer.getOutputPorts();
  57         this->inputs = layer.getInputPorts();
  58         this->params = layer.getParameters();
  59         this->subGraph = layer.getGraph();
  60         this->name = layer.getName();
  61         this->type = layer.getType();
  62         this->id = layer.getId();
  63     }
  64
  65     size_t getId() const noexcept override {
  66         return id;
  67     }
  68     const std::string& getName() const noexcept override {
  69         return name;
  70     }
  71     const std::string& getType() const noexcept override {
  72         return type;
  73     }
  74     const INetwork::Ptr& getGraph() const noexcept override {
  75         return subGraph;
  76     }
  77     const IParameters::Ptr& getParameters() const noexcept override {
  78         return params;
  79     }
  80     const std::vector<Port>& getInputPorts() const noexcept override {
  81         return inputs;
  82     }
  83     const std::vector<Port>& getOutputPorts() const noexcept override {
  84         return outputs;
  85     }
  86
  87     std::string& getName() noexcept {
  88         return name;
  89     }
  90
  91     std::string& getType() noexcept {
  92         return type;
  93     }
  94     std::shared_ptr<Network> getGraph() noexcept {
  95         return std::dynamic_pointer_cast<Network>(subGraph);
  96     }
  97     void setGraph(const INetwork::Ptr& graph) noexcept {
  98         subGraph = graph;
  99     }
 100     Parameters::Ptr getParameters() noexcept {
 101         return std::dynamic_pointer_cast<Parameters>(params);
 102     }
 103     std::vector<Port>& getInputPorts() noexcept {
 104         return inputs;
 105     }
 106     std::vector<Port>& getOutputPorts() noexcept {
 107         return outputs;
 108     }
 109
 110 private:
 111     idx_t id;
 112     std::string name;
 113     std::string type;
 114     INetwork::Ptr subGraph;
 115     IParameters::Ptr params;
 116     std::vector<Port> inputs;
 117     std::vector<Port> outputs;
 118 };
 119
 120 class Network: public INetwork {
 121 public:
 122     using Ptr = std::shared_ptr<Network>;
 123     using iterator = details::INetworkIterator<Network, Layer>;
 124
 125     explicit Network(const Context& context, const std::string& name = "");
 126     Network(const Context& context, const INetwork& network);
 127     Network(const Context& context, const Network& network);
 128
 129     Network& operator=(const Network& network);
 130     Network& operator=(const INetwork& network);
 131
 132     const_iterator begin() const noexcept override;
 133     const_iterator end() const noexcept override;
 134     iterator begin() noexcept;
 135     iterator end() noexcept;
 136
 137     const ILayer::Ptr getLayer(size_t id) const noexcept override;
 138     const std::vector<ILayer::Ptr> getInputs() const noexcept override;
 139     const std::vector<ILayer::Ptr> getOutputs() const noexcept override;
 140     const std::vector<Connection> getLayerConnections(idx_t layerId) const noexcept override;
 141     size_t size() const noexcept override;
 142     const std::string& getName() const noexcept override;
 143     const Context& getContext() const noexcept override;
 144
 145     const std::vector<Connection>& getConnections() const noexcept;
 146     Layer::Ptr getLayer(size_t id) noexcept;
 147     std::string& getName() noexcept;
 148
 149     void addLayer(const ILayer::Ptr& layer) noexcept;
 150     void addConnection(const Connection& connection) noexcept;
 151
 152 private:
 153     const Context ctx;
 154     std::string name;
 155     std::vector<Layer::Ptr> layers;
 156     std::vector<Connection> connections;
 157 };
 158
 159 }  // namespace details
 160 }  // namespace InferenceEngine