class OCRepresentation
{
public:
+ friend bool operator==(const OC::OCRepresentation&, const OC::OCRepresentation&);
// Note: Implementation of all constructors and destructors
// are all placed in the same location due to a crash that
// was observed in Android, where merely constructing/destructing
virtual ~OCRepresentation(){}
+ void setDevAddr(const OCDevAddr addr);
+
+ const std::string getHost() const;
+
OCRepPayload* getPayload() const;
void addChild(const OCRepresentation&);
if(x!= m_values.end())
{
- val = boost::get<T>(x->second);
- return true;
+ try
+ {
+ val = boost::get<T>(x->second);
+ return true;
+ }
+ catch (boost::bad_get& e)
+ {
+ val = T();
+ return false;
+ }
}
else
{
auto x = m_values.find(str);
if(x != m_values.end())
{
- val = boost::get<T>(x->second);
+ try
+ {
+ val = boost::get<T>(x->second);
+ }
+ catch (boost::bad_get& e)
+ {
+ return val;
+ }
}
return val;
}
bool isNULL(const std::string& str) const;
+ private:
+ std::string m_host;
+
// STL Container stuff
public:
class iterator;
template<typename T>
T getValue() const
{
- return boost::get<T>(m_values[m_attrName]);
+ try
+ {
+ return boost::get<T>(m_values[m_attrName]);
+ }
+ catch (boost::bad_get& e)
+ {
+ T val = T();
+ return val;
+ }
}
std::string getValueToString() const;
return *this;
}
- AttributeItem& operator=(std::nullptr_t rhs)
+ AttributeItem& operator=(std::nullptr_t /*rhs*/)
{
NullType t;
m_values[m_attrName] = t;
// Enable-if required to prevent conversions to alternate types. This prevents
// ambigious conversions in the case where conversions can include a number of
// types, such as the string constructor.
- template<typename T, typename= typename std::enable_if<
+ template<typename T, typename std::enable_if<
std::is_same<T, int>::value ||
std::is_same<T, double>::value ||
std::is_same<T, bool>::value ||
std::is_same<T, std::vector<OCRepresentation>>::value ||
std::is_same<T, std::vector<std::vector<OCRepresentation>>>::value ||
std::is_same<T, std::vector<std::vector<std::vector<OCRepresentation>>>>::value
- >::type // enable_if
+ , int>::type = 0// enable_if
>
operator T() const
{
return this->getValue<T>();
}
- operator std::nullptr_t() const
+ template<typename T, typename std::enable_if<
+ std::is_same<T, std::nullptr_t>::value
+ , int>::type = 0
+ >
+ operator T() const
{
this->getValue<NullType>();
return nullptr;