ie_layer_builder.hpp
1 // Copyright (C) 2018-2019 Intel Corporation
2 // SPDX-License-Identifier: Apache-2.0
3 //
4 
5 #pragma once
6 
7 #include <details/caseless.hpp>
8 #include <ie_parameter.hpp>
9 #include <ie_network.hpp>
10 #include <ie_blob.h>
11 #include <string>
12 #include <vector>
13 #include <memory>
14 #include <map>
15 
16 namespace InferenceEngine {
17 namespace Builder {
18 
19 class Layer;
20 
21 /**
22  * @brief This structure implements a holder for validators
23  */
24 struct ValidatorsHolder {
25  /**
26  * @brief Caseless map connects type with validator
27  */
28  details::caseless_map<std::string, std::function<void(const std::shared_ptr<const Layer>&, bool)>> validators;
29 };
30 
31 /**
32  * @brief This class implements a builder for IE Layer
33  */
34 class INFERENCE_ENGINE_API_CLASS(Layer): public ILayer,
35  public std::enable_shared_from_this<Layer> {
36 public:
37  /**
38  * @brief A shared pointer to the Layer builder
39  */
40  using Ptr = std::shared_ptr<Layer>;
41  /**
42  * @brief A shared pointer to the constant Layer builder
43  */
44  using CPtr = std::shared_ptr<const Layer>;
45 
46  /**
47  * @brief The constructor creates a Layer builder with layer type and layer name
48  * @param type Layer type
49  * @param name Layer name
50  */
51  explicit Layer(const std::string& type, const std::string& name = "");
52  /**
53  * @brief The constructor creates a Layer builder from shared pointer to constant ILayer
54  * @param layer shared pointer to constant ILayer
55  */
56  explicit Layer(const ILayer::CPtr& layer);
57  /**
58  * @brief The constructor creates a Layer builder with layer ID and layer builder
59  * @param id Layer ID
60  * @param layer layer builder
61  */
62  Layer(idx_t id, const Layer& layer);
63 
64  /**
65  * @brief Compares the given Layer builder with the current one
66  * @param rhs Layer builder to compare with
67  * @return true if the given Layer builder is equal to the current one, false - otherwise
68  */
69  bool operator==(const Layer& rhs) const {
70  return params == rhs.params;
71  }
72 
73  /**
74  * @brief Returns layer ID
75  * @return Layer ID
76  */
77  idx_t getId() const noexcept override;
78 
79  /**
80  * @brief Returns a constant reference to layer name
81  * @return Layer name
82  */
83  const std::string& getName() const noexcept override;
84  /**
85  * @brief Sets layer name
86  * @param name Layer name
87  * @return Reference to Layer builder
88  */
89  Layer& setName(const std::string& name);
90 
91  /**
92  * @brief Returns a constant reference to layer type
93  * @return Layer type
94  */
95  const std::string& getType() const noexcept override;
96  /**
97  * @brief Sets layer type
98  * @param type Layer type
99  * @return Reference to Layer builder
100  */
101  Layer& setType(const std::string& type);
102 
103  /**
104  * @brief Returns map of parameters
105  * @return map of parameters
106  */
107  const std::map<std::string, Parameter>& getParameters() const noexcept override;
108  /**
109  * @brief Returns map of parameters
110  * @return map of parameters
111  */
112  std::map<std::string, Parameter>& getParameters();
113  /**
114  * @brief Sets parameters for layer
115  * @param params constant map of parameters
116  * @return Reference to Layer builder
117  */
118  Layer& setParameters(const std::map<std::string, Parameter>& params);
119 
120  /**
121  * @brief Returns vector of input ports
122  * @return Vector of input ports
123  */
124  const std::vector<Port>& getInputPorts() const noexcept override;
125  /**
126  * @brief Returns vector of input ports
127  * @return Vector of input ports
128  */
129  std::vector<Port>& getInputPorts();
130  /**
131  * @brief Sets input ports
132  * @param ports vector of ports
133  * @return Reference to Layer builder
134  */
135  Layer& setInputPorts(const std::vector<Port> &ports);
136 
137  /**
138  * @brief Returns vector of output ports
139  * @return Vector of output ports
140  */
141  const std::vector<Port>& getOutputPorts() const noexcept override;
142  /**
143  * @brief Returns vector of output ports
144  * @return Vector of output ports
145  */
146  std::vector<Port>& getOutputPorts();
147  /**
148  * @brief Sets output ports
149  * @param ports vector of ports
150  * @return Reference to Layer builder
151  */
152  Layer& setOutputPorts(const std::vector<Port> &ports);
153 
154  /**
155  * @brief Validates the current builder and generates ILayer object
156  * @return constant shared pointer to ILayer
157  */
158  const ILayer::CPtr build() const;
159 
160  /**
161  * @brief Validates layer builder
162  */
163  void validate(bool partial = false) const;
164 
165  /**
166  * @brief Registers a new validator for type
167  * @param type Layer type
168  * @param validator Layer validator
169  */
170  static void addValidator(const std::string& type, const std::function<void(const Layer::CPtr&, bool)>& validator);
171 
172 private:
173  idx_t id;
174  std::string type;
175  std::string name;
176  std::vector<Port> inPorts;
177  std::vector<Port> outPorts;
178  std::map<std::string, Parameter> params;
179  static std::shared_ptr<ValidatorsHolder> getValidatorsHolder();
180 };
181 
182 /**
183  * @brief This class registers layer validators
184  */
185 class ValidatorRegisterBase {
186 public:
187  /**
188  * @brief The constructor registers new layer validator
189  * @param type Layer type
190  * @param validator Layer validator
191  */
192  explicit ValidatorRegisterBase(const std::string& type, const std::function<void(const Layer::CPtr&, bool)>& validator) {
193  InferenceEngine::Builder::Layer::addValidator(type, validator);
194  }
195 };
196 
197 #define REG_VALIDATOR_FOR(__type, __validator) \
198 static InferenceEngine::Builder::ValidatorRegisterBase _reg_##__type(#__type, __validator)
199 
200 } // namespace Builder
201 } // namespace InferenceEngine
InferenceEngine
Definition: ie_argmax_layer.hpp:11
InferenceEngine::ILayer::CPtr
std::shared_ptr< const ILayer > CPtr
A shared pointer to the const ILayer object.
Definition: ie_network.hpp:298
ie_blob.h
A header file for Blob and generic TBlob<>
InferenceEngine::Builder::ValidatorRegisterBase::ValidatorRegisterBase
ValidatorRegisterBase(const std::string &type, const std::function< void(const Layer::CPtr &, bool)> &validator)
The constructor registers new layer validator.
Definition: ie_layer_builder.hpp:192
InferenceEngine::Builder::ValidatorsHolder::validators
details::caseless_map< std::string, std::function< void(const std::shared_ptr< const Layer > &, bool)> > validators
Caseless map connects type with validator.
Definition: ie_layer_builder.hpp:28
InferenceEngine::Builder::ValidatorsHolder
This structure implements a holder for validators.
Definition: ie_layer_builder.hpp:24
InferenceEngine::ILayer
This class is the main interface to describe the Inference Engine layer. All methods here are constan...
Definition: ie_network.hpp:293
InferenceEngine::Builder::ValidatorRegisterBase
This class registers layer validators.
Definition: ie_layer_builder.hpp:185