VariantFunctions.hpp

00001 // ArduinoJson - arduinojson.org
00002 // Copyright Benoit Blanchon 2014-2021
00003 // MIT License
00004 
00005 #pragma once
00006 
00007 #include <ArduinoJson/Polyfills/attributes.hpp>
00008 #include <ArduinoJson/Variant/VariantData.hpp>
00009 
00010 namespace ARDUINOJSON_NAMESPACE {
00011 
00012 template <typename TVisitor>
00013 inline typename TVisitor::result_type variantAccept(const VariantData *var,
00014                                                     TVisitor &visitor) {
00015   if (var != 0)
00016     return var->accept(visitor);
00017   else
00018     return visitor.visitNull();
00019 }
00020 
00021 inline const CollectionData *variantAsArray(const VariantData *var) {
00022   return var != 0 ? var->asArray() : 0;
00023 }
00024 
00025 inline const CollectionData *variantAsObject(const VariantData *var) {
00026   return var != 0 ? var->asObject() : 0;
00027 }
00028 
00029 inline CollectionData *variantAsObject(VariantData *var) {
00030   return var != 0 ? var->asObject() : 0;
00031 }
00032 
00033 inline bool variantCopyFrom(VariantData *dst, const VariantData *src,
00034                             MemoryPool *pool) {
00035   if (!dst)
00036     return false;
00037   if (!src) {
00038     dst->setNull();
00039     return true;
00040   }
00041   return dst->copyFrom(*src, pool);
00042 }
00043 
00044 inline int variantCompare(const VariantData *a, const VariantData *b);
00045 
00046 inline bool variantIsArray(const VariantData *var) {
00047   return var && var->isArray();
00048 }
00049 
00050 inline bool variantIsBoolean(const VariantData *var) {
00051   return var && var->isBoolean();
00052 }
00053 
00054 template <typename T>
00055 inline bool variantIsInteger(const VariantData *var) {
00056   return var && var->isInteger<T>();
00057 }
00058 
00059 inline bool variantIsFloat(const VariantData *var) {
00060   return var && var->isFloat();
00061 }
00062 
00063 inline bool variantIsString(const VariantData *var) {
00064   return var && var->isString();
00065 }
00066 
00067 inline bool variantIsObject(const VariantData *var) {
00068   return var && var->isObject();
00069 }
00070 
00071 inline bool variantIsNull(const VariantData *var) {
00072   return var == 0 || var->isNull();
00073 }
00074 
00075 inline bool variantSetBoolean(VariantData *var, bool value) {
00076   if (!var)
00077     return false;
00078   var->setBoolean(value);
00079   return true;
00080 }
00081 
00082 inline bool variantSetFloat(VariantData *var, Float value) {
00083   if (!var)
00084     return false;
00085   var->setFloat(value);
00086   return true;
00087 }
00088 
00089 inline bool variantSetLinkedRaw(VariantData *var,
00090                                 SerializedValue<const char *> value) {
00091   if (!var)
00092     return false;
00093   var->setLinkedRaw(value);
00094   return true;
00095 }
00096 
00097 template <typename T>
00098 inline bool variantSetOwnedRaw(VariantData *var, SerializedValue<T> value,
00099                                MemoryPool *pool) {
00100   return var != 0 && var->setOwnedRaw(value, pool);
00101 }
00102 
00103 inline void variantSetNull(VariantData *var) {
00104   if (!var)
00105     return;
00106   var->setNull();
00107 }
00108 
00109 template <typename TAdaptedString>
00110 inline bool variantSetString(VariantData *var, TAdaptedString value,
00111                              MemoryPool *pool) {
00112   if (!var)
00113     return false;
00114   return var->setString(value, pool);
00115 }
00116 
00117 template <typename T>
00118 inline bool variantSetInteger(VariantData *var, T value) {
00119   ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
00120   if (!var)
00121     return false;
00122   var->setInteger(value);
00123   return true;
00124 }
00125 
00126 inline size_t variantSize(const VariantData *var) {
00127   return var != 0 ? var->size() : 0;
00128 }
00129 
00130 inline CollectionData *variantToArray(VariantData *var) {
00131   if (!var)
00132     return 0;
00133   return &var->toArray();
00134 }
00135 
00136 inline CollectionData *variantToObject(VariantData *var) {
00137   if (!var)
00138     return 0;
00139   return &var->toObject();
00140 }
00141 
00142 inline NO_INLINE VariantData *variantAddElement(VariantData *var,
00143                                                 MemoryPool *pool) {
00144   return var != 0 ? var->addElement(pool) : 0;
00145 }
00146 
00147 inline NO_INLINE VariantData *variantGetOrAddElement(VariantData *var,
00148                                                      size_t index,
00149                                                      MemoryPool *pool) {
00150   return var != 0 ? var->getOrAddElement(index, pool) : 0;
00151 }
00152 
00153 template <typename TChar>
00154 NO_INLINE VariantData *variantGetOrAddMember(VariantData *var, TChar *key,
00155                                              MemoryPool *pool) {
00156   return var != 0 ? var->getOrAddMember(adaptString(key), pool) : 0;
00157 }
00158 
00159 template <typename TString>
00160 NO_INLINE VariantData *variantGetOrAddMember(VariantData *var,
00161                                              const TString &key,
00162                                              MemoryPool *pool) {
00163   return var != 0 ? var->getOrAddMember(adaptString(key), pool) : 0;
00164 }
00165 
00166 }  // namespace ARDUINOJSON_NAMESPACE