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