1 //******************************************************************
3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
24 * This file contains the declaration of classes and its members related
25 * to OCRepresentation.
28 #ifndef __OCREPRESENTATION_H
29 #define __OCREPRESENTATION_H
37 #include <AttributeValue.h>
38 #include <StringConstants.h>
41 #include "OCAndroid.h"
44 #include <OCException.h>
49 enum class InterfaceType
60 class MessageContainer
63 void setPayload(const OCPayload* rep);
65 void setPayload(const OCDevicePayload* rep);
67 void setPayload(const OCPlatformPayload* rep);
69 void setPayload(const OCRepPayload* rep);
71 OCRepPayload* getPayload() const;
73 const std::vector<OCRepresentation>& representations() const;
75 void addRepresentation(const OCRepresentation& rep);
77 const OCRepresentation& operator[](int index) const
82 const OCRepresentation& back() const
87 std::vector<OCRepresentation> m_reps;
89 class OCRepresentation
92 // Note: Implementation of all constructors and destructors
93 // are all placed in the same location due to a crash that
94 // was observed in Android, where merely constructing/destructing
95 // an OCRepresentation object was enough to cause an invalid 'free'.
96 // It is believed that this is a result of incompatible compiler
97 // options between the gradle JNI and armeabi scons build, however
98 // this fix will work in the meantime.
99 OCRepresentation(): m_interfaceType(InterfaceType::None){}
101 OCRepresentation(OCRepresentation&&) = default;
103 OCRepresentation(const OCRepresentation&) = default;
105 OCRepresentation& operator=(const OCRepresentation&) = default;
107 OCRepresentation& operator=(OCRepresentation&&) = default;
109 virtual ~OCRepresentation(){}
111 OCRepPayload* getPayload() const;
113 void addChild(const OCRepresentation&);
115 void clearChildren();
117 const std::vector<OCRepresentation>& getChildren() const;
119 void setChildren(const std::vector<OCRepresentation>& children);
121 void setUri(const char* uri);
123 void setUri(const std::string& uri);
125 std::string getUri() const;
127 const std::vector<std::string>& getResourceTypes() const;
129 void setResourceTypes(const std::vector<std::string>& resourceTypes);
131 void addResourceType(const std::string& str);
133 const std::vector<std::string>& getResourceInterfaces() const;
135 void setResourceInterfaces(const std::vector<std::string>& resourceInterfaces);
137 void addResourceInterface(const std::string& str);
139 bool emptyData() const;
141 int numberOfAttributes() const;
143 bool erase(const std::string& str);
145 template <typename T>
146 void setValue(const std::string& str, const T& val)
152 * Retrieve the attribute value associated with the supplied name
154 * @param str Name of the attribute
155 * @param val Value of the attribute
156 * @return The getValue method returns true if the attribute was
157 * found in the representation. Otherwise it returns false.
159 template <typename T>
160 bool getValue(const std::string& str, T& val) const
162 auto x = m_values.find(str);
164 if(x!= m_values.end())
166 val = boost::get<T>(x->second);
177 * Return the attribute value associated with the supplied name
179 * @param str Name of the attribute
180 * @return When the representation contains the attribute, the
181 * the associated value is returned. Otherwise, getValue
182 * returns the default contructed value for the type.
184 template <typename T>
185 T getValue(const std::string& str) const
188 auto x = m_values.find(str);
189 if(x != m_values.end())
191 val = boost::get<T>(x->second);
197 * Retrieve the attributevalue structure associated with the supplied name
199 * @param str Name of the attribute
200 * @param attrValue Attribute Value structure
201 * @return The getAttributeValue method returns true if the attribute was
202 * found in the representation. Otherwise it returns false.
204 bool getAttributeValue(const std::string& str, AttributeValue& attrValue) const
206 auto x = m_values.find(str);
208 if (x != m_values.end())
210 attrValue = x->second;
219 std::string getValueToString(const std::string& key) const;
220 bool hasAttribute(const std::string& str) const;
222 void setNULL(const std::string& str);
224 bool isNULL(const std::string& str) const;
226 // STL Container stuff
229 class const_iterator;
230 // Shim class to allow iterating and indexing of the OCRepresentation
234 friend class OCRepresentation;
235 friend class iterator;
236 friend class const_iterator;
238 const std::string& attrname() const;
239 AttributeType type() const;
240 AttributeType base_type() const;
241 size_t depth() const;
245 return boost::get<T>(m_values[m_attrName]);
248 std::string getValueToString() const;
251 AttributeItem& operator=(T&& rhs)
253 m_values[m_attrName] = std::forward<T>(rhs);
257 AttributeItem& operator=(std::nullptr_t /*rhs*/)
260 m_values[m_attrName] = t;
264 // Enable-if required to prevent conversions to alternate types. This prevents
265 // ambigious conversions in the case where conversions can include a number of
266 // types, such as the string constructor.
267 template<typename T, typename std::enable_if<
268 std::is_same<T, int>::value ||
269 std::is_same<T, double>::value ||
270 std::is_same<T, bool>::value ||
271 std::is_same<T, std::string>::value ||
272 std::is_same<T, OCRepresentation>::value ||
273 std::is_same<T, std::vector<int>>::value ||
274 std::is_same<T, std::vector<std::vector<int>>>::value ||
275 std::is_same<T, std::vector<std::vector<std::vector<int>>>>::value ||
276 std::is_same<T, std::vector<double>>::value ||
277 std::is_same<T, std::vector<std::vector<double>>>::value ||
278 std::is_same<T, std::vector<std::vector<std::vector<double>>>>::value ||
279 std::is_same<T, std::vector<bool>>::value ||
280 std::is_same<T, std::vector<std::vector<bool>>>::value ||
281 std::is_same<T, std::vector<std::vector<std::vector<bool>>>>::value ||
282 std::is_same<T, std::vector<std::string>>::value ||
283 std::is_same<T, std::vector<std::vector<std::string>>>::value ||
284 std::is_same<T, std::vector<std::vector<std::vector<std::string>>>>::value ||
285 std::is_same<T, std::vector<OCRepresentation>>::value ||
286 std::is_same<T, std::vector<std::vector<OCRepresentation>>>::value ||
287 std::is_same<T, std::vector<std::vector<std::vector<OCRepresentation>>>>::value
288 , int>::type = 0// enable_if
292 return this->getValue<T>();
295 template<typename T, typename std::enable_if<
296 std::is_same<T, std::nullptr_t>::value
301 this->getValue<NullType>();
306 AttributeItem(const std::string& name,
307 std::map<std::string, AttributeValue>& vals);
308 AttributeItem(const AttributeItem&) = default;
309 std::string m_attrName;
310 std::map<std::string, AttributeValue>& m_values;
313 // Iterator to allow iteration via STL containers/methods
316 friend class OCRepresentation;
318 typedef iterator self_type;
319 typedef AttributeItem value_type;
320 typedef value_type& reference;
321 typedef value_type* pointer;
322 typedef std::forward_iterator_tag iterator_category;
323 typedef int difference_type;
325 iterator(const iterator&) = default;
326 ~iterator() = default;
328 bool operator ==(const iterator&) const;
329 bool operator !=(const iterator&) const;
331 iterator& operator++();
332 iterator operator++(int);
334 reference operator*();
335 pointer operator->();
337 iterator(std::map<std::string, AttributeValue>::iterator&& itr,
338 std::map<std::string, AttributeValue>& vals)
339 : m_iterator(std::move(itr)),
340 m_item(m_iterator != vals.end() ? m_iterator->first:"", vals){}
341 std::map<std::string, AttributeValue>::iterator m_iterator;
342 AttributeItem m_item;
347 friend class OCRepresentation;
349 typedef iterator self_type;
350 typedef const AttributeItem value_type;
351 typedef value_type& const_reference;
352 typedef value_type* const_pointer;
353 typedef std::forward_iterator_tag iterator_category;
354 typedef int difference_type;
356 const_iterator(const iterator& rhs)
357 :m_iterator(rhs.m_iterator), m_item(rhs.m_item){}
358 const_iterator(const const_iterator&) = default;
359 ~const_iterator() = default;
361 bool operator ==(const const_iterator&) const;
362 bool operator !=(const const_iterator&) const;
364 const_iterator& operator++();
365 const_iterator operator++(int);
367 const_reference operator*() const;
368 const_pointer operator->() const;
370 const_iterator(std::map<std::string, AttributeValue>::const_iterator&& itr,
371 std::map<std::string, AttributeValue>& vals)
372 : m_iterator(std::move(itr)),
373 m_item(m_iterator != vals.end() ? m_iterator->first: "", vals){}
374 std::map<std::string, AttributeValue>::const_iterator m_iterator;
375 AttributeItem m_item;
379 const_iterator begin() const;
380 const_iterator cbegin() const;
382 const_iterator end() const;
383 const_iterator cend() const;
387 AttributeItem operator[](const std::string& key);
388 const AttributeItem operator[](const std::string& key) const;
390 friend class OCResourceResponse;
391 friend class MessageContainer;
394 void payload_array_helper(const OCRepPayloadValue* pl, size_t depth);
396 T payload_array_helper_copy(size_t index, const OCRepPayloadValue* pl);
397 void setPayload(const OCRepPayload* payload);
398 void setPayloadArray(const OCRepPayloadValue* pl);
399 void getPayloadArray(OCRepPayload* payload,
400 const OCRepresentation::AttributeItem& item) const;
401 // the root node has a slightly different JSON version
402 // based on the interface type configured in ResourceResponse.
403 // This allows ResourceResponse to set it, so that the save function
404 // doesn't serialize things that it isn't supposed to serialize.
405 void setInterfaceType(InterfaceType ift)
407 m_interfaceType = ift;
410 // class used to wrap the 'prop' feature of the save/load
414 Prop(std::vector<std::string>& resourceTypes,
415 std::vector<std::string>& interfaces)
416 : m_types(resourceTypes), m_interfaces(interfaces)
419 /* Prop(const std::vector<std::string>& resourceTypes,
420 const std::vector<std::string>& interfaces)
421 :m_types(resourceTypes),
422 m_interfaces(interfaces)
425 std::vector<std::string>& m_types;
426 std::vector<std::string>& m_interfaces;
430 std::vector<OCRepresentation> m_children;
431 mutable std::map<std::string, AttributeValue> m_values;
432 std::vector<std::string> m_resourceTypes;
433 std::vector<std::string> m_interfaces;
435 InterfaceType m_interfaceType;
438 std::ostream& operator <<(std::ostream& os, const OCRepresentation::AttributeItem& ai);
442 #endif //__OCREPRESENTATION_H