ie_parameter.hpp
1 // Copyright (C) 2018-2019 Intel Corporation
2 // SPDX-License-Identifier: Apache-2.0
3 //
4 
5 /**
6  * @brief A header file for the CNNNetworkIterator class
7  * @file ie_cnn_network_iterator.hpp
8  */
9 #pragma once
10 
11 #include <algorithm>
12 #include <cctype>
13 #include <details/ie_exception.hpp>
14 #include <iterator>
15 #include <map>
16 #include <memory>
17 #include <string>
18 #include <tuple>
19 #include <typeinfo>
20 #include <utility>
21 #include <vector>
22 
23 #include "ie_api.h"
24 
25 namespace ngraph {
26 
27 class Variant;
28 
29 } // namespace ngraph
30 
31 namespace InferenceEngine {
32 
33 /**
34  * @brief This class represents an object to work with different parameters
35  */
36 class INFERENCE_ENGINE_API_CLASS(Parameter) {
37 public:
38  /**
39  * @brief Default constructor
40  */
41  Parameter() = default;
42 
43  /**
44  * @brief Move constructor
45  * @param parameter Parameter object
46  */
47  Parameter(Parameter&& parameter) noexcept {
48  std::swap(ptr, parameter.ptr);
49  }
50 
51  /**
52  * @brief Creates parameter from variant.
53  * This method creates empty parameter if variant doesn't contain Parameter
54  *
55  * @param var ngraph variant
56  */
57  Parameter(const std::shared_ptr<ngraph::Variant>& var);
58 
59  /**
60  * @brief Copy constructor
61  * @param parameter Parameter object
62  */
63  Parameter(const Parameter& parameter) {
64  *this = parameter;
65  }
66 
67  /**
68  * @brief Constructor creates parameter with object
69  * @tparam T Parameter type
70  * @tparam U Identity type-transformation
71  * @param parameter object
72  */
73  template <class T,
74  typename = typename std::enable_if<!std::is_same<typename std::decay<T>::type, Parameter>::value>::type>
75  Parameter(T&& parameter) { // NOLINT
76  static_assert(!std::is_same<typename std::decay<T>::type, Parameter>::value, "To prevent recursion");
77  ptr = new RealData<typename std::decay<T>::type>(std::forward<T>(parameter));
78  }
79 
80  /**
81  * @brief Constructor creates string parameter from char *
82  * @param str char array
83  */
84  Parameter(const char* str): Parameter(std::string(str)) {} // NOLINT
85 
86  /**
87  * @brief Destructor
88  */
89  virtual ~Parameter();
90 
91  /**
92  * Copy operator for Parameter
93  * @param parameter Parameter object
94  * @return Parameter
95  */
96  Parameter& operator=(const Parameter& parameter) {
97  if (this == &parameter) {
98  return *this;
99  }
100  clear();
101  if (!parameter.empty()) ptr = parameter.ptr->copy();
102  return *this;
103  }
104 
105  /**
106  * Remove a value from parameter
107  */
108  void clear() {
109  delete ptr;
110  ptr = nullptr;
111  }
112 
113  /**
114  * Checks that parameter contains a value
115  * @return false if parameter contains a value else false
116  */
117  bool empty() const noexcept {
118  return nullptr == ptr;
119  }
120 
121  /**
122  * Checks the type of value
123  * @tparam T Type of value
124  * @return true if type of value is correct
125  */
126  template <class T>
127  bool is() const {
128  return empty() ? false : ptr->is(typeid(T));
129  }
130 
131  /**
132  * Dynamic cast to specified type
133  * @tparam T type
134  * @return casted object
135  */
136  template <typename T>
137  T&& as() && {
138  return std::move(dyn_cast<T>(ptr));
139  }
140 
141  /**
142  * Dynamic cast to specified type
143  * @tparam T type
144  * @return casted object
145  */
146  template <class T>
147  T& as() & {
148  return dyn_cast<T>(ptr);
149  }
150  /**
151  * Dynamic cast to specified type
152  * @tparam T type
153  * @return casted object
154  */
155  template <class T>
156  const T& as() const& {
157  return dyn_cast<T>(ptr);
158  }
159 
160  /**
161  * Dynamic cast to specified type
162  * @tparam T type
163  * @return casted object
164  */
165  template <class T>
166  operator T &&() && {
167  return std::move(dyn_cast<typename std::remove_cv<T>::type>(ptr));
168  }
169 
170  /**
171  * Dynamic cast to specified type
172  * @tparam T type
173  * @return casted object
174  */
175  template <class T>
176  operator T&() & {
177  return dyn_cast<typename std::remove_cv<T>::type>(ptr);
178  }
179 
180  /**
181  * Dynamic cast to specified type
182  * @tparam T type
183  * @return casted object
184  */
185  template <class T>
186  operator const T&() const& {
187  return dyn_cast<typename std::remove_cv<T>::type>(ptr);
188  }
189 
190  /**
191  * @brief Converts parameter to shared pointer on ngraph::Variant
192  *
193  * @return shared pointer on ngraph::Variant
194  */
195  std::shared_ptr<ngraph::Variant> asVariant() const;
196 
197  /**
198  * @brief Casts to shared pointer on ngraph::Variant
199  *
200  * @return shared pointer on ngraph::Variant
201  */
202  operator std::shared_ptr<ngraph::Variant>() const {
203  return asVariant();
204  }
205 
206  /**
207  * Dynamic cast to specified type
208  * @tparam T type
209  * @return casted object
210  */
211  template <class T>
212  operator T&() const& {
213  return dyn_cast<typename std::remove_cv<T>::type>(ptr);
214  }
215 
216  /**
217  * @brief The comparison operator for the Parameter
218  * @param rhs object to compare
219  * @return true if objects are equal
220  */
221  bool operator==(const Parameter& rhs) const {
222  return *ptr == *(rhs.ptr);
223  }
224  /**
225  * @brief The comparison operator for the Parameter
226  * @param rhs object to compare
227  * @return true if objects aren't equal
228  */
229  bool operator!=(const Parameter& rhs) const {
230  return !(*this == rhs);
231  }
232 
233 private:
234  template <class T, class EqualTo>
235  struct CheckOperatorEqual {
236  template <class U, class V>
237  static auto test(U*) -> decltype(std::declval<U>() == std::declval<V>()) {
238  return false;
239  }
240 
241  template <typename, typename>
242  static auto test(...) -> std::false_type {
243  return {};
244  }
245 
246  using type = typename std::is_same<bool, decltype(test<T, EqualTo>(nullptr))>::type;
247  };
248 
249  template <class T, class EqualTo = T>
250  struct HasOperatorEqual : CheckOperatorEqual<T, EqualTo>::type {};
251 
252  struct Any {
253 #ifdef __clang__
254  virtual ~Any();
255 #else
256  virtual ~Any() = default;
257 #endif
258  virtual bool is(const std::type_info&) const = 0;
259  virtual Any* copy() const = 0;
260  virtual bool operator==(const Any& rhs) const = 0;
261  };
262 
263  template <class T>
264  struct RealData : Any, std::tuple<T> {
265  using std::tuple<T>::tuple;
266 
267  bool is(const std::type_info& id) const override {
268  return id == typeid(T);
269  }
270  Any* copy() const override {
271  return new RealData {get()};
272  }
273 
274  T& get() & {
275  return std::get<0>(*static_cast<std::tuple<T>*>(this));
276  }
277 
278  const T& get() const& {
279  return std::get<0>(*static_cast<const std::tuple<T>*>(this));
280  }
281 
282  template <class U>
283  typename std::enable_if<!HasOperatorEqual<U>::value, bool>::type equal(const Any& left, const Any& rhs) const {
284  THROW_IE_EXCEPTION << "Parameter doesn't contain equal operator";
285  }
286 
287  template <class U>
288  typename std::enable_if<HasOperatorEqual<U>::value, bool>::type equal(const Any& left, const Any& rhs) const {
289  return dyn_cast<U>(&left) == dyn_cast<U>(&rhs);
290  }
291 
292  bool operator==(const Any& rhs) const override {
293  return rhs.is(typeid(T)) && equal<T>(*this, rhs);
294  }
295  };
296 
297  template <typename T>
298  static T& dyn_cast(Any* obj) {
299  if (obj == nullptr) THROW_IE_EXCEPTION << "Parameter is empty!";
300  return dynamic_cast<RealData<T>&>(*obj).get();
301  }
302 
303  template <typename T>
304  static const T& dyn_cast(const Any* obj) {
305  if (obj == nullptr) THROW_IE_EXCEPTION << "Parameter is empty!";
306  return dynamic_cast<const RealData<T>&>(*obj).get();
307  }
308 
309  Any* ptr = nullptr;
310 };
311 
312 #ifdef __clang__
313 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<int>);
314 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<bool>);
315 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<float>);
316 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<uint32_t>);
317 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<std::string>);
318 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<unsigned long>);
319 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<std::vector<int>>);
320 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<std::vector<std::string>>);
321 extern template struct INFERENCE_ENGINE_API_CLASS(InferenceEngine::Parameter::RealData<std::vector<unsigned long>>);
322 extern template struct INFERENCE_ENGINE_API_CLASS(
323  InferenceEngine::Parameter::RealData<std::tuple<unsigned int, unsigned int>>);
324 extern template struct INFERENCE_ENGINE_API_CLASS(
325  InferenceEngine::Parameter::RealData<std::tuple<unsigned int, unsigned int, unsigned int>>);
326 #endif // __clang__
327 
328 } // namespace InferenceEngine
THROW_IE_EXCEPTION
#define THROW_IE_EXCEPTION
A macro used to throw the exception with a notable description.
Definition: ie_exception.hpp:24
InferenceEngine::Parameter::Parameter
Parameter(T &&parameter)
Constructor creates parameter with object.
Definition: ie_parameter.hpp:75
InferenceEngine::Parameter::is
bool is() const
Definition: ie_parameter.hpp:127
InferenceEngine
Inference Engine API.
Definition: ie_argmax_layer.hpp:11
InferenceEngine::Parameter::Parameter
Parameter(Parameter &&parameter) noexcept
Move constructor.
Definition: ie_parameter.hpp:47
InferenceEngine::Parameter::as
T & as() &
Definition: ie_parameter.hpp:147
InferenceEngine::Parameter::Parameter
Parameter(const Parameter &parameter)
Copy constructor.
Definition: ie_parameter.hpp:63
InferenceEngine::Parameter::operator==
bool operator==(const Parameter &rhs) const
The comparison operator for the Parameter.
Definition: ie_parameter.hpp:221
InferenceEngine::Parameter::clear
void clear()
Definition: ie_parameter.hpp:108
InferenceEngine::Parameter::empty
bool empty() const noexcept
Definition: ie_parameter.hpp:117
ngraph
Definition: ie_cnn_network.h:26
InferenceEngine::Parameter::operator=
Parameter & operator=(const Parameter &parameter)
Definition: ie_parameter.hpp:96
InferenceEngine::Parameter::as
const T & as() const &
Definition: ie_parameter.hpp:156
InferenceEngine::Parameter::Parameter
Parameter(const char *str)
Constructor creates string parameter from char *.
Definition: ie_parameter.hpp:84
InferenceEngine::Parameter::as
T && as() &&
Definition: ie_parameter.hpp:137
ie_api.h
The macro defines a symbol import/export mechanism essential for Microsoft Windows(R) OS...
InferenceEngine::Parameter::operator!=
bool operator!=(const Parameter &rhs) const
The comparison operator for the Parameter.
Definition: ie_parameter.hpp:229
InferenceEngine::Parameter
This class represents an object to work with different parameters.
Definition: ie_parameter.hpp:36
ie_exception.hpp
A header file for the main Inference Engine exception.