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 <details/ie_exception.hpp>
12 #include <algorithm>
13 #include <typeinfo>
14 #include <iterator>
15 #include <utility>
16 #include <vector>
17 #include <cctype>
18 #include <string>
19 #include <tuple>
20 #include <map>
21 
22 namespace InferenceEngine {
23 
24 /**
25  * @brief This class represents an object to work with different parameters
26  */
27 class Parameter {
28 public:
29  /**
30  * @brief Default constructor
31  */
32  Parameter() = default;
33 
34  /**
35  * @brief Move constructor
36  * @param parameter Parameter object
37  */
38  Parameter(Parameter &&parameter) noexcept: ptr(std::move(parameter.ptr)) {}
39 
40  /**
41  * @brief Copy constructor
42  * @param parameter Parameter object
43  */
44  Parameter(const Parameter &parameter) {
45  *this = parameter;
46  }
47 
48  /**
49  * @brief Constructor creates parameter with object
50  * @tparam T Parameter type
51  * @tparam U Identity type-transformation
52  * @param parameter object
53  */
54  template<class T>
55  Parameter(T&& parameter) { // NOLINT
56  ptr = new RealData<typename std::decay<T>::type>(std::forward<T>(parameter));
57  }
58 
59  /**
60  * @brief Constructor creates string parameter from char *
61  * @param str char array
62  */
63  Parameter(const char *str): Parameter(std::string(str)) {} // NOLINT
64 
65  /**
66  * @brief Destructor
67  */
68  virtual ~Parameter() {
69  clear();
70  }
71 
72  /**
73  * Copy operator for Parameter
74  * @param parameter Parameter object
75  * @return Parameter
76  */
77  Parameter& operator=(const Parameter& parameter) {
78  if (this == &parameter) {
79  return *this;
80  }
81  clear();
82  if (!parameter.empty())
83  ptr = parameter.ptr->copy();
84  return *this;
85  }
86 
87  /**
88  * Remove a value from parameter
89  */
90  void clear() {
91  delete ptr;
92  ptr = nullptr;
93  }
94 
95  /**
96  * Checks that parameter contains a value
97  * @return false if parameter contains a value else false
98  */
99  bool empty() const noexcept {
100  return nullptr == ptr;
101  }
102 
103  /**
104  * Checks the type of value
105  * @tparam T Type of value
106  * @return true if type of value is correct
107  */
108  template<class T>
109  bool is() const {
110  return empty() ? false : ptr->is(typeid(T));
111  }
112 
113  /**
114  * Dynamic cast to specified type
115  * @tparam T type
116  * @return casted object
117  */
118  template<typename T>
119  T &&as() && {
120  return std::move(dyn_cast<T>(ptr));
121  }
122 
123  /**
124  * Dynamic cast to specified type
125  * @tparam T type
126  * @return casted object
127  */
128  template<class T>
129  T& as() & {
130  return dyn_cast<T>(ptr);
131  }
132  /**
133  * Dynamic cast to specified type
134  * @tparam T type
135  * @return casted object
136  */
137  template<class T>
138  const T& as() const & {
139  return dyn_cast<T>(ptr);
140  }
141 
142  /**
143  * Dynamic cast to specified type
144  * @tparam T type
145  * @return casted object
146  */
147  template<class T>
148  operator T&&() && {
149  return std::move(dyn_cast<typename std::remove_cv<T>::type>(ptr));
150  }
151 
152  /**
153  * Dynamic cast to specified type
154  * @tparam T type
155  * @return casted object
156  */
157  template<class T>
158  operator T&() & {
159  return dyn_cast<typename std::remove_cv<T>::type>(ptr);
160  }
161 
162  /**
163  * Dynamic cast to specified type
164  * @tparam T type
165  * @return casted object
166  */
167  template<class T> operator const T&() const & {
168  return dyn_cast<typename std::remove_cv<T>::type>(ptr);
169  }
170 
171  /**
172  * Dynamic cast to specified type
173  * @tparam T type
174  * @return casted object
175  */
176  template<class T> operator T&() const & {
177  return dyn_cast<typename std::remove_cv<T>::type>(ptr);
178  }
179 
180  /**
181  * @brief The comparison operator for the Parameter
182  * @param rhs object to compare
183  * @return true if objects are equal
184  */
185  bool operator == (const Parameter& rhs) const {
186  return *ptr == *(rhs.ptr);
187  }
188  /**
189  * @brief The comparison operator for the Parameter
190  * @param rhs object to compare
191  * @return true if objects aren't equal
192  */
193  bool operator != (const Parameter& rhs) const {
194  return !(*this == rhs);
195  }
196 
197 private:
198  template<class T, class EqualTo>
199  struct CheckOperatorEqual {
200  template<class U, class V>
201  static auto test(U*) -> decltype(std::declval<U>() == std::declval<V>()) {
202  return false;
203  }
204 
205  template<typename, typename>
206  static auto test(...) -> std::false_type {
207  return {};
208  }
209 
210  using type = typename std::is_same<bool, decltype(test<T, EqualTo>(nullptr))>::type;
211  };
212 
213  template<class T, class EqualTo = T>
214  struct HasOperatorEqual : CheckOperatorEqual<T, EqualTo>::type {};
215 
216  struct Any {
217  virtual ~Any() = default;
218  virtual bool is(const std::type_info&) const = 0;
219  virtual Any *copy() const = 0;
220  virtual bool operator==(const Any& rhs) const = 0;
221  };
222 
223  template<class T>
224  struct RealData: Any, std::tuple<T> {
225  using std::tuple<T>::tuple;
226 
227  bool is(const std::type_info& id) const override {
228  return id == typeid(T);
229  }
230  Any *copy() const override {
231  return new RealData{get()};
232  }
233 
234  T& get() & {
235  return std::get<0>(*this);
236  }
237 
238  const T& get() const & {
239  return std::get<0>(*this);
240  }
241 
242  template <class U>
243  typename std::enable_if<!HasOperatorEqual<U>::value, bool>::type
244  equal(const Any& left, const Any& rhs) const {
245  THROW_IE_EXCEPTION << "Parameter doesn't contain equal operator";
246  }
247 
248  template <class U>
249  typename std::enable_if<HasOperatorEqual<U>::value, bool>::type
250  equal(const Any& left, const Any& rhs) const {
251  return dyn_cast<U>(&left) == dyn_cast<U>(&rhs);
252  }
253 
254  bool operator==(const Any& rhs) const override {
255  return rhs.is(typeid(T)) && equal<T>(*this, rhs);
256  }
257  };
258 
259  template<typename T>
260  static T &dyn_cast(Any* obj) {
261  if (obj == nullptr)
262  THROW_IE_EXCEPTION << "Parameter is empty!";
263  return dynamic_cast<RealData<T>&>(*obj).get();
264  }
265 
266  template<typename T>
267  static const T &dyn_cast(const Any* obj) {
268  if (obj == nullptr)
269  THROW_IE_EXCEPTION << "Parameter is empty!";
270  return dynamic_cast<const RealData<T> &>(*obj).get();
271  }
272 
273  Any *ptr = nullptr;
274 };
275 
276 } // namespace InferenceEngine
THROW_IE_EXCEPTION
#define THROW_IE_EXCEPTION
A macro used to throw the exception with a notable description.
Definition: ie_exception.hpp:22
InferenceEngine::Parameter::is
bool is() const
Definition: ie_parameter.hpp:109
InferenceEngine
Definition: ie_argmax_layer.hpp:11
InferenceEngine::Parameter::Parameter
Parameter(Parameter &&parameter) noexcept
Move constructor.
Definition: ie_parameter.hpp:38
InferenceEngine::Parameter::as
T & as() &
Definition: ie_parameter.hpp:129
InferenceEngine::Parameter::Parameter
Parameter(const Parameter &parameter)
Copy constructor.
Definition: ie_parameter.hpp:44
InferenceEngine::Parameter::operator==
bool operator==(const Parameter &rhs) const
The comparison operator for the Parameter.
Definition: ie_parameter.hpp:185
InferenceEngine::Parameter::Parameter
Parameter()=default
Default constructor.
InferenceEngine::Parameter::clear
void clear()
Definition: ie_parameter.hpp:90
InferenceEngine::Parameter::empty
bool empty() const noexcept
Definition: ie_parameter.hpp:99
InferenceEngine::Parameter::operator=
Parameter & operator=(const Parameter &parameter)
Definition: ie_parameter.hpp:77
InferenceEngine::Parameter::as
const T & as() const &
Definition: ie_parameter.hpp:138
InferenceEngine::Parameter::Parameter
Parameter(const char *str)
Constructor creates string parameter from char *.
Definition: ie_parameter.hpp:63
InferenceEngine::Parameter::as
T && as() &&
Definition: ie_parameter.hpp:119
InferenceEngine::Parameter::operator!=
bool operator!=(const Parameter &rhs) const
The comparison operator for the Parameter.
Definition: ie_parameter.hpp:193
InferenceEngine::Parameter::Parameter
Parameter(T &&parameter)
Constructor creates parameter with object.
Definition: ie_parameter.hpp:55
InferenceEngine::Parameter
This class represents an object to work with different parameters.
Definition: ie_parameter.hpp:27
InferenceEngine::Parameter::~Parameter
virtual ~Parameter()
Destructor.
Definition: ie_parameter.hpp:68
ie_exception.hpp
A header file for the main Inference Engine exception.