JsonDocument.hpp

00001 // ArduinoJson - arduinojson.org
00002 // Copyright Benoit Blanchon 2014-2021
00003 // MIT License
00004 
00005 #pragma once
00006 
00007 #include <ArduinoJson/Array/ElementProxy.hpp>
00008 #include <ArduinoJson/Memory/MemoryPool.hpp>
00009 #include <ArduinoJson/Object/MemberProxy.hpp>
00010 #include <ArduinoJson/Object/ObjectRef.hpp>
00011 #include <ArduinoJson/Variant/VariantRef.hpp>
00012 #include <ArduinoJson/Variant/VariantTo.hpp>
00013 
00014 namespace ARDUINOJSON_NAMESPACE {
00015 
00016 class JsonDocument : public Visitable {
00017  public:
00018   template <typename TVisitor>
00019   typename TVisitor::result_type accept(TVisitor& visitor) const {
00020     return getVariant().accept(visitor);
00021   }
00022 
00023   template <typename T>
00024   typename VariantAs<T>::type as() {
00025     return getVariant().template as<T>();
00026   }
00027 
00028   template <typename T>
00029   typename VariantConstAs<T>::type as() const {
00030     return getVariant().template as<T>();
00031   }
00032 
00033   void clear() {
00034     _pool.clear();
00035     _data.setNull();
00036   }
00037 
00038   template <typename T>
00039   bool is() const {
00040     return getVariant().template is<T>();
00041   }
00042 
00043   bool isNull() const {
00044     return getVariant().isNull();
00045   }
00046 
00047   size_t memoryUsage() const {
00048     return _pool.size();
00049   }
00050 
00051   bool overflowed() const {
00052     return _pool.overflowed();
00053   }
00054 
00055   size_t nesting() const {
00056     return _data.nesting();
00057   }
00058 
00059   size_t capacity() const {
00060     return _pool.capacity();
00061   }
00062 
00063   size_t size() const {
00064     return _data.size();
00065   }
00066 
00067   bool set(const JsonDocument& src) {
00068     return to<VariantRef>().set(src.as<VariantRef>());
00069   }
00070 
00071   template <typename T>
00072   typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set(
00073       const T& src) {
00074     return to<VariantRef>().set(src);
00075   }
00076 
00077   template <typename T>
00078   typename VariantTo<T>::type to() {
00079     clear();
00080     return getVariant().template to<T>();
00081   }
00082 
00083   // for internal use only
00084   MemoryPool& memoryPool() {
00085     return _pool;
00086   }
00087 
00088   // for internal use only
00089   VariantData& data() {
00090     return _data;
00091   }
00092 
00093   ArrayRef createNestedArray() {
00094     return addElement().to<ArrayRef>();
00095   }
00096 
00097   // createNestedArray(char*)
00098   // createNestedArray(const char*)
00099   // createNestedArray(const __FlashStringHelper*)
00100   template <typename TChar>
00101   ArrayRef createNestedArray(TChar* key) {
00102     return getOrAddMember(key).template to<ArrayRef>();
00103   }
00104 
00105   // createNestedArray(const std::string&)
00106   // createNestedArray(const String&)
00107   template <typename TString>
00108   ArrayRef createNestedArray(const TString& key) {
00109     return getOrAddMember(key).template to<ArrayRef>();
00110   }
00111 
00112   ObjectRef createNestedObject() {
00113     return addElement().to<ObjectRef>();
00114   }
00115 
00116   // createNestedObject(char*)
00117   // createNestedObject(const char*)
00118   // createNestedObject(const __FlashStringHelper*)
00119   template <typename TChar>
00120   ObjectRef createNestedObject(TChar* key) {
00121     return getOrAddMember(key).template to<ObjectRef>();
00122   }
00123 
00124   // createNestedObject(const std::string&)
00125   // createNestedObject(const String&)
00126   template <typename TString>
00127   ObjectRef createNestedObject(const TString& key) {
00128     return getOrAddMember(key).template to<ObjectRef>();
00129   }
00130 
00131   // containsKey(char*) const
00132   // containsKey(const char*) const
00133   // containsKey(const __FlashStringHelper*) const
00134   template <typename TChar>
00135   bool containsKey(TChar* key) const {
00136     return !getMember(key).isUndefined();
00137   }
00138 
00139   // containsKey(const std::string&) const
00140   // containsKey(const String&) const
00141   template <typename TString>
00142   bool containsKey(const TString& key) const {
00143     return !getMember(key).isUndefined();
00144   }
00145 
00146   // operator[](const std::string&)
00147   // operator[](const String&)
00148   template <typename TString>
00149   FORCE_INLINE typename enable_if<IsString<TString>::value,
00150                                   MemberProxy<JsonDocument&, TString> >::type
00151   operator[](const TString& key) {
00152     return MemberProxy<JsonDocument&, TString>(*this, key);
00153   }
00154 
00155   // operator[](char*)
00156   // operator[](const char*)
00157   // operator[](const __FlashStringHelper*)
00158   template <typename TChar>
00159   FORCE_INLINE typename enable_if<IsString<TChar*>::value,
00160                                   MemberProxy<JsonDocument&, TChar*> >::type
00161   operator[](TChar* key) {
00162     return MemberProxy<JsonDocument&, TChar*>(*this, key);
00163   }
00164 
00165   // operator[](const std::string&) const
00166   // operator[](const String&) const
00167   template <typename TString>
00168   FORCE_INLINE
00169       typename enable_if<IsString<TString>::value, VariantConstRef>::type
00170       operator[](const TString& key) const {
00171     return getMember(key);
00172   }
00173 
00174   // operator[](char*) const
00175   // operator[](const char*) const
00176   // operator[](const __FlashStringHelper*) const
00177   template <typename TChar>
00178   FORCE_INLINE
00179       typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
00180       operator[](TChar* key) const {
00181     return getMember(key);
00182   }
00183 
00184   FORCE_INLINE ElementProxy<JsonDocument&> operator[](size_t index) {
00185     return ElementProxy<JsonDocument&>(*this, index);
00186   }
00187 
00188   FORCE_INLINE VariantConstRef operator[](size_t index) const {
00189     return getElement(index);
00190   }
00191 
00192   FORCE_INLINE VariantRef getElement(size_t index) {
00193     return VariantRef(&_pool, _data.getElement(index));
00194   }
00195 
00196   FORCE_INLINE VariantConstRef getElement(size_t index) const {
00197     return VariantConstRef(_data.getElement(index));
00198   }
00199 
00200   FORCE_INLINE VariantRef getOrAddElement(size_t index) {
00201     return VariantRef(&_pool, _data.getOrAddElement(index, &_pool));
00202   }
00203 
00204   // JsonVariantConst getMember(char*) const
00205   // JsonVariantConst getMember(const char*) const
00206   // JsonVariantConst getMember(const __FlashStringHelper*) const
00207   template <typename TChar>
00208   FORCE_INLINE VariantConstRef getMember(TChar* key) const {
00209     return VariantConstRef(_data.getMember(adaptString(key)));
00210   }
00211 
00212   // JsonVariantConst getMember(const std::string&) const
00213   // JsonVariantConst getMember(const String&) const
00214   template <typename TString>
00215   FORCE_INLINE
00216       typename enable_if<IsString<TString>::value, VariantConstRef>::type
00217       getMember(const TString& key) const {
00218     return VariantConstRef(_data.getMember(adaptString(key)));
00219   }
00220 
00221   // JsonVariant getMember(char*)
00222   // JsonVariant getMember(const char*)
00223   // JsonVariant getMember(const __FlashStringHelper*)
00224   template <typename TChar>
00225   FORCE_INLINE VariantRef getMember(TChar* key) {
00226     return VariantRef(&_pool, _data.getMember(adaptString(key)));
00227   }
00228 
00229   // JsonVariant getMember(const std::string&)
00230   // JsonVariant getMember(const String&)
00231   template <typename TString>
00232   FORCE_INLINE typename enable_if<IsString<TString>::value, VariantRef>::type
00233   getMember(const TString& key) {
00234     return VariantRef(&_pool, _data.getMember(adaptString(key)));
00235   }
00236 
00237   // getOrAddMember(char*)
00238   // getOrAddMember(const char*)
00239   // getOrAddMember(const __FlashStringHelper*)
00240   template <typename TChar>
00241   FORCE_INLINE VariantRef getOrAddMember(TChar* key) {
00242     return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool));
00243   }
00244 
00245   // getOrAddMember(const std::string&)
00246   // getOrAddMember(const String&)
00247   template <typename TString>
00248   FORCE_INLINE VariantRef getOrAddMember(const TString& key) {
00249     return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool));
00250   }
00251 
00252   FORCE_INLINE VariantRef addElement() {
00253     return VariantRef(&_pool, _data.addElement(&_pool));
00254   }
00255 
00256   template <typename TValue>
00257   FORCE_INLINE bool add(const TValue& value) {
00258     return addElement().set(value);
00259   }
00260 
00261   // add(char*) const
00262   // add(const char*) const
00263   // add(const __FlashStringHelper*) const
00264   template <typename TChar>
00265   FORCE_INLINE bool add(TChar* value) {
00266     return addElement().set(value);
00267   }
00268 
00269   FORCE_INLINE void remove(size_t index) {
00270     _data.remove(index);
00271   }
00272   // remove(char*)
00273   // remove(const char*)
00274   // remove(const __FlashStringHelper*)
00275   template <typename TChar>
00276   FORCE_INLINE typename enable_if<IsString<TChar*>::value>::type remove(
00277       TChar* key) {
00278     _data.remove(adaptString(key));
00279   }
00280   // remove(const std::string&)
00281   // remove(const String&)
00282   template <typename TString>
00283   FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
00284       const TString& key) {
00285     _data.remove(adaptString(key));
00286   }
00287 
00288   FORCE_INLINE operator VariantConstRef() const {
00289     return VariantConstRef(&_data);
00290   }
00291 
00292   bool operator==(VariantConstRef rhs) const {
00293     return getVariant() == rhs;
00294   }
00295 
00296   bool operator!=(VariantConstRef rhs) const {
00297     return getVariant() != rhs;
00298   }
00299 
00300  protected:
00301   JsonDocument() : _pool(0, 0) {
00302     _data.setNull();
00303   }
00304 
00305   JsonDocument(MemoryPool pool) : _pool(pool) {
00306     _data.setNull();
00307   }
00308 
00309   JsonDocument(char* buf, size_t capa) : _pool(buf, capa) {
00310     _data.setNull();
00311   }
00312 
00313   ~JsonDocument() {}
00314 
00315   void replacePool(MemoryPool pool) {
00316     _pool = pool;
00317   }
00318 
00319   VariantRef getVariant() {
00320     return VariantRef(&_pool, &_data);
00321   }
00322 
00323   VariantConstRef getVariant() const {
00324     return VariantConstRef(&_data);
00325   }
00326 
00327   MemoryPool _pool;
00328   VariantData _data;
00329 
00330  private:
00331   JsonDocument(const JsonDocument&);
00332   JsonDocument& operator=(const JsonDocument&);
00333 };
00334 
00335 }  // namespace ARDUINOJSON_NAMESPACE