ArrayIterator.hpp

00001 // ArduinoJson - arduinojson.org
00002 // Copyright Benoit Blanchon 2014-2021
00003 // MIT License
00004 
00005 #pragma once
00006 
00007 #include <ArduinoJson/Variant/SlotFunctions.hpp>
00008 #include <ArduinoJson/Variant/VariantRef.hpp>
00009 
00010 namespace ARDUINOJSON_NAMESPACE {
00011 
00012 class VariantPtr {
00013  public:
00014   VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {}
00015 
00016   VariantRef *operator->() {
00017     return &_variant;
00018   }
00019 
00020   VariantRef &operator*() {
00021     return _variant;
00022   }
00023 
00024  private:
00025   VariantRef _variant;
00026 };
00027 
00028 class ArrayIterator {
00029  public:
00030   ArrayIterator() : _slot(0) {}
00031   explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot)
00032       : _pool(pool), _slot(slot) {}
00033 
00034   VariantRef operator*() const {
00035     return VariantRef(_pool, _slot->data());
00036   }
00037   VariantPtr operator->() {
00038     return VariantPtr(_pool, _slot->data());
00039   }
00040 
00041   bool operator==(const ArrayIterator &other) const {
00042     return _slot == other._slot;
00043   }
00044 
00045   bool operator!=(const ArrayIterator &other) const {
00046     return _slot != other._slot;
00047   }
00048 
00049   ArrayIterator &operator++() {
00050     _slot = _slot->next();
00051     return *this;
00052   }
00053 
00054   ArrayIterator &operator+=(size_t distance) {
00055     _slot = _slot->next(distance);
00056     return *this;
00057   }
00058 
00059   VariantSlot *internal() {
00060     return _slot;
00061   }
00062 
00063  private:
00064   MemoryPool *_pool;
00065   VariantSlot *_slot;
00066 };
00067 
00068 class VariantConstPtr {
00069  public:
00070   VariantConstPtr(const VariantData *data) : _variant(data) {}
00071 
00072   VariantConstRef *operator->() {
00073     return &_variant;
00074   }
00075 
00076   VariantConstRef &operator*() {
00077     return _variant;
00078   }
00079 
00080  private:
00081   VariantConstRef _variant;
00082 };
00083 
00084 class ArrayConstRefIterator {
00085  public:
00086   ArrayConstRefIterator() : _slot(0) {}
00087   explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {}
00088 
00089   VariantConstRef operator*() const {
00090     return VariantConstRef(_slot->data());
00091   }
00092   VariantConstPtr operator->() {
00093     return VariantConstPtr(_slot->data());
00094   }
00095 
00096   bool operator==(const ArrayConstRefIterator &other) const {
00097     return _slot == other._slot;
00098   }
00099 
00100   bool operator!=(const ArrayConstRefIterator &other) const {
00101     return _slot != other._slot;
00102   }
00103 
00104   ArrayConstRefIterator &operator++() {
00105     _slot = _slot->next();
00106     return *this;
00107   }
00108 
00109   ArrayConstRefIterator &operator+=(size_t distance) {
00110     _slot = _slot->next(distance);
00111     return *this;
00112   }
00113 
00114   const VariantSlot *internal() {
00115     return _slot;
00116   }
00117 
00118  private:
00119   const VariantSlot *_slot;
00120 };
00121 }  // namespace ARDUINOJSON_NAMESPACE