VariantImpl.hpp

00001 // ArduinoJson - arduinojson.org
00002 // Copyright Benoit Blanchon 2014-2021
00003 // MIT License
00004 
00005 #pragma once
00006 
00007 #include <ArduinoJson/Array/ArrayRef.hpp>
00008 #include <ArduinoJson/Configuration.hpp>
00009 #include <ArduinoJson/Numbers/convertNumber.hpp>
00010 #include <ArduinoJson/Numbers/parseNumber.hpp>
00011 #include <ArduinoJson/Object/ObjectRef.hpp>
00012 #include <ArduinoJson/Variant/VariantRef.hpp>
00013 
00014 #include <string.h>  // for strcmp
00015 
00016 namespace ARDUINOJSON_NAMESPACE {
00017 
00018 template <typename T>
00019 inline T VariantData::asIntegral() const {
00020   switch (type()) {
00021     case VALUE_IS_POSITIVE_INTEGER:
00022     case VALUE_IS_BOOLEAN:
00023       return convertPositiveInteger<T>(_content.asInteger);
00024     case VALUE_IS_NEGATIVE_INTEGER:
00025       return convertNegativeInteger<T>(_content.asInteger);
00026     case VALUE_IS_LINKED_STRING:
00027     case VALUE_IS_OWNED_STRING:
00028       return parseNumber<T>(_content.asString);
00029     case VALUE_IS_FLOAT:
00030       return convertFloat<T>(_content.asFloat);
00031     default:
00032       return 0;
00033   }
00034 }
00035 
00036 inline bool VariantData::asBoolean() const {
00037   switch (type()) {
00038     case VALUE_IS_POSITIVE_INTEGER:
00039     case VALUE_IS_BOOLEAN:
00040     case VALUE_IS_NEGATIVE_INTEGER:
00041       return _content.asInteger != 0;
00042     case VALUE_IS_FLOAT:
00043       return _content.asFloat != 0;
00044     case VALUE_IS_NULL:
00045       return false;
00046     default:
00047       return true;
00048   }
00049 }
00050 
00051 // T = float/double
00052 template <typename T>
00053 inline T VariantData::asFloat() const {
00054   switch (type()) {
00055     case VALUE_IS_POSITIVE_INTEGER:
00056     case VALUE_IS_BOOLEAN:
00057       return static_cast<T>(_content.asInteger);
00058     case VALUE_IS_NEGATIVE_INTEGER:
00059       return -static_cast<T>(_content.asInteger);
00060     case VALUE_IS_LINKED_STRING:
00061     case VALUE_IS_OWNED_STRING:
00062       return parseNumber<T>(_content.asString);
00063     case VALUE_IS_FLOAT:
00064       return static_cast<T>(_content.asFloat);
00065     default:
00066       return 0;
00067   }
00068 }
00069 
00070 inline const char *VariantData::asString() const {
00071   switch (type()) {
00072     case VALUE_IS_LINKED_STRING:
00073     case VALUE_IS_OWNED_STRING:
00074       return _content.asString;
00075     default:
00076       return 0;
00077   }
00078 }
00079 
00080 template <typename TVariant>
00081 typename enable_if<IsVisitable<TVariant>::value, bool>::type VariantRef::set(
00082     const TVariant &value) const {
00083   VariantConstRef v = value;
00084   return variantCopyFrom(_data, v._data, _pool);
00085 }
00086 
00087 template <typename T>
00088 inline typename enable_if<is_same<T, ArrayRef>::value, ArrayRef>::type
00089 VariantRef::to() const {
00090   return ArrayRef(_pool, variantToArray(_data));
00091 }
00092 
00093 template <typename T>
00094 typename enable_if<is_same<T, ObjectRef>::value, ObjectRef>::type
00095 VariantRef::to() const {
00096   return ObjectRef(_pool, variantToObject(_data));
00097 }
00098 
00099 template <typename T>
00100 typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type
00101 VariantRef::to() const {
00102   variantSetNull(_data);
00103   return *this;
00104 }
00105 
00106 inline VariantConstRef VariantConstRef::getElement(size_t index) const {
00107   return ArrayConstRef(_data != 0 ? _data->asArray() : 0)[index];
00108 }
00109 
00110 inline VariantRef VariantRef::addElement() const {
00111   return VariantRef(_pool, variantAddElement(_data, _pool));
00112 }
00113 
00114 inline VariantRef VariantRef::getElement(size_t index) const {
00115   return VariantRef(_pool, _data != 0 ? _data->getElement(index) : 0);
00116 }
00117 
00118 inline VariantRef VariantRef::getOrAddElement(size_t index) const {
00119   return VariantRef(_pool, variantGetOrAddElement(_data, index, _pool));
00120 }
00121 
00122 template <typename TChar>
00123 inline VariantRef VariantRef::getMember(TChar *key) const {
00124   return VariantRef(_pool, _data != 0 ? _data->getMember(adaptString(key)) : 0);
00125 }
00126 
00127 template <typename TString>
00128 inline typename enable_if<IsString<TString>::value, VariantRef>::type
00129 VariantRef::getMember(const TString &key) const {
00130   return VariantRef(_pool, _data != 0 ? _data->getMember(adaptString(key)) : 0);
00131 }
00132 
00133 template <typename TChar>
00134 inline VariantRef VariantRef::getOrAddMember(TChar *key) const {
00135   return VariantRef(_pool, variantGetOrAddMember(_data, key, _pool));
00136 }
00137 
00138 template <typename TString>
00139 inline VariantRef VariantRef::getOrAddMember(const TString &key) const {
00140   return VariantRef(_pool, variantGetOrAddMember(_data, key, _pool));
00141 }
00142 
00143 inline VariantConstRef operator|(VariantConstRef preferedValue,
00144                                  VariantConstRef defaultValue) {
00145   return preferedValue ? preferedValue : defaultValue;
00146 }
00147 }  // namespace ARDUINOJSON_NAMESPACE