feedc0de/ArduinoJson
1
0
Fork 0
forked from bblanchon/ArduinoJson
Code Pull Requests Activity

Change naming convention from _member to member_ (fixes #1905)

Browse Source 
Ported from 31ce648e63
This commit is contained in:
Benoit Blanchon
2023-04-21 18:53:16 +02:00
parent 5d796781fb
commit dd46813dc0
60 changed files with 789 additions and 786 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
extras/tests/Helpers/Allocators.hpp
View File

@ -62,12 +62,12 @@ class AllocatorLog {
};
AllocatorLog& operator<<(const std::string& s) {
_log << s << "\n";
log_ << s << "\n";
return *this;
}
std::string str() const {
auto s = _log.str();
auto s = log_.str();
if (s.empty())
return "(empty)";
s.pop_back(); // remove the trailing '\n'
@ -84,57 +84,57 @@ class AllocatorLog {
}
private:
std::ostringstream _log;
std::ostringstream log_;
};
class SpyingAllocator : public ArduinoJson::Allocator {
public:
SpyingAllocator(
Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
: _upstream(upstream) {}
: upstream_(upstream) {}
virtual ~SpyingAllocator() {}
void* allocate(size_t n) override {
auto block = reinterpret_cast<AllocatedBlock*>(
_upstream->allocate(sizeof(AllocatedBlock) + n - 1));
upstream_->allocate(sizeof(AllocatedBlock) + n - 1));
if (block) {
_log << AllocatorLog::Allocate(n);
log_ << AllocatorLog::Allocate(n);
block->size = n;
return block->payload;
} else {
_log << AllocatorLog::AllocateFail(n);
log_ << AllocatorLog::AllocateFail(n);
return nullptr;
}
}
void deallocate(void* p) override {
auto block = AllocatedBlock::fromPayload(p);
_log << AllocatorLog::Deallocate(block->size);
_upstream->deallocate(block);
log_ << AllocatorLog::Deallocate(block->size);
upstream_->deallocate(block);
}
void* reallocate(void* p, size_t n) override {
auto block = AllocatedBlock::fromPayload(p);
auto oldSize = block->size;
block = reinterpret_cast<AllocatedBlock*>(
_upstream->reallocate(block, sizeof(AllocatedBlock) + n - 1));
upstream_->reallocate(block, sizeof(AllocatedBlock) + n - 1));
if (block) {
_log << AllocatorLog::Reallocate(oldSize, n);
log_ << AllocatorLog::Reallocate(oldSize, n);
ARDUINOJSON_ASSERT(block->size == oldSize);
block->size = n;
return block->payload;
} else {
_log << AllocatorLog::ReallocateFail(oldSize, n);
log_ << AllocatorLog::ReallocateFail(oldSize, n);
return nullptr;
}
}
void clearLog() {
_log = AllocatorLog();
log_ = AllocatorLog();
}
const AllocatorLog& log() const {
return _log;
return log_;
}
private:
@ -151,36 +151,36 @@ class SpyingAllocator : public ArduinoJson::Allocator {
}
};
AllocatorLog _log;
Allocator* _upstream;
AllocatorLog log_;
Allocator* upstream_;
};
class ControllableAllocator : public ArduinoJson::Allocator {
public:
ControllableAllocator(
Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
: _enabled(true), _upstream(upstream) {}
: enabled_(true), upstream_(upstream) {}
virtual ~ControllableAllocator() {}
void* allocate(size_t n) override {
return _enabled ? _upstream->allocate(n) : 0;
return enabled_ ? upstream_->allocate(n) : 0;
}
void deallocate(void* p) override {
_upstream->deallocate(p);
upstream_->deallocate(p);
}
void* reallocate(void* ptr, size_t n) override {
return _enabled ? _upstream->reallocate(ptr, n) : 0;
return enabled_ ? upstream_->reallocate(ptr, n) : 0;
}
void disable() {
_enabled = false;
enabled_ = false;
}
private:
bool _enabled;
Allocator* _upstream;
bool enabled_;
Allocator* upstream_;
};
class TimebombAllocator : public ArduinoJson::Allocator {
@ -188,32 +188,32 @@ class TimebombAllocator : public ArduinoJson::Allocator {
TimebombAllocator(
size_t initialCountdown,
Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
: _countdown(initialCountdown), _upstream(upstream) {}
: countdown_(initialCountdown), upstream_(upstream) {}
virtual ~TimebombAllocator() {}
void* allocate(size_t n) override {
if (!_countdown)
if (!countdown_)
return nullptr;
_countdown--;
return _upstream->allocate(n);
countdown_--;
return upstream_->allocate(n);
}
void deallocate(void* p) override {
_upstream->deallocate(p);
upstream_->deallocate(p);
}
void* reallocate(void* ptr, size_t n) override {
if (!_countdown)
if (!countdown_)
return nullptr;
_countdown--;
return _upstream->reallocate(ptr, n);
countdown_--;
return upstream_->reallocate(ptr, n);
}
void setCountdown(size_t value) {
_countdown = value;
countdown_ = value;
}
private:
size_t _countdown = 0;
Allocator* _upstream;
size_t countdown_ = 0;
Allocator* upstream_;
};

10
extras/tests/Helpers/CustomReader.hpp
View File

@ -7,18 +7,18 @@
#include <sstream>
class CustomReader {
std::stringstream _stream;
std::stringstream stream_;
public:
CustomReader(const char* input) : _stream(input) {}
CustomReader(const char* input) : stream_(input) {}
CustomReader(const CustomReader&) = delete;
int read() {
return _stream.get();
return stream_.get();
}
size_t readBytes(char* buffer, size_t length) {
_stream.read(buffer, static_cast<std::streamsize>(length));
return static_cast<size_t>(_stream.gcount());
stream_.read(buffer, static_cast<std::streamsize>(length));
return static_cast<size_t>(stream_.gcount());
}
};

28
extras/tests/Helpers/api/String.h
View File

@ -9,11 +9,11 @@
// Reproduces Arduino's String class
class String {
public:
String() : _maxCapacity(1024) {}
explicit String(const char* s) : _str(s), _maxCapacity(1024) {}
String() : maxCapacity_(1024) {}
explicit String(const char* s) : str_(s), maxCapacity_(1024) {}
void limitCapacityTo(size_t maxCapacity) {
_maxCapacity = maxCapacity;
maxCapacity_ = maxCapacity;
}
unsigned char concat(const char* s) {
@ -21,45 +21,45 @@ class String {
}
size_t length() const {
return _str.size();
return str_.size();
}
const char* c_str() const {
return _str.c_str();
return str_.c_str();
}
bool operator==(const char* s) const {
return _str == s;
return str_ == s;
}
String& operator=(const char* s) {
_str.assign(s);
str_.assign(s);
return *this;
}
char operator[](unsigned int index) const {
if (index >= _str.size())
if (index >= str_.size())
return 0;
return _str[index];
return str_[index];
}
friend std::ostream& operator<<(std::ostream& lhs, const ::String& rhs) {
lhs << rhs._str;
lhs << rhs.str_;
return lhs;
}
protected:
// This function is protected in most Arduino cores
unsigned char concat(const char* s, size_t n) {
if (_str.size() + n > _maxCapacity)
if (str_.size() + n > maxCapacity_)
return 0;
_str.append(s, n);
str_.append(s, n);
return 1;
}
private:
std::string _str;
size_t _maxCapacity;
std::string str_;
size_t maxCapacity_;
};
class StringSumHelper : public ::String {};

8
extras/tests/JsonSerializer/CustomWriter.cpp
View File

@ -12,21 +12,21 @@ class CustomWriter {
CustomWriter& operator=(const CustomWriter&) = delete;
size_t write(uint8_t c) {
_str.append(1, static_cast<char>(c));
str_.append(1, static_cast<char>(c));
return 1;
}
size_t write(const uint8_t* s, size_t n) {
_str.append(reinterpret_cast<const char*>(s), n);
str_.append(reinterpret_cast<const char*>(s), n);
return n;
}
const std::string& str() const {
return _str;
return str_;
}
private:
std::string _str;
std::string str_;
};
TEST_CASE("CustomWriter") {

8
extras/tests/JsonVariant/converters.cpp
View File

@ -74,18 +74,18 @@ TEST_CASE("Custom converter with overloading") {
class Complex {
public:
explicit Complex(double r, double i) : _real(r), _imag(i) {}
explicit Complex(double r, double i) : real_(r), imag_(i) {}
double real() const {
return _real;
return real_;
}
double imag() const {
return _imag;
return imag_;
}
private:
double _real, _imag;
double real_, imag_;
};
namespace ArduinoJson {

10
extras/tests/Misc/Readers.cpp
View File

@ -170,19 +170,19 @@ TEST_CASE("IteratorReader") {
class StreamStub : public Stream {
public:
StreamStub(const char* s) : _stream(s) {}
StreamStub(const char* s) : stream_(s) {}
int read() {
return _stream.get();
return stream_.get();
}
size_t readBytes(char* buffer, size_t length) {
_stream.read(buffer, static_cast<std::streamsize>(length));
return static_cast<size_t>(_stream.gcount());
stream_.read(buffer, static_cast<std::streamsize>(length));
return static_cast<size_t>(stream_.gcount());
}
private:
std::istringstream _stream;
std::istringstream stream_;
};
TEST_CASE("Reader<Stream>") {

3
extras/tests/Misc/conflicts.cpp
View File

@ -52,5 +52,8 @@
#define BLOCKSIZE
#define CAPACITY
// issue #1905
#define _current
// catch.hpp mutes several warnings, this file also allows to detect them
#include "ArduinoJson.h"

12
extras/tests/Misc/printable.cpp
View File

@ -34,21 +34,21 @@ struct PrintAllAtOnce {
template <typename PrintPolicy>
struct PrintableString : public Printable {
PrintableString(const char* s) : _str(s), _total(0) {}
PrintableString(const char* s) : str_(s), total_(0) {}
virtual size_t printTo(Print& p) const {
size_t result = PrintPolicy::printStringTo(_str, p);
_total += result;
size_t result = PrintPolicy::printStringTo(str_, p);
total_ += result;
return result;
}
size_t totalBytesWritten() const {
return _total;
return total_;
}
private:
std::string _str;
mutable size_t _total;
std::string str_;
mutable size_t total_;
};
TEST_CASE("Printable") {

16
src/ArduinoJson/Array/ElementProxy.hpp
View File

@ -17,10 +17,10 @@ class ElementProxy : public VariantRefBase<ElementProxy<TUpstream>>,
public:
ElementProxy(TUpstream upstream, size_t index)
: _upstream(upstream), _index(index) {}
: upstream_(upstream), index_(index) {}
ElementProxy(const ElementProxy& src)
: _upstream(src._upstream), _index(src._index) {}
: upstream_(src.upstream_), index_(src.index_) {}
FORCE_INLINE ElementProxy& operator=(const ElementProxy& src) {
this->set(src);
@ -41,20 +41,20 @@ class ElementProxy : public VariantRefBase<ElementProxy<TUpstream>>,
private:
FORCE_INLINE MemoryPool* getPool() const {
return VariantAttorney::getPool(_upstream);
return VariantAttorney::getPool(upstream_);
}
FORCE_INLINE VariantData* getData() const {
return variantGetElement(VariantAttorney::getData(_upstream), _index);
return variantGetElement(VariantAttorney::getData(upstream_), index_);
}
FORCE_INLINE VariantData* getOrCreateData() const {
return variantGetOrAddElement(VariantAttorney::getOrCreateData(_upstream),
_index, VariantAttorney::getPool(_upstream));
return variantGetOrAddElement(VariantAttorney::getOrCreateData(upstream_),
index_, VariantAttorney::getPool(upstream_));
}
TUpstream _upstream;
size_t _index;
TUpstream upstream_;
size_t index_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

48
src/ArduinoJson/Array/JsonArray.hpp
View File

@ -21,30 +21,30 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
typedef JsonArrayIterator iterator;
// Constructs an unbound reference.
FORCE_INLINE JsonArray() : _data(0), _pool(0) {}
FORCE_INLINE JsonArray() : data_(0), pool_(0) {}
// INTERNAL USE ONLY
FORCE_INLINE JsonArray(detail::MemoryPool* pool, detail::CollectionData* data)
: _data(data), _pool(pool) {}
: data_(data), pool_(pool) {}
// Returns a JsonVariant pointing to the array.
// https://arduinojson.org/v6/api/jsonvariant/
operator JsonVariant() {
void* data = _data; // prevent warning cast-align
return JsonVariant(_pool, reinterpret_cast<detail::VariantData*>(data));
void* data = data_; // prevent warning cast-align
return JsonVariant(pool_, reinterpret_cast<detail::VariantData*>(data));
}
// Returns a read-only reference to the array.
// https://arduinojson.org/v6/api/jsonarrayconst/
operator JsonArrayConst() const {
return JsonArrayConst(_data);
return JsonArrayConst(data_);
}
// Appends a new (null) element to the array.
// Returns a reference to the new element.
// https://arduinojson.org/v6/api/jsonarray/add/
JsonVariant add() const {
return JsonVariant(_pool, collectionAddElement(_data, _pool));
return JsonVariant(pool_, collectionAddElement(data_, pool_));
}
// Appends a value to the array.
@ -64,9 +64,9 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
// Returns an iterator to the first element of the array.
// https://arduinojson.org/v6/api/jsonarray/begin/
FORCE_INLINE iterator begin() const {
if (!_data)
if (!data_)
return iterator();
return iterator(_pool, _data->head());
return iterator(pool_, data_->head());
}
// Returns an iterator following the last element of the array.
@ -78,33 +78,33 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
// Copies an array.
// https://arduinojson.org/v6/api/jsonarray/set/
FORCE_INLINE bool set(JsonArrayConst src) const {
return collectionCopy(_data, src._data, _pool);
return collectionCopy(data_, src.data_, pool_);
}
// Compares the content of two arrays.
FORCE_INLINE bool operator==(JsonArray rhs) const {
return JsonArrayConst(_data) == JsonArrayConst(rhs._data);
return JsonArrayConst(data_) == JsonArrayConst(rhs.data_);
}
// Removes the element at the specified iterator.
// ⚠️ Doesn't release the memory associated with the removed element.
// https://arduinojson.org/v6/api/jsonarray/remove/
FORCE_INLINE void remove(iterator it) const {
collectionRemove(_data, it._slot, _pool);
collectionRemove(data_, it.slot_, pool_);
}
// Removes the element at the specified index.
// ⚠️ Doesn't release the memory associated with the removed element.
// https://arduinojson.org/v6/api/jsonarray/remove/
FORCE_INLINE void remove(size_t index) const {
collectionRemoveElement(_data, index, _pool);
collectionRemoveElement(data_, index, pool_);
}
// Removes all the elements of the array.
// ⚠️ Doesn't release the memory associated with the removed elements.
// https://arduinojson.org/v6/api/jsonarray/clear/
void clear() const {
collectionClear(_data, _pool);
collectionClear(data_, pool_);
}
// Gets or sets the element at the specified index.
@ -124,54 +124,54 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
}
operator JsonVariantConst() const {
return JsonVariantConst(collectionToVariant(_data));
return JsonVariantConst(collectionToVariant(data_));
}
// Returns true if the reference is unbound.
// https://arduinojson.org/v6/api/jsonarray/isnull/
FORCE_INLINE bool isNull() const {
return _data == 0;
return data_ == 0;
}
// Returns true if the reference is bound.
// https://arduinojson.org/v6/api/jsonarray/isnull/
FORCE_INLINE operator bool() const {
return _data != 0;
return data_ != 0;
}
// Returns the number of bytes occupied by the array.
// https://arduinojson.org/v6/api/jsonarray/memoryusage/
FORCE_INLINE size_t memoryUsage() const {
return _data ? _data->memoryUsage() : 0;
return data_ ? data_->memoryUsage() : 0;
}
// Returns the depth (nesting level) of the array.
// https://arduinojson.org/v6/api/jsonarray/nesting/
FORCE_INLINE size_t nesting() const {
return variantNesting(collectionToVariant(_data));
return variantNesting(collectionToVariant(data_));
}
// Returns the number of elements in the array.
// https://arduinojson.org/v6/api/jsonarray/size/
FORCE_INLINE size_t size() const {
return _data ? _data->size() : 0;
return data_ ? data_->size() : 0;
}
private:
detail::MemoryPool* getPool() const {
return _pool;
return pool_;
}
detail::VariantData* getData() const {
return collectionToVariant(_data);
return collectionToVariant(data_);
}
detail::VariantData* getOrCreateData() const {
return collectionToVariant(_data);
return collectionToVariant(data_);
}
detail::CollectionData* _data;
detail::MemoryPool* _pool;
detail::CollectionData* data_;
detail::MemoryPool* pool_;
};
template <>

30
src/ArduinoJson/Array/JsonArrayConst.hpp
View File

@ -24,9 +24,9 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
// Returns an iterator to the first element of the array.
// https://arduinojson.org/v6/api/jsonarrayconst/begin/
FORCE_INLINE iterator begin() const {
if (!_data)
if (!data_)
return iterator();
return iterator(_data->head());
return iterator(data_->head());
}
// Returns an iterator to the element following the last element of the array.
@ -36,18 +36,18 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
}
// Creates an unbound reference.
FORCE_INLINE JsonArrayConst() : _data(0) {}
FORCE_INLINE JsonArrayConst() : data_(0) {}
// INTERNAL USE ONLY
FORCE_INLINE JsonArrayConst(const detail::CollectionData* data)
: _data(data) {}
: data_(data) {}
// Compares the content of two arrays.
// Returns true if the two arrays are equal.
FORCE_INLINE bool operator==(JsonArrayConst rhs) const {
if (_data == rhs._data)
if (data_ == rhs.data_)
return true;
if (!_data || !rhs._data)
if (!data_ || !rhs.data_)
return false;
iterator it1 = begin();
@ -70,49 +70,49 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
// Returns the element at the specified index.
// https://arduinojson.org/v6/api/jsonarrayconst/subscript/
FORCE_INLINE JsonVariantConst operator[](size_t index) const {
return JsonVariantConst(_data ? slotData(_data->get(index)) : 0);
return JsonVariantConst(data_ ? slotData(data_->get(index)) : 0);
}
operator JsonVariantConst() const {
return JsonVariantConst(collectionToVariant(_data));
return JsonVariantConst(collectionToVariant(data_));
}
// Returns true if the reference is unbound.
// https://arduinojson.org/v6/api/jsonarrayconst/isnull/
FORCE_INLINE bool isNull() const {
return _data == 0;
return data_ == 0;
}
// Returns true if the reference is bound.
// https://arduinojson.org/v6/api/jsonarrayconst/isnull/
FORCE_INLINE operator bool() const {
return _data != 0;
return data_ != 0;
}
// Returns the number of bytes occupied by the array.
// https://arduinojson.org/v6/api/jsonarrayconst/memoryusage/
FORCE_INLINE size_t memoryUsage() const {
return _data ? _data->memoryUsage() : 0;
return data_ ? data_->memoryUsage() : 0;
}
// Returns the depth (nesting level) of the array.
// https://arduinojson.org/v6/api/jsonarrayconst/nesting/
FORCE_INLINE size_t nesting() const {
return variantNesting(collectionToVariant(_data));
return variantNesting(collectionToVariant(data_));
}
// Returns the number of elements in the array.
// https://arduinojson.org/v6/api/jsonarrayconst/size/
FORCE_INLINE size_t size() const {
return _data ? _data->size() : 0;
return data_ ? data_->size() : 0;
}
private:
const detail::VariantData* getData() const {
return collectionToVariant(_data);
return collectionToVariant(data_);
}
const detail::CollectionData* _data;
const detail::CollectionData* data_;
};
template <>

54
src/ArduinoJson/Array/JsonArrayIterator.hpp
View File

@ -12,110 +12,110 @@ ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
class VariantPtr {
public:
VariantPtr(detail::MemoryPool* pool, detail::VariantData* data)
: _variant(pool, data) {}
: variant_(pool, data) {}
JsonVariant* operator->() {
return &_variant;
return &variant_;
}
JsonVariant& operator*() {
return _variant;
return variant_;
}
private:
JsonVariant _variant;
JsonVariant variant_;
};
class JsonArrayIterator {
friend class JsonArray;
public:
JsonArrayIterator() : _slot(0) {}
JsonArrayIterator() : slot_(0) {}
explicit JsonArrayIterator(detail::MemoryPool* pool,
detail::VariantSlot* slot)
: _pool(pool), _slot(slot) {}
: pool_(pool), slot_(slot) {}
JsonVariant operator*() const {
return JsonVariant(_pool, _slot->data());
return JsonVariant(pool_, slot_->data());
}
VariantPtr operator->() {
return VariantPtr(_pool, _slot->data());
return VariantPtr(pool_, slot_->data());
}
bool operator==(const JsonArrayIterator& other) const {
return _slot == other._slot;
return slot_ == other.slot_;
}
bool operator!=(const JsonArrayIterator& other) const {
return _slot != other._slot;
return slot_ != other.slot_;
}
JsonArrayIterator& operator++() {
_slot = _slot->next();
slot_ = slot_->next();
return *this;
}
JsonArrayIterator& operator+=(size_t distance) {
_slot = _slot->next(distance);
slot_ = slot_->next(distance);
return *this;
}
private:
detail::MemoryPool* _pool;
detail::VariantSlot* _slot;
detail::MemoryPool* pool_;
detail::VariantSlot* slot_;
};
class VariantConstPtr {
public:
VariantConstPtr(const detail::VariantData* data) : _variant(data) {}
VariantConstPtr(const detail::VariantData* data) : variant_(data) {}
JsonVariantConst* operator->() {
return &_variant;
return &variant_;
}
JsonVariantConst& operator*() {
return _variant;
return variant_;
}
private:
JsonVariantConst _variant;
JsonVariantConst variant_;
};
class JsonArrayConstIterator {
friend class JsonArray;
public:
JsonArrayConstIterator() : _slot(0) {}
JsonArrayConstIterator() : slot_(0) {}
explicit JsonArrayConstIterator(const detail::VariantSlot* slot)
: _slot(slot) {}
: slot_(slot) {}
JsonVariantConst operator*() const {
return JsonVariantConst(_slot->data());
return JsonVariantConst(slot_->data());
}
VariantConstPtr operator->() {
return VariantConstPtr(_slot->data());
return VariantConstPtr(slot_->data());
}
bool operator==(const JsonArrayConstIterator& other) const {
return _slot == other._slot;
return slot_ == other.slot_;
}
bool operator!=(const JsonArrayConstIterator& other) const {
return _slot != other._slot;
return slot_ != other.slot_;
}
JsonArrayConstIterator& operator++() {
_slot = _slot->next();
slot_ = slot_->next();
return *this;
}
JsonArrayConstIterator& operator+=(size_t distance) {
_slot = _slot->next(distance);
slot_ = slot_->next(distance);
return *this;
}
private:
const detail::VariantSlot* _slot;
const detail::VariantSlot* slot_;
};
ARDUINOJSON_END_PUBLIC_NAMESPACE

6
src/ArduinoJson/Collection/CollectionData.hpp
View File

@ -15,8 +15,8 @@ class VariantData;
class VariantSlot;
class CollectionData {
VariantSlot* _head;
VariantSlot* _tail;
VariantSlot* head_;
VariantSlot* tail_;
public:
void clear();
@ -27,7 +27,7 @@ class CollectionData {
void remove(VariantSlot* slot);
VariantSlot* head() const {
return _head;
return head_;
}
void movePointers(ptrdiff_t variantDistance);

36
src/ArduinoJson/Collection/CollectionImpl.hpp
View File

@ -14,25 +14,25 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
inline void CollectionData::add(VariantSlot* slot) {
ARDUINOJSON_ASSERT(slot != nullptr);
if (_tail) {
_tail->setNextNotNull(slot);
_tail = slot;
if (tail_) {
tail_->setNextNotNull(slot);
tail_ = slot;
} else {
_head = slot;
_tail = slot;
head_ = slot;
tail_ = slot;
}
}
inline void CollectionData::clear() {
_head = 0;
_tail = 0;
head_ = 0;
tail_ = 0;
}
template <typename TAdaptedString>
inline VariantSlot* CollectionData::get(TAdaptedString key) const {
if (key.isNull())
return 0;
VariantSlot* slot = _head;
VariantSlot* slot = head_;
while (slot) {
if (stringEquals(key, adaptString(slot->key())))
break;
@ -42,13 +42,13 @@ inline VariantSlot* CollectionData::get(TAdaptedString key) const {
}
inline VariantSlot* CollectionData::get(size_t index) const {
if (!_head)
if (!head_)
return 0;
return _head->next(index);
return head_->next(index);
}
inline VariantSlot* CollectionData::getPrevious(VariantSlot* target) const {
VariantSlot* current = _head;
VariantSlot* current = head_;
while (current) {
VariantSlot* next = current->next();
if (next == target)
@ -65,14 +65,14 @@ inline void CollectionData::remove(VariantSlot* slot) {
if (prev)
prev->setNext(next);
else
_head = next;
head_ = next;
if (!next)
_tail = prev;
tail_ = prev;
}
inline size_t CollectionData::memoryUsage() const {
size_t total = 0;
for (VariantSlot* s = _head; s; s = s->next()) {
for (VariantSlot* s = head_; s; s = s->next()) {
total += sizeof(VariantSlot) + s->data()->memoryUsage();
if (s->ownsKey())
total += sizeofString(strlen(s->key()));
@ -81,7 +81,7 @@ inline size_t CollectionData::memoryUsage() const {
}
inline size_t CollectionData::size() const {
return slotSize(_head);
return slotSize(head_);
}
template <typename T>
@ -94,9 +94,9 @@ inline void movePointer(T*& p, ptrdiff_t offset) {
}
inline void CollectionData::movePointers(ptrdiff_t variantDistance) {
movePointer(_head, variantDistance);
movePointer(_tail, variantDistance);
for (VariantSlot* slot = _head; slot; slot = slot->next())
movePointer(head_, variantDistance);
movePointer(tail_, variantDistance);
for (VariantSlot* slot = head_; slot; slot = slot->next())
slot->movePointers(variantDistance);
}

26
src/ArduinoJson/Deserialization/DeserializationError.hpp
View File

@ -26,49 +26,49 @@ class DeserializationError {
};
DeserializationError() {}
DeserializationError(Code c) : _code(c) {}
DeserializationError(Code c) : code_(c) {}
// Compare with DeserializationError
friend bool operator==(const DeserializationError& lhs,
const DeserializationError& rhs) {
return lhs._code == rhs._code;
return lhs.code_ == rhs.code_;
}
friend bool operator!=(const DeserializationError& lhs,
const DeserializationError& rhs) {
return lhs._code != rhs._code;
return lhs.code_ != rhs.code_;
}
// Compare with Code
friend bool operator==(const DeserializationError& lhs, Code rhs) {
return lhs._code == rhs;
return lhs.code_ == rhs;
}
friend bool operator==(Code lhs, const DeserializationError& rhs) {
return lhs == rhs._code;
return lhs == rhs.code_;
}
friend bool operator!=(const DeserializationError& lhs, Code rhs) {
return lhs._code != rhs;
return lhs.code_ != rhs;
}
friend bool operator!=(Code lhs, const DeserializationError& rhs) {
return lhs != rhs._code;
return lhs != rhs.code_;
}
// Returns true if there is an error
explicit operator bool() const {
return _code != Ok;
return code_ != Ok;
}
// Returns internal enum, useful for switch statement
Code code() const {
return _code;
return code_;
}
const char* c_str() const {
static const char* messages[] = {
"Ok", "EmptyInput", "IncompleteInput",
"InvalidInput", "NoMemory", "TooDeep"};
ARDUINOJSON_ASSERT(static_cast<size_t>(_code) <
ARDUINOJSON_ASSERT(static_cast<size_t>(code_) <
sizeof(messages) / sizeof(messages[0]));
return messages[_code];
return messages[code_];
}
#if ARDUINOJSON_ENABLE_PROGMEM
@ -82,12 +82,12 @@ class DeserializationError {
ARDUINOJSON_DEFINE_PROGMEM_ARRAY(const char*, messages,
{s0, s1, s2, s3, s4, s5});
return reinterpret_cast<const __FlashStringHelper*>(
detail::pgm_read(messages + _code));
detail::pgm_read(messages + code_));
}
#endif
private:
Code _code;
Code code_;
};
#if ARDUINOJSON_ENABLE_STD_STREAM

18
src/ArduinoJson/Deserialization/Filter.hpp
View File

@ -11,34 +11,34 @@ ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
namespace DeserializationOption {
class Filter {
public:
explicit Filter(JsonVariantConst v) : _variant(v) {}
explicit Filter(JsonVariantConst v) : variant_(v) {}
bool allow() const {
return _variant;
return variant_;
}
bool allowArray() const {
return _variant == true || _variant.is<JsonArrayConst>();
return variant_ == true || variant_.is<JsonArrayConst>();
}
bool allowObject() const {
return _variant == true || _variant.is<JsonObjectConst>();
return variant_ == true || variant_.is<JsonObjectConst>();
}
bool allowValue() const {
return _variant == true;
return variant_ == true;
}
template <typename TKey>
Filter operator[](const TKey& key) const {
if (_variant == true) // "true" means "allow recursively"
if (variant_ == true) // "true" means "allow recursively"
return *this;
JsonVariantConst member = _variant[key];
return Filter(member.isNull() ? _variant["*"] : member);
JsonVariantConst member = variant_[key];
return Filter(member.isNull() ? variant_["*"] : member);
}
private:
JsonVariantConst _variant;
JsonVariantConst variant_;
};
} // namespace DeserializationOption

12
src/ArduinoJson/Deserialization/NestingLimit.hpp
View File

@ -12,20 +12,20 @@ ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
namespace DeserializationOption {
class NestingLimit {
public:
NestingLimit() : _value(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
explicit NestingLimit(uint8_t n) : _value(n) {}
NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
explicit NestingLimit(uint8_t n) : value_(n) {}
NestingLimit decrement() const {
ARDUINOJSON_ASSERT(_value > 0);
return NestingLimit(static_cast<uint8_t>(_value - 1));
ARDUINOJSON_ASSERT(value_ > 0);
return NestingLimit(static_cast<uint8_t>(value_ - 1));
}
bool reached() const {
return _value == 0;
return value_ == 0;
}
private:
uint8_t _value;
uint8_t value_;
};
} // namespace DeserializationOption

8
src/ArduinoJson/Deserialization/Reader.hpp
View File

@ -15,18 +15,18 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
template <typename TSource, typename Enable = void>
struct Reader {
public:
Reader(TSource& source) : _source(&source) {}
Reader(TSource& source) : source_(&source) {}
int read() {
return _source->read(); // Error here? You passed an unsupported input type
return source_->read(); // Error here? You passed an unsupported input type
}
size_t readBytes(char* buffer, size_t length) {
return _source->readBytes(buffer, length);
return source_->readBytes(buffer, length);
}
private:
TSource* _source;
TSource* source_;
};
template <typename TSource, typename Enable = void>

10
src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp
View File

@ -12,20 +12,20 @@ template <typename TSource>
struct Reader<TSource,
typename enable_if<is_base_of<Stream, TSource>::value>::type> {
public:
explicit Reader(Stream& stream) : _stream(&stream) {}
explicit Reader(Stream& stream) : stream_(&stream) {}
int read() {
// don't use _stream.read() as it ignores the timeout
// don't use stream_->read() as it ignores the timeout
char c;
return _stream->readBytes(&c, 1) ? static_cast<unsigned char>(c) : -1;
return stream_->readBytes(&c, 1) ? static_cast<unsigned char>(c) : -1;
}
size_t readBytes(char* buffer, size_t length) {
return _stream->readBytes(buffer, length);
return stream_->readBytes(buffer, length);
}
private:
Stream* _stream;
Stream* stream_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

26
src/ArduinoJson/Deserialization/Readers/FlashReader.hpp
View File

@ -10,45 +10,45 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
template <>
struct Reader<const __FlashStringHelper*, void> {
const char* _ptr;
const char* ptr_;
public:
explicit Reader(const __FlashStringHelper* ptr)
: _ptr(reinterpret_cast<const char*>(ptr)) {}
: ptr_(reinterpret_cast<const char*>(ptr)) {}
int read() {
return pgm_read_byte(_ptr++);
return pgm_read_byte(ptr_++);
}
size_t readBytes(char* buffer, size_t length) {
memcpy_P(buffer, _ptr, length);
_ptr += length;
memcpy_P(buffer, ptr_, length);
ptr_ += length;
return length;
}
};
template <>
struct BoundedReader<const __FlashStringHelper*, void> {
const char* _ptr;
const char* _end;
const char* ptr_;
const char* end_;
public:
explicit BoundedReader(const __FlashStringHelper* ptr, size_t size)
: _ptr(reinterpret_cast<const char*>(ptr)), _end(_ptr + size) {}
: ptr_(reinterpret_cast<const char*>(ptr)), end_(ptr_ + size) {}
int read() {
if (_ptr < _end)
return pgm_read_byte(_ptr++);
if (ptr_ < end_)
return pgm_read_byte(ptr_++);
else
return -1;
}
size_t readBytes(char* buffer, size_t length) {
size_t available = static_cast<size_t>(_end - _ptr);
size_t available = static_cast<size_t>(end_ - ptr_);
if (available < length)
length = available;
memcpy_P(buffer, _ptr, length);
_ptr += length;
memcpy_P(buffer, ptr_, length);
ptr_ += length;
return length;
}
};

12
src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp
View File

@ -8,23 +8,23 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
template <typename TIterator>
class IteratorReader {
TIterator _ptr, _end;
TIterator ptr_, end_;
public:
explicit IteratorReader(TIterator begin, TIterator end)
: _ptr(begin), _end(end) {}
: ptr_(begin), end_(end) {}
int read() {
if (_ptr < _end)
return static_cast<unsigned char>(*_ptr++);
if (ptr_ < end_)
return static_cast<unsigned char>(*ptr_++);
else
return -1;
}
size_t readBytes(char* buffer, size_t length) {
size_t i = 0;
while (i < length && _ptr < _end)
buffer[i++] = *_ptr++;
while (i < length && ptr_ < end_)
buffer[i++] = *ptr_++;
return i;
}
};

8
src/ArduinoJson/Deserialization/Readers/RamReader.hpp
View File

@ -21,19 +21,19 @@ struct IsCharOrVoid<const T> : IsCharOrVoid<T> {};
template <typename TSource>
struct Reader<TSource*,
typename enable_if<IsCharOrVoid<TSource>::value>::type> {
const char* _ptr;
const char* ptr_;
public:
explicit Reader(const void* ptr)
: _ptr(ptr ? reinterpret_cast<const char*>(ptr) : "") {}
: ptr_(ptr ? reinterpret_cast<const char*>(ptr) : "") {}
int read() {
return static_cast<unsigned char>(*_ptr++);
return static_cast<unsigned char>(*ptr_++);
}
size_t readBytes(char* buffer, size_t length) {
for (size_t i = 0; i < length; i++)
buffer[i] = *_ptr++;
buffer[i] = *ptr_++;
return length;
}
};

10
src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp
View File

@ -12,19 +12,19 @@ template <typename TSource>
struct Reader<TSource, typename enable_if<
is_base_of<std::istream, TSource>::value>::type> {
public:
explicit Reader(std::istream& stream) : _stream(&stream) {}
explicit Reader(std::istream& stream) : stream_(&stream) {}
int read() {
return _stream->get();
return stream_->get();
}
size_t readBytes(char* buffer, size_t length) {
_stream->read(buffer, static_cast<std::streamsize>(length));
return static_cast<size_t>(_stream->gcount());
stream_->read(buffer, static_cast<std::streamsize>(length));
return static_cast<size_t>(stream_->gcount());
}
private:
std::istream* _stream;
std::istream* stream_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

64
src/ArduinoJson/Document/JsonDocument.hpp
View File

@ -24,16 +24,16 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
public:
explicit JsonDocument(size_t capa,
Allocator* alloc = detail::DefaultAllocator::instance())
: _pool(capa, alloc) {}
: pool_(capa, alloc) {}
// Copy-constructor
JsonDocument(const JsonDocument& src)
: JsonDocument(src._pool.capacity(), src.allocator()) {
: JsonDocument(src.pool_.capacity(), src.allocator()) {
set(src);
}
// Move-constructor
JsonDocument(JsonDocument&& src) : _pool(0, src.allocator()) {
JsonDocument(JsonDocument&& src) : pool_(0, src.allocator()) {
// TODO: use the copy and swap idiom
moveAssignFrom(src);
}
@ -74,20 +74,20 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
template <typename T>
JsonDocument& operator=(const T& src) {
size_t requiredSize = src.memoryUsage();
if (requiredSize > _pool.capacity())
_pool.reallocPool(requiredSize);
if (requiredSize > pool_.capacity())
pool_.reallocPool(requiredSize);
set(src);
return *this;
}
Allocator* allocator() const {
return _pool.allocator();
return pool_.allocator();
}
// Reduces the capacity of the memory pool to match the current usage.
// https://arduinojson.org/v6/api/JsonDocument/shrinktofit/
void shrinkToFit() {
_pool.shrinkToFit(_data);
pool_.shrinkToFit(data_);
}
// Reclaims the memory leaked when removing and replacing values.
@ -95,7 +95,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
bool garbageCollect() {
// make a temporary clone and move assign
JsonDocument tmp(*this);
if (!tmp._pool.capacity())
if (!tmp.pool_.capacity())
return false;
moveAssignFrom(tmp);
return true;
@ -118,8 +118,8 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
// Empties the document and resets the memory pool
// https://arduinojson.org/v6/api/jsondocument/clear/
void clear() {
_pool.clear();
_data.reset();
pool_.clear();
data_.reset();
}
// Returns true if the root is of the specified type.
@ -145,25 +145,25 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
// Returns the number of used bytes in the memory pool.
// https://arduinojson.org/v6/api/jsondocument/memoryusage/
size_t memoryUsage() const {
return _pool.size();
return pool_.size();
}
// Returns trues if the memory pool was too small.
// https://arduinojson.org/v6/api/jsondocument/overflowed/
bool overflowed() const {
return _pool.overflowed();
return pool_.overflowed();
}
// Returns the depth (nesting level) of the array.
// https://arduinojson.org/v6/api/jsondocument/nesting/
size_t nesting() const {
return variantNesting(&_data);
return variantNesting(&data_);
}
// Returns the number of elements in the root array or object.
// https://arduinojson.org/v6/api/jsondocument/size/
size_t size() const {
return _data.size();
return data_.size();
}
// Copies the specified document.
@ -233,14 +233,14 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
// https://arduinojson.org/v6/api/jsondocument/containskey/
template <typename TChar>
bool containsKey(TChar* key) const {
return _data.getMember(detail::adaptString(key)) != 0;
return data_.getMember(detail::adaptString(key)) != 0;
}
// Returns true if the root object contains the specified key.
// https://arduinojson.org/v6/api/jsondocument/containskey/
template <typename TString>
bool containsKey(const TString& key) const {
return _data.getMember(detail::adaptString(key)) != 0;
return data_.getMember(detail::adaptString(key)) != 0;
}
// Gets or sets a root object's member.
@ -269,7 +269,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
FORCE_INLINE typename detail::enable_if<detail::IsString<TString>::value,
JsonVariantConst>::type
operator[](const TString& key) const {
return JsonVariantConst(_data.getMember(detail::adaptString(key)));
return JsonVariantConst(data_.getMember(detail::adaptString(key)));
}
// Gets a root object's member.
@ -278,7 +278,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
FORCE_INLINE typename detail::enable_if<detail::IsString<TChar*>::value,
JsonVariantConst>::type
operator[](TChar* key) const {
return JsonVariantConst(_data.getMember(detail::adaptString(key)));
return JsonVariantConst(data_.getMember(detail::adaptString(key)));
}
// Gets or sets a root array's element.
@ -290,14 +290,14 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
// Gets a root array's member.
// https://arduinojson.org/v6/api/jsondocument/subscript/
FORCE_INLINE JsonVariantConst operator[](size_t index) const {
return JsonVariantConst(_data.getElement(index));
return JsonVariantConst(data_.getElement(index));
}
// Appends a new (null) element to the root array.
// Returns a reference to the new element.
// https://arduinojson.org/v6/api/jsondocument/add/
FORCE_INLINE JsonVariant add() {
return JsonVariant(&_pool, variantAddElement(&_data, &_pool));
return JsonVariant(&pool_, variantAddElement(&data_, &pool_));
}
// Appends a value to the root array.
@ -350,42 +350,42 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
private:
JsonVariant getVariant() {
return JsonVariant(&_pool, &_data);
return JsonVariant(&pool_, &data_);
}
JsonVariantConst getVariant() const {
return JsonVariantConst(&_data);
return JsonVariantConst(&data_);
}
void copyAssignFrom(const JsonDocument& src) {
_pool.reallocPool(src._pool.capacity());
pool_.reallocPool(src.pool_.capacity());
set(src);
}
void moveAssignFrom(JsonDocument& src) {
_data = src._data;
src._data.reset();
_pool = move(src._pool);
data_ = src.data_;
src.data_.reset();
pool_ = move(src.pool_);
}
detail::MemoryPool* getPool() {
return &_pool;
return &pool_;
}
detail::VariantData* getData() {
return &_data;
return &data_;
}
const detail::VariantData* getData() const {
return &_data;
return &data_;
}
detail::VariantData* getOrCreateData() {
return &_data;
return &data_;
}
detail::MemoryPool _pool;
detail::VariantData _data;
detail::MemoryPool pool_;
detail::VariantData data_;
};
inline void convertToJson(const JsonDocument& src, JsonVariant dst) {

60
src/ArduinoJson/Json/JsonDeserializer.hpp
View File

@ -23,10 +23,10 @@ class JsonDeserializer {
public:
JsonDeserializer(MemoryPool* pool, TReader reader,
TStringStorage stringStorage)
: _stringStorage(stringStorage),
_foundSomething(false),
_latch(reader),
_pool(pool) {}
: stringStorage_(stringStorage),
foundSomething_(false),
latch_(reader),
pool_(pool) {}
template <typename TFilter>
DeserializationError parse(VariantData& variant, TFilter filter,
@ -35,7 +35,7 @@ class JsonDeserializer {
err = parseVariant(variant, filter, nestingLimit);
if (!err && _latch.last() != 0 && !variant.isEnclosed()) {
if (!err && latch_.last() != 0 && !variant.isEnclosed()) {
// We don't detect trailing characters earlier, so we need to check now
return DeserializationError::InvalidInput;
}
@ -45,11 +45,11 @@ class JsonDeserializer {
private:
char current() {
return _latch.current();
return latch_.current();
}
void move() {
_latch.clear();
latch_.clear();
}
bool eat(char charToSkip) {
@ -173,7 +173,7 @@ class JsonDeserializer {
for (;;) {
if (memberFilter.allow()) {
// Allocate slot in array
VariantData* value = collectionAddElement(&array, _pool);
VariantData* value = collectionAddElement(&array, pool_);
if (!value)
return DeserializationError::NoMemory;
@ -269,7 +269,7 @@ class JsonDeserializer {
if (!eat(':'))
return DeserializationError::InvalidInput;
JsonString key = _stringStorage.str();
JsonString key = stringStorage_.str();
TFilter memberFilter = filter[key.c_str()];
@ -277,10 +277,10 @@ class JsonDeserializer {
VariantSlot* slot = object.get(adaptString(key.c_str()));
if (!slot) {
// Save key in memory pool.
key = _stringStorage.save();
key = stringStorage_.save();
// Allocate slot in object
slot = _pool->allocVariant();
slot = pool_->allocVariant();
if (!slot)
return DeserializationError::NoMemory;
@ -376,7 +376,7 @@ class JsonDeserializer {
}
DeserializationError::Code parseKey() {
_stringStorage.startString();
stringStorage_.startString();
if (isQuote(current())) {
return parseQuotedString();
} else {
@ -387,13 +387,13 @@ class JsonDeserializer {
DeserializationError::Code parseStringValue(VariantData& variant) {
DeserializationError::Code err;
_stringStorage.startString();
stringStorage_.startString();
err = parseQuotedString();
if (err)
return err;
variant.setString(_stringStorage.save());
variant.setString(stringStorage_.save());
return DeserializationError::Ok;
}
@ -429,9 +429,9 @@ class JsonDeserializer {
if (err)
return err;
if (codepoint.append(codeunit))
Utf8::encodeCodepoint(codepoint.value(), _stringStorage);
Utf8::encodeCodepoint(codepoint.value(), stringStorage_);
#else
_stringStorage.append('\\');
stringStorage_.append('\\');
#endif
continue;
}
@ -443,10 +443,10 @@ class JsonDeserializer {
move();
}
_stringStorage.append(c);
stringStorage_.append(c);
}
if (!_stringStorage.isValid())
if (!stringStorage_.isValid())
return DeserializationError::NoMemory;
return DeserializationError::Ok;
@ -459,14 +459,14 @@ class JsonDeserializer {
if (canBeInNonQuotedString(c)) { // no quotes
do {
move();
_stringStorage.append(c);
stringStorage_.append(c);
c = current();
} while (canBeInNonQuotedString(c));
} else {
return DeserializationError::InvalidInput;
}
if (!_stringStorage.isValid())
if (!stringStorage_.isValid())
return DeserializationError::NoMemory;
return DeserializationError::Ok;
@ -515,12 +515,12 @@ class JsonDeserializer {
char c = current();
while (canBeInNumber(c) && n < 63) {
move();
_buffer[n++] = c;
buffer_[n++] = c;
c = current();
}
_buffer[n] = 0;
buffer_[n] = 0;
if (!parseNumber(_buffer, result))
if (!parseNumber(buffer_, result))
return DeserializationError::InvalidInput;
return DeserializationError::Ok;
@ -584,7 +584,7 @@ class JsonDeserializer {
switch (current()) {
// end of string
case '\0':
return _foundSomething ? DeserializationError::IncompleteInput
return foundSomething_ ? DeserializationError::IncompleteInput
: DeserializationError::EmptyInput;
// spaces
@ -639,7 +639,7 @@ class JsonDeserializer {
#endif
default:
_foundSomething = true;
foundSomething_ = true;
return DeserializationError::Ok;
}
}
@ -658,11 +658,11 @@ class JsonDeserializer {
return DeserializationError::Ok;
}
TStringStorage _stringStorage;
bool _foundSomething;
Latch<TReader> _latch;
MemoryPool* _pool;
char _buffer[64]; // using a member instead of a local variable because it
TStringStorage stringStorage_;
bool foundSomething_;
Latch<TReader> latch_;
MemoryPool* pool_;
char buffer_[64]; // using a member instead of a local variable because it
// ended in the recursive path after compiler inlined the
// code
};

28
src/ArduinoJson/Json/JsonSerializer.hpp
View File

@ -16,7 +16,7 @@ class JsonSerializer : public Visitor<size_t> {
public:
static const bool producesText = true;
JsonSerializer(TWriter writer) : _formatter(writer) {}
JsonSerializer(TWriter writer) : formatter_(writer) {}
FORCE_INLINE size_t visitArray(const CollectionData& array) {
write('[');
@ -43,7 +43,7 @@ class JsonSerializer : public Visitor<size_t> {
const VariantSlot* slot = object.head();
while (slot != 0) {
_formatter.writeString(slot->key());
formatter_.writeString(slot->key());
write(':');
slot->data()->accept(*this);
@ -59,60 +59,60 @@ class JsonSerializer : public Visitor<size_t> {
}
size_t visitFloat(JsonFloat value) {
_formatter.writeFloat(value);
formatter_.writeFloat(value);
return bytesWritten();
}
size_t visitString(const char* value) {
_formatter.writeString(value);
formatter_.writeString(value);
return bytesWritten();
}
size_t visitString(const char* value, size_t n) {
_formatter.writeString(value, n);
formatter_.writeString(value, n);
return bytesWritten();
}
size_t visitRawJson(const char* data, size_t n) {
_formatter.writeRaw(data, n);
formatter_.writeRaw(data, n);
return bytesWritten();
}
size_t visitSignedInteger(JsonInteger value) {
_formatter.writeInteger(value);
formatter_.writeInteger(value);
return bytesWritten();
}
size_t visitUnsignedInteger(JsonUInt value) {
_formatter.writeInteger(value);
formatter_.writeInteger(value);
return bytesWritten();
}
size_t visitBoolean(bool value) {
_formatter.writeBoolean(value);
formatter_.writeBoolean(value);
return bytesWritten();
}
size_t visitNull() {
_formatter.writeRaw("null");
formatter_.writeRaw("null");
return bytesWritten();
}
protected:
size_t bytesWritten() const {
return _formatter.bytesWritten();
return formatter_.bytesWritten();
}
void write(char c) {
_formatter.writeRaw(c);
formatter_.writeRaw(c);
}
void write(const char* s) {
_formatter.writeRaw(s);
formatter_.writeRaw(s);
}
private:
TextFormatter<TWriter> _formatter;
TextFormatter<TWriter> formatter_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

30
src/ArduinoJson/Json/Latch.hpp
View File

@ -11,45 +11,45 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
template <typename TReader>
class Latch {
public:
Latch(TReader reader) : _reader(reader), _loaded(false) {
Latch(TReader reader) : reader_(reader), loaded_(false) {
#if ARDUINOJSON_DEBUG
_ended = false;
ended_ = false;
#endif
}
void clear() {
_loaded = false;
loaded_ = false;
}
int last() const {
return _current;
return current_;
}
FORCE_INLINE char current() {
if (!_loaded) {
if (!loaded_) {
load();
}
return _current;
return current_;
}
private:
void load() {
ARDUINOJSON_ASSERT(!_ended);
int c = _reader.read();
ARDUINOJSON_ASSERT(!ended_);
int c = reader_.read();
#if ARDUINOJSON_DEBUG
if (c <= 0)
_ended = true;
ended_ = true;
#endif
_current = static_cast<char>(c > 0 ? c : 0);
_loaded = true;
current_ = static_cast<char>(c > 0 ? c : 0);
loaded_ = true;
}
TReader _reader;
char _current; // NOLINT(clang-analyzer-optin.cplusplus.UninitializedObject)
TReader reader_;
char current_; // NOLINT(clang-analyzer-optin.cplusplus.UninitializedObject)
// Not initialized in constructor (+10 bytes on AVR)
bool _loaded;
bool loaded_;
#if ARDUINOJSON_DEBUG
bool _ended;
bool ended_;
#endif
};

14
src/ArduinoJson/Json/PrettyJsonSerializer.hpp
View File

@ -16,13 +16,13 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
typedef JsonSerializer<TWriter> base;
public:
PrettyJsonSerializer(TWriter writer) : base(writer), _nesting(0) {}
PrettyJsonSerializer(TWriter writer) : base(writer), nesting_(0) {}
size_t visitArray(const CollectionData& array) {
const VariantSlot* slot = array.head();
if (slot) {
base::write("[\r\n");
_nesting++;
nesting_++;
while (slot != 0) {
indent();
slot->data()->accept(*this);
@ -30,7 +30,7 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
slot = slot->next();
base::write(slot ? ",\r\n" : "\r\n");
}
_nesting--;
nesting_--;
indent();
base::write("]");
} else {
@ -43,7 +43,7 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
const VariantSlot* slot = object.head();
if (slot) {
base::write("{\r\n");
_nesting++;
nesting_++;
while (slot != 0) {
indent();
base::visitString(slot->key());
@ -53,7 +53,7 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
slot = slot->next();
base::write(slot ? ",\r\n" : "\r\n");
}
_nesting--;
nesting_--;
indent();
base::write("}");
} else {
@ -64,11 +64,11 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
private:
void indent() {
for (uint8_t i = 0; i < _nesting; i++)
for (uint8_t i = 0; i < nesting_; i++)
base::write(ARDUINOJSON_TAB);
}
uint8_t _nesting;
uint8_t nesting_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

16
src/ArduinoJson/Json/TextFormatter.hpp
View File

@ -20,13 +20,13 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
template <typename TWriter>
class TextFormatter {
public:
explicit TextFormatter(TWriter writer) : _writer(writer) {}
explicit TextFormatter(TWriter writer) : writer_(writer) {}
TextFormatter& operator=(const TextFormatter&) = delete;
// Returns the number of bytes sent to the TWriter implementation.
size_t bytesWritten() const {
return _writer.count();
return writer_.count();
}
void writeBoolean(bool value) {
@ -146,28 +146,28 @@ class TextFormatter {
}
void writeRaw(const char* s) {
_writer.write(reinterpret_cast<const uint8_t*>(s), strlen(s));
writer_.write(reinterpret_cast<const uint8_t*>(s), strlen(s));
}
void writeRaw(const char* s, size_t n) {
_writer.write(reinterpret_cast<const uint8_t*>(s), n);
writer_.write(reinterpret_cast<const uint8_t*>(s), n);
}
void writeRaw(const char* begin, const char* end) {
_writer.write(reinterpret_cast<const uint8_t*>(begin),
writer_.write(reinterpret_cast<const uint8_t*>(begin),
static_cast<size_t>(end - begin));
}
template <size_t N>
void writeRaw(const char (&s)[N]) {
_writer.write(reinterpret_cast<const uint8_t*>(s), N - 1);
writer_.write(reinterpret_cast<const uint8_t*>(s), N - 1);
}
void writeRaw(char c) {
_writer.write(static_cast<uint8_t>(c));
writer_.write(static_cast<uint8_t>(c));
}
protected:
CountingDecorator<TWriter> _writer;
CountingDecorator<TWriter> writer_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

16
src/ArduinoJson/Json/Utf16.hpp
View File

@ -31,31 +31,31 @@ inline bool isLowSurrogate(uint16_t codeunit) {
class Codepoint {
public:
Codepoint() : _highSurrogate(0), _codepoint(0) {}
Codepoint() : highSurrogate_(0), codepoint_(0) {}
bool append(uint16_t codeunit) {
if (isHighSurrogate(codeunit)) {
_highSurrogate = codeunit & 0x3FF;
highSurrogate_ = codeunit & 0x3FF;
return false;
}
if (isLowSurrogate(codeunit)) {
_codepoint =
uint32_t(0x10000 + ((_highSurrogate << 10) | (codeunit & 0x3FF)));
codepoint_ =
uint32_t(0x10000 + ((highSurrogate_ << 10) | (codeunit & 0x3FF)));
return true;
}
_codepoint = codeunit;
codepoint_ = codeunit;
return true;
}
uint32_t value() const {
return _codepoint;
return codepoint_;
}
private:
uint16_t _highSurrogate;
uint32_t _codepoint;
uint16_t highSurrogate_;
uint32_t codepoint_;
};
} // namespace Utf16
ARDUINOJSON_END_PRIVATE_NAMESPACE

130
src/ArduinoJson/Memory/MemoryPool.hpp
View File

@ -40,7 +40,7 @@ constexpr size_t sizeofString(size_t n) {
class MemoryPool {
public:
MemoryPool(size_t capa, Allocator* allocator = DefaultAllocator::instance())
: _allocator(allocator), _overflowed(false) {
: allocator_(allocator), overflowed_(false) {
allocPool(addPadding(capa));
}
@ -55,48 +55,48 @@ class MemoryPool {
MemoryPool& operator=(MemoryPool&& src) {
deallocAllStrings();
deallocPool();
_allocator = src._allocator;
_begin = src._begin;
_end = src._end;
_right = src._right;
_overflowed = src._overflowed;
src._begin = src._end = src._right = nullptr;
_strings = src._strings;
src._strings = nullptr;
allocator_ = src.allocator_;
begin_ = src.begin_;
end_ = src.end_;
right_ = src.right_;
overflowed_ = src.overflowed_;
src.begin_ = src.end_ = src.right_ = nullptr;
strings_ = src.strings_;
src.strings_ = nullptr;
return *this;
}
Allocator* allocator() const {
return _allocator;
return allocator_;
}
void reallocPool(size_t requiredSize) {
size_t capa = addPadding(requiredSize);
if (capa == capacity())
return;
_allocator->deallocate(_begin);
allocator_->deallocate(begin_);
allocPool(requiredSize);
}
void* buffer() {
return _begin; // NOLINT(clang-analyzer-unix.Malloc)
return begin_; // NOLINT(clang-analyzer-unix.Malloc)
// movePointers() alters this pointer
}
// Gets the capacity of the memoryPool in bytes
size_t capacity() const {
return size_t(_end - _begin);
return size_t(end_ - begin_);
}
size_t size() const {
size_t total = size_t(_end - _right);
for (auto node = _strings; node; node = node->next)
size_t total = size_t(end_ - right_);
for (auto node = strings_; node; node = node->next)
total += sizeofString(node->length);
return total;
}
bool overflowed() const {
return _overflowed;
return overflowed_;
}
VariantSlot* allocVariant() {
@ -131,13 +131,13 @@ class MemoryPool {
void addStringToList(StringNode* node) {
ARDUINOJSON_ASSERT(node != nullptr);
node->next = _strings;
_strings = node;
node->next = strings_;
strings_ = node;
}
template <typename TAdaptedString>
StringNode* findString(const TAdaptedString& str) const {
for (auto node = _strings; node; node = node->next) {
for (auto node = strings_; node; node = node->next) {
if (stringEquals(str, adaptString(node->data, node->length)))
return node;
}
@ -146,12 +146,12 @@ class MemoryPool {
StringNode* allocString(size_t length) {
auto node = reinterpret_cast<StringNode*>(
_allocator->allocate(sizeofString(length)));
allocator_->allocate(sizeofString(length)));
if (node) {
node->length = uint16_t(length);
node->references = 1;
} else {
_overflowed = true;
overflowed_ = true;
}
return node;
}
@ -159,30 +159,30 @@ class MemoryPool {
StringNode* reallocString(StringNode* node, size_t length) {
ARDUINOJSON_ASSERT(node != nullptr);
auto newNode = reinterpret_cast<StringNode*>(
_allocator->reallocate(node, sizeofString(length)));
allocator_->reallocate(node, sizeofString(length)));
if (newNode) {
newNode->length = uint16_t(length);
} else {
_overflowed = true;
_allocator->deallocate(node);
overflowed_ = true;
allocator_->deallocate(node);
}
return newNode;
}
void deallocString(StringNode* node) {
_allocator->deallocate(node);
allocator_->deallocate(node);
}
void dereferenceString(const char* s) {
StringNode* prev = nullptr;
for (auto node = _strings; node; node = node->next) {
for (auto node = strings_; node; node = node->next) {
if (node->data == s) {
if (--node->references == 0) {
if (prev)
prev->next = node->next;
else
_strings = node->next;
_allocator->deallocate(node);
strings_ = node->next;
allocator_->deallocate(node);
}
return;
}
@ -191,17 +191,17 @@ class MemoryPool {
}
void clear() {
_right = _end;
_overflowed = false;
right_ = end_;
overflowed_ = false;
deallocAllStrings();
}
bool canAlloc(size_t bytes) const {
return _begin + bytes <= _right;
return begin_ + bytes <= right_;
}
bool owns(void* p) const {
return _begin <= p && p < _end;
return begin_ <= p && p < end_;
}
// Workaround for missing placement new
@ -214,8 +214,8 @@ class MemoryPool {
if (bytes_reclaimed == 0)
return;
void* old_ptr = _begin;
void* new_ptr = _allocator->reallocate(old_ptr, capacity());
void* old_ptr = begin_;
void* new_ptr = allocator_->reallocate(old_ptr, capacity());
ptrdiff_t ptr_offset =
static_cast<char*>(new_ptr) - static_cast<char*>(old_ptr);
@ -227,37 +227,37 @@ class MemoryPool {
private:
ptrdiff_t squash() {
char* new_right = addPadding(_begin);
if (new_right >= _right)
char* new_right = addPadding(begin_);
if (new_right >= right_)
return 0;
size_t right_size = static_cast<size_t>(_end - _right);
memmove(new_right, _right, right_size);
size_t right_size = static_cast<size_t>(end_ - right_);
memmove(new_right, right_, right_size);
ptrdiff_t bytes_reclaimed = _right - new_right;
_right = new_right;
_end = new_right + right_size;
ptrdiff_t bytes_reclaimed = right_ - new_right;
right_ = new_right;
end_ = new_right + right_size;
return bytes_reclaimed;
}
// Move all pointers together
// This funcion is called after a realloc.
void movePointers(ptrdiff_t offset) {
_begin += offset;
_right += offset;
_end += offset;
begin_ += offset;
right_ += offset;
end_ += offset;
}
void checkInvariants() {
ARDUINOJSON_ASSERT(_begin <= _right);
ARDUINOJSON_ASSERT(_right <= _end);
ARDUINOJSON_ASSERT(isAligned(_right));
ARDUINOJSON_ASSERT(begin_ <= right_);
ARDUINOJSON_ASSERT(right_ <= end_);
ARDUINOJSON_ASSERT(isAligned(right_));
}
void deallocAllStrings() {
while (_strings) {
auto node = _strings;
_strings = node->next;
while (strings_) {
auto node = strings_;
strings_ = node->next;
deallocString(node);
}
}
@ -269,31 +269,31 @@ class MemoryPool {
void* allocRight(size_t bytes) {
if (!canAlloc(bytes)) {
_overflowed = true;
overflowed_ = true;
return 0;
}
_right -= bytes;
return _right;
right_ -= bytes;
return right_;
}
void allocPool(size_t capa) {
auto buf = capa ? reinterpret_cast<char*>(_allocator->allocate(capa)) : 0;
_begin = buf;
_end = _right = buf ? buf + capa : 0;
ARDUINOJSON_ASSERT(isAligned(_begin));
ARDUINOJSON_ASSERT(isAligned(_right));
ARDUINOJSON_ASSERT(isAligned(_end));
auto buf = capa ? reinterpret_cast<char*>(allocator_->allocate(capa)) : 0;
begin_ = buf;
end_ = right_ = buf ? buf + capa : 0;
ARDUINOJSON_ASSERT(isAligned(begin_));
ARDUINOJSON_ASSERT(isAligned(right_));
ARDUINOJSON_ASSERT(isAligned(end_));
}
void deallocPool() {
if (_begin)
_allocator->deallocate(_begin);
if (begin_)
allocator_->deallocate(begin_);
}
Allocator* _allocator;
char *_begin, *_right, *_end;
bool _overflowed;
StringNode* _strings = nullptr;
Allocator* allocator_;
char *begin_, *right_, *end_;
bool overflowed_;
StringNode* strings_ = nullptr;
};
template <typename TAdaptedString>

22
src/ArduinoJson/Misc/SerializedValue.hpp
View File

@ -12,43 +12,43 @@ ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
template <typename T>
class SerializedValue {
public:
explicit SerializedValue(T str) : _str(str) {}
explicit SerializedValue(T str) : str_(str) {}
operator T() const {
return _str;
return str_;
}
const char* data() const {
return _str.c_str();
return str_.c_str();
}
size_t size() const {
// CAUTION: the old Arduino String doesn't have size()
return _str.length();
return str_.length();
}
private:
T _str;
T str_;
};
template <typename TChar>
class SerializedValue<TChar*> {
public:
explicit SerializedValue(TChar* p, size_t n) : _data(p), _size(n) {}
explicit SerializedValue(TChar* p, size_t n) : data_(p), size_(n) {}
operator TChar*() const {
return _data;
return data_;
}
TChar* data() const {
return _data;
return data_;
}
size_t size() const {
return _size;
return size_;
}
private:
TChar* _data;
size_t _size;
TChar* data_;
size_t size_;
};
template <typename T>

42
src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
View File

@ -18,17 +18,17 @@ class MsgPackDeserializer {
public:
MsgPackDeserializer(MemoryPool* pool, TReader reader,
TStringStorage stringStorage)
: _pool(pool),
_reader(reader),
_stringStorage(stringStorage),
_foundSomething(false) {}
: pool_(pool),
reader_(reader),
stringStorage_(stringStorage),
foundSomething_(false) {}
template <typename TFilter>
DeserializationError parse(VariantData& variant, TFilter filter,
DeserializationOption::NestingLimit nestingLimit) {
DeserializationError::Code err;
err = parseVariant(&variant, filter, nestingLimit);
return _foundSomething ? err : DeserializationError::EmptyInput;
return foundSomething_ ? err : DeserializationError::EmptyInput;
}
private:
@ -43,7 +43,7 @@ class MsgPackDeserializer {
if (err)
return err;
_foundSomething = true;
foundSomething_ = true;
bool allowValue = filter.allowValue();
@ -224,7 +224,7 @@ class MsgPackDeserializer {
}
DeserializationError::Code readByte(uint8_t& value) {
int c = _reader.read();
int c = reader_.read();
if (c < 0)
return DeserializationError::IncompleteInput;
value = static_cast<uint8_t>(c);
@ -232,7 +232,7 @@ class MsgPackDeserializer {
}
DeserializationError::Code readBytes(uint8_t* p, size_t n) {
if (_reader.readBytes(reinterpret_cast<char*>(p), n) == n)
if (reader_.readBytes(reinterpret_cast<char*>(p), n) == n)
return DeserializationError::Ok;
return DeserializationError::IncompleteInput;
}
@ -244,7 +244,7 @@ class MsgPackDeserializer {
DeserializationError::Code skipBytes(size_t n) {
for (; n; --n) {
if (_reader.read() < 0)
if (reader_.read() < 0)
return DeserializationError::IncompleteInput;
}
return DeserializationError::Ok;
@ -371,14 +371,14 @@ class MsgPackDeserializer {
if (err)
return err;
variant->setString(_stringStorage.save());
variant->setString(stringStorage_.save());
return DeserializationError::Ok;
}
DeserializationError::Code readString(size_t n) {
DeserializationError::Code err;
_stringStorage.startString();
stringStorage_.startString();
for (; n; --n) {
uint8_t c;
@ -386,10 +386,10 @@ class MsgPackDeserializer {
if (err)
return err;
_stringStorage.append(static_cast<char>(c));
stringStorage_.append(static_cast<char>(c));
}
if (!_stringStorage.isValid())
if (!stringStorage_.isValid())
return DeserializationError::NoMemory;
return DeserializationError::Ok;
@ -435,7 +435,7 @@ class MsgPackDeserializer {
if (memberFilter.allow()) {
ARDUINOJSON_ASSERT(array != 0);
value = collectionAddElement(array, _pool);
value = collectionAddElement(array, pool_);
if (!value)
return DeserializationError::NoMemory;
} else {
@ -486,7 +486,7 @@ class MsgPackDeserializer {
if (err)
return err;
JsonString key = _stringStorage.str();
JsonString key = stringStorage_.str();
TFilter memberFilter = filter[key.c_str()];
VariantData* member;
@ -494,9 +494,9 @@ class MsgPackDeserializer {
ARDUINOJSON_ASSERT(object != 0);
// Save key in memory pool.
key = _stringStorage.save();
key = stringStorage_.save();
VariantSlot* slot = _pool->allocVariant();
VariantSlot* slot = pool_->allocVariant();
if (!slot)
return DeserializationError::NoMemory;
@ -554,10 +554,10 @@ class MsgPackDeserializer {
return skipBytes(size + 1U);
}
MemoryPool* _pool;
TReader _reader;
TStringStorage _stringStorage;
bool _foundSomething;
MemoryPool* pool_;
TReader reader_;
TStringStorage stringStorage_;
bool foundSomething_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

10
src/ArduinoJson/MsgPack/MsgPackSerializer.hpp
View File

@ -19,7 +19,7 @@ class MsgPackSerializer : public Visitor<size_t> {
public:
static const bool producesText = false;
MsgPackSerializer(TWriter writer) : _writer(writer) {}
MsgPackSerializer(TWriter writer) : writer_(writer) {}
template <typename T>
typename enable_if<sizeof(T) == 4, size_t>::type visitFloat(T value32) {
@ -177,15 +177,15 @@ class MsgPackSerializer : public Visitor<size_t> {
private:
size_t bytesWritten() const {
return _writer.count();
return writer_.count();
}
void writeByte(uint8_t c) {
_writer.write(c);
writer_.write(c);
}
void writeBytes(const uint8_t* p, size_t n) {
_writer.write(p, n);
writer_.write(p, n);
}
template <typename T>
@ -194,7 +194,7 @@ class MsgPackSerializer : public Visitor<size_t> {
writeBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
}
CountingDecorator<TWriter> _writer;
CountingDecorator<TWriter> writer_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

54
src/ArduinoJson/Object/JsonObject.hpp
View File

@ -20,61 +20,61 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
typedef JsonObjectIterator iterator;
// Creates an unbound reference.
FORCE_INLINE JsonObject() : _data(0), _pool(0) {}
FORCE_INLINE JsonObject() : data_(0), pool_(0) {}
// INTERNAL USE ONLY
FORCE_INLINE JsonObject(detail::MemoryPool* buf, detail::CollectionData* data)
: _data(data), _pool(buf) {}
: data_(data), pool_(buf) {}
operator JsonVariant() const {
void* data = _data; // prevent warning cast-align
return JsonVariant(_pool, reinterpret_cast<detail::VariantData*>(data));
void* data = data_; // prevent warning cast-align
return JsonVariant(pool_, reinterpret_cast<detail::VariantData*>(data));
}
operator JsonObjectConst() const {
return JsonObjectConst(_data);
return JsonObjectConst(data_);
}
operator JsonVariantConst() const {
return JsonVariantConst(collectionToVariant(_data));
return JsonVariantConst(collectionToVariant(data_));
}
// Returns true if the reference is unbound.
// https://arduinojson.org/v6/api/jsonobject/isnull/
FORCE_INLINE bool isNull() const {
return _data == 0;
return data_ == 0;
}
// Returns true if the reference is bound.
// https://arduinojson.org/v6/api/jsonobject/isnull/
FORCE_INLINE operator bool() const {
return _data != 0;
return data_ != 0;
}
// Returns the number of bytes occupied by the object.
// https://arduinojson.org/v6/api/jsonobject/memoryusage/
FORCE_INLINE size_t memoryUsage() const {
return _data ? _data->memoryUsage() : 0;
return data_ ? data_->memoryUsage() : 0;
}
// Returns the depth (nesting level) of the object.
// https://arduinojson.org/v6/api/jsonobject/nesting/
FORCE_INLINE size_t nesting() const {
return variantNesting(collectionToVariant(_data));
return variantNesting(collectionToVariant(data_));
}
// Returns the number of members in the object.
// https://arduinojson.org/v6/api/jsonobject/size/
FORCE_INLINE size_t size() const {
return _data ? _data->size() : 0;
return data_ ? data_->size() : 0;
}
// Returns an iterator to the first key-value pair of the object.
// https://arduinojson.org/v6/api/jsonobject/begin/
FORCE_INLINE iterator begin() const {
if (!_data)
if (!data_)
return iterator();
return iterator(_pool, _data->head());
return iterator(pool_, data_->head());
}
// Returns an iterator following the last key-value pair of the object.
@ -87,18 +87,18 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
// ⚠️ Doesn't release the memory associated with the removed members.
// https://arduinojson.org/v6/api/jsonobject/clear/
void clear() const {
collectionClear(_data, _pool);
collectionClear(data_, pool_);
}
// Copies an object.
// https://arduinojson.org/v6/api/jsonobject/set/
FORCE_INLINE bool set(JsonObjectConst src) {
return collectionCopy(_data, src._data, _pool);
return collectionCopy(data_, src.data_, pool_);
}
// Compares the content of two objects.
FORCE_INLINE bool operator==(JsonObject rhs) const {
return JsonObjectConst(_data) == JsonObjectConst(rhs._data);
return JsonObjectConst(data_) == JsonObjectConst(rhs.data_);
}
// Gets or sets the member with specified key.
@ -125,7 +125,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
// ⚠️ Doesn't release the memory associated with the removed member.
// https://arduinojson.org/v6/api/jsonobject/remove/
FORCE_INLINE void remove(iterator it) const {
collectionRemove(_data, it._slot, _pool);
collectionRemove(data_, it.slot_, pool_);
}
// Removes the member with the specified key.
@ -133,7 +133,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
// https://arduinojson.org/v6/api/jsonobject/remove/
template <typename TString>
FORCE_INLINE void remove(const TString& key) const {
collectionRemoveMember(_data, detail::adaptString(key), _pool);
collectionRemoveMember(data_, detail::adaptString(key), pool_);
}
// Removes the member with the specified key.
@ -141,7 +141,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
// https://arduinojson.org/v6/api/jsonobject/remove/
template <typename TChar>
FORCE_INLINE void remove(TChar* key) const {
collectionRemoveMember(_data, detail::adaptString(key), _pool);
collectionRemoveMember(data_, detail::adaptString(key), pool_);
}
// Returns true if the object contains the specified key.
@ -150,7 +150,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
FORCE_INLINE
typename detail::enable_if<detail::IsString<TString>::value, bool>::type
containsKey(const TString& key) const {
return collectionGetMember(_data, detail::adaptString(key)) != 0;
return collectionGetMember(data_, detail::adaptString(key)) != 0;
}
// Returns true if the object contains the specified key.
@ -159,7 +159,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
FORCE_INLINE
typename detail::enable_if<detail::IsString<TChar*>::value, bool>::type
containsKey(TChar* key) const {
return collectionGetMember(_data, detail::adaptString(key)) != 0;
return collectionGetMember(data_, detail::adaptString(key)) != 0;
}
// Creates an array and adds it to the object.
@ -188,24 +188,24 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
private:
detail::MemoryPool* getPool() const {
return _pool;
return pool_;
}
detail::VariantData* getData() const {
return detail::collectionToVariant(_data);
return detail::collectionToVariant(data_);
}
detail::VariantData* getOrCreateData() const {
return detail::collectionToVariant(_data);
return detail::collectionToVariant(data_);
}
template <typename TAdaptedString>
void removeMember(TAdaptedString key) const {
collectionRemove(_data, _data->get(key), _pool);
collectionRemove(data_, data_->get(key), pool_);
}
detail::CollectionData* _data;
detail::MemoryPool* _pool;
detail::CollectionData* data_;
detail::MemoryPool* pool_;
};
template <>

36
src/ArduinoJson/Object/JsonObjectConst.hpp
View File

@ -19,51 +19,51 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
typedef JsonObjectConstIterator iterator;
// Creates an unbound reference.
JsonObjectConst() : _data(0) {}
JsonObjectConst() : data_(0) {}
// INTERNAL USE ONLY
JsonObjectConst(const detail::CollectionData* data) : _data(data) {}
JsonObjectConst(const detail::CollectionData* data) : data_(data) {}
operator JsonVariantConst() const {
return JsonVariantConst(collectionToVariant(_data));
return JsonVariantConst(collectionToVariant(data_));
}
// Returns true if the reference is unbound.
// https://arduinojson.org/v6/api/jsonobjectconst/isnull/
FORCE_INLINE bool isNull() const {
return _data == 0;
return data_ == 0;
}
// Returns true if the reference is bound.
// https://arduinojson.org/v6/api/jsonobjectconst/isnull/
FORCE_INLINE operator bool() const {
return _data != 0;
return data_ != 0;
}
// Returns the number of bytes occupied by the object.
// https://arduinojson.org/v6/api/jsonobjectconst/memoryusage/
FORCE_INLINE size_t memoryUsage() const {
return _data ? _data->memoryUsage() : 0;
return data_ ? data_->memoryUsage() : 0;
}
// Returns the depth (nesting level) of the object.
// https://arduinojson.org/v6/api/jsonobjectconst/nesting/
FORCE_INLINE size_t nesting() const {
return variantNesting(collectionToVariant(_data));
return variantNesting(collectionToVariant(data_));
}
// Returns the number of members in the object.
// https://arduinojson.org/v6/api/jsonobjectconst/size/
FORCE_INLINE size_t size() const {
return _data ? _data->size() : 0;
return data_ ? data_->size() : 0;
}
// Returns an iterator to the first key-value pair of the object.
// https://arduinojson.org/v6/api/jsonobjectconst/begin/
FORCE_INLINE iterator begin() const {
if (!_data)
if (!data_)
return iterator();
return iterator(_data->head());
return iterator(data_->head());
}
// Returns an iterator following the last key-value pair of the object.
@ -76,14 +76,14 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
// https://arduinojson.org/v6/api/jsonobjectconst/containskey/
template <typename TString>
FORCE_INLINE bool containsKey(const TString& key) const {
return collectionGetMember(_data, detail::adaptString(key)) != 0;
return collectionGetMember(data_, detail::adaptString(key)) != 0;
}
// Returns true if the object contains the specified key.
// https://arduinojson.org/v6/api/jsonobjectconst/containskey/
template <typename TChar>
FORCE_INLINE bool containsKey(TChar* key) const {
return collectionGetMember(_data, detail::adaptString(key)) != 0;
return collectionGetMember(data_, detail::adaptString(key)) != 0;
}
// Gets the member with specified key.
@ -93,7 +93,7 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
JsonVariantConst>::type
operator[](const TString& key) const {
return JsonVariantConst(
collectionGetMember(_data, detail::adaptString(key)));
collectionGetMember(data_, detail::adaptString(key)));
}
// Gets the member with specified key.
@ -103,15 +103,15 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
JsonVariantConst>::type
operator[](TChar* key) const {
return JsonVariantConst(
collectionGetMember(_data, detail::adaptString(key)));
collectionGetMember(data_, detail::adaptString(key)));
}
// Compares objects.
FORCE_INLINE bool operator==(JsonObjectConst rhs) const {
if (_data == rhs._data)
if (data_ == rhs.data_)
return true;
if (!_data || !rhs._data)
if (!data_ || !rhs.data_)
return false;
size_t count = 0;
@ -125,10 +125,10 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
private:
const detail::VariantData* getData() const {
return collectionToVariant(_data);
return collectionToVariant(data_);
}
const detail::CollectionData* _data;
const detail::CollectionData* data_;
};
template <>

54
src/ArduinoJson/Object/JsonObjectIterator.hpp
View File

@ -12,112 +12,112 @@ ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
class JsonPairPtr {
public:
JsonPairPtr(detail::MemoryPool* pool, detail::VariantSlot* slot)
: _pair(pool, slot) {}
: pair_(pool, slot) {}
const JsonPair* operator->() const {
return &_pair;
return &pair_;
}
const JsonPair& operator*() const {
return _pair;
return pair_;
}
private:
JsonPair _pair;
JsonPair pair_;
};
class JsonObjectIterator {
friend class JsonObject;
public:
JsonObjectIterator() : _slot(0) {}
JsonObjectIterator() : slot_(0) {}
explicit JsonObjectIterator(detail::MemoryPool* pool,
detail::VariantSlot* slot)
: _pool(pool), _slot(slot) {}
: pool_(pool), slot_(slot) {}
JsonPair operator*() const {
return JsonPair(_pool, _slot);
return JsonPair(pool_, slot_);
}
JsonPairPtr operator->() {
return JsonPairPtr(_pool, _slot);
return JsonPairPtr(pool_, slot_);
}
bool operator==(const JsonObjectIterator& other) const {
return _slot == other._slot;
return slot_ == other.slot_;
}
bool operator!=(const JsonObjectIterator& other) const {
return _slot != other._slot;
return slot_ != other.slot_;
}
JsonObjectIterator& operator++() {
_slot = _slot->next();
slot_ = slot_->next();
return *this;
}
JsonObjectIterator& operator+=(size_t distance) {
_slot = _slot->next(distance);
slot_ = slot_->next(distance);
return *this;
}
private:
detail::MemoryPool* _pool;
detail::VariantSlot* _slot;
detail::MemoryPool* pool_;
detail::VariantSlot* slot_;
};
class JsonPairConstPtr {
public:
JsonPairConstPtr(const detail::VariantSlot* slot) : _pair(slot) {}
JsonPairConstPtr(const detail::VariantSlot* slot) : pair_(slot) {}
const JsonPairConst* operator->() const {
return &_pair;
return &pair_;
}
const JsonPairConst& operator*() const {
return _pair;
return pair_;
}
private:
JsonPairConst _pair;
JsonPairConst pair_;
};
class JsonObjectConstIterator {
friend class JsonObject;
public:
JsonObjectConstIterator() : _slot(0) {}
JsonObjectConstIterator() : slot_(0) {}
explicit JsonObjectConstIterator(const detail::VariantSlot* slot)
: _slot(slot) {}
: slot_(slot) {}
JsonPairConst operator*() const {
return JsonPairConst(_slot);
return JsonPairConst(slot_);
}
JsonPairConstPtr operator->() {
return JsonPairConstPtr(_slot);
return JsonPairConstPtr(slot_);
}
bool operator==(const JsonObjectConstIterator& other) const {
return _slot == other._slot;
return slot_ == other.slot_;
}
bool operator!=(const JsonObjectConstIterator& other) const {
return _slot != other._slot;
return slot_ != other.slot_;
}
JsonObjectConstIterator& operator++() {
_slot = _slot->next();
slot_ = slot_->next();
return *this;
}
JsonObjectConstIterator& operator+=(size_t distance) {
_slot = _slot->next(distance);
slot_ = slot_->next(distance);
return *this;
}
private:
const detail::VariantSlot* _slot;
const detail::VariantSlot* slot_;
};
ARDUINOJSON_END_PUBLIC_NAMESPACE

24
src/ArduinoJson/Object/JsonPair.hpp
View File

@ -17,25 +17,25 @@ class JsonPair {
// INTERNAL USE ONLY
JsonPair(detail::MemoryPool* pool, detail::VariantSlot* slot) {
if (slot) {
_key = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
key_ = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
: JsonString::Linked);
_value = JsonVariant(pool, slot->data());
value_ = JsonVariant(pool, slot->data());
}
}
// Returns the key.
JsonString key() const {
return _key;
return key_;
}
// Returns the value.
JsonVariant value() const {
return _value;
return value_;
}
private:
JsonString _key;
JsonVariant _value;
JsonString key_;
JsonVariant value_;
};
// A read-only key-value pair.
@ -44,25 +44,25 @@ class JsonPairConst {
public:
JsonPairConst(const detail::VariantSlot* slot) {
if (slot) {
_key = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
key_ = JsonString(slot->key(), slot->ownsKey() ? JsonString::Copied
: JsonString::Linked);
_value = JsonVariantConst(slot->data());
value_ = JsonVariantConst(slot->data());
}
}
// Returns the key.
JsonString key() const {
return _key;
return key_;
}
// Returns the value.
JsonVariantConst value() const {
return _value;
return value_;
}
private:
JsonString _key;
JsonVariantConst _value;
JsonString key_;
JsonVariantConst value_;
};
ARDUINOJSON_END_PUBLIC_NAMESPACE

20
src/ArduinoJson/Object/MemberProxy.hpp
View File

@ -18,10 +18,10 @@ class MemberProxy
public:
FORCE_INLINE MemberProxy(TUpstream upstream, TStringRef key)
: _upstream(upstream), _key(key) {}
: upstream_(upstream), key_(key) {}
MemberProxy(const MemberProxy& src)
: _upstream(src._upstream), _key(src._key) {}
: upstream_(src.upstream_), key_(src.key_) {}
FORCE_INLINE MemberProxy& operator=(const MemberProxy& src) {
this->set(src);
@ -42,23 +42,23 @@ class MemberProxy
private:
FORCE_INLINE MemoryPool* getPool() const {
return VariantAttorney::getPool(_upstream);
return VariantAttorney::getPool(upstream_);
}
FORCE_INLINE VariantData* getData() const {
return variantGetMember(VariantAttorney::getData(_upstream),
adaptString(_key));
return variantGetMember(VariantAttorney::getData(upstream_),
adaptString(key_));
}
FORCE_INLINE VariantData* getOrCreateData() const {
return variantGetOrAddMember(VariantAttorney::getOrCreateData(_upstream),
adaptString(_key),
VariantAttorney::getPool(_upstream));
return variantGetOrAddMember(VariantAttorney::getOrCreateData(upstream_),
adaptString(key_),
VariantAttorney::getPool(upstream_));
}
private:
TUpstream _upstream;
TStringRef _key;
TUpstream upstream_;
TStringRef key_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

6
src/ArduinoJson/Polyfills/pgmspace_generic.hpp
View File

@ -54,14 +54,14 @@ inline T pgm_read(const T* p) {
template <typename T>
class pgm_ptr {
public:
explicit pgm_ptr(const T* ptr) : _ptr(ptr) {}
explicit pgm_ptr(const T* ptr) : ptr_(ptr) {}
T operator[](intptr_t index) const {
return pgm_read(_ptr + index);
return pgm_read(ptr_ + index);
}
private:
const T* _ptr;
const T* ptr_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

4
src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp
View File

@ -27,10 +27,10 @@ struct is_convertible {
static int probe(To);
static char probe(...);
static From& _from;
static From& from_;
public:
static const bool value = sizeof(probe(_from)) == sizeof(int);
static const bool value = sizeof(probe(from_)) == sizeof(int);
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

12
src/ArduinoJson/Serialization/CountingDecorator.hpp
View File

@ -11,23 +11,23 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
template <typename TWriter>
class CountingDecorator {
public:
explicit CountingDecorator(TWriter& writer) : _writer(writer), _count(0) {}
explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {}
void write(uint8_t c) {
_count += _writer.write(c);
count_ += writer_.write(c);
}
void write(const uint8_t* s, size_t n) {
_count += _writer.write(s, n);
count_ += writer_.write(s, n);
}
size_t count() const {
return _count;
return count_;
}
private:
TWriter _writer;
size_t _count;
TWriter writer_;
size_t count_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

8
src/ArduinoJson/Serialization/Writer.hpp
View File

@ -12,18 +12,18 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
template <typename TDestination, typename Enable = void>
class Writer {
public:
explicit Writer(TDestination& dest) : _dest(&dest) {}
explicit Writer(TDestination& dest) : dest_(&dest) {}
size_t write(uint8_t c) {
return _dest->write(c);
return dest_->write(c);
}
size_t write(const uint8_t* s, size_t n) {
return _dest->write(s, n);
return dest_->write(s, n);
}
private:
TDestination* _dest;
TDestination* dest_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

24
src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp
View File

@ -13,8 +13,8 @@ class Writer<::String, void> {
static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE;
public:
explicit Writer(::String& str) : _destination(&str) {
_size = 0;
explicit Writer(::String& str) : destination_(&str) {
size_ = 0;
}
~Writer() {
@ -22,10 +22,10 @@ class Writer<::String, void> {
}
size_t write(uint8_t c) {
if (_size + 1 >= bufferCapacity)
if (size_ + 1 >= bufferCapacity)
if (flush() != 0)
return 0;
_buffer[_size++] = static_cast<char>(c);
buffer_[size_++] = static_cast<char>(c);
return 1;
}
@ -37,17 +37,17 @@ class Writer<::String, void> {
}
size_t flush() {
ARDUINOJSON_ASSERT(_size < bufferCapacity);
_buffer[_size] = 0;
if (_destination->concat(_buffer))
_size = 0;
return _size;
ARDUINOJSON_ASSERT(size_ < bufferCapacity);
buffer_[size_] = 0;
if (destination_->concat(buffer_))
size_ = 0;
return size_;
}
private:
::String* _destination;
char _buffer[bufferCapacity];
size_t _size;
::String* destination_;
char buffer_[bufferCapacity];
size_t size_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

8
src/ArduinoJson/Serialization/Writers/PrintWriter.hpp
View File

@ -13,18 +13,18 @@ class Writer<
TDestination,
typename enable_if<is_base_of<::Print, TDestination>::value>::type> {
public:
explicit Writer(::Print& print) : _print(&print) {}
explicit Writer(::Print& print) : print_(&print) {}
size_t write(uint8_t c) {
return _print->write(c);
return print_->write(c);
}
size_t write(const uint8_t* s, size_t n) {
return _print->write(s, n);
return print_->write(s, n);
}
private:
::Print* _print;
::Print* print_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

8
src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp
View File

@ -13,21 +13,21 @@ class Writer<
TDestination,
typename enable_if<is_base_of<std::ostream, TDestination>::value>::type> {
public:
explicit Writer(std::ostream& os) : _os(&os) {}
explicit Writer(std::ostream& os) : os_(&os) {}
size_t write(uint8_t c) {
_os->put(static_cast<char>(c));
os_->put(static_cast<char>(c));
return 1;
}
size_t write(const uint8_t* s, size_t n) {
_os->write(reinterpret_cast<const char*>(s),
os_->write(reinterpret_cast<const char*>(s),
static_cast<std::streamsize>(n));
return n;
}
private:
std::ostream* _os;
std::ostream* os_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

8
src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp
View File

@ -24,20 +24,20 @@ template <typename TDestination>
class Writer<TDestination,
typename enable_if<is_std_string<TDestination>::value>::type> {
public:
Writer(TDestination& str) : _str(&str) {}
Writer(TDestination& str) : str_(&str) {}
size_t write(uint8_t c) {
_str->push_back(static_cast<char>(c));
str_->push_back(static_cast<char>(c));
return 1;
}
size_t write(const uint8_t* s, size_t n) {
_str->append(reinterpret_cast<const char*>(s), n);
str_->append(reinterpret_cast<const char*>(s), n);
return n;
}
private:
TDestination* _str;
TDestination* str_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

48
src/ArduinoJson/StringStorage/StringCopier.hpp
View File

@ -12,27 +12,27 @@ class StringCopier {
public:
static const size_t initialCapacity = 31;
StringCopier(MemoryPool* pool) : _pool(pool) {}
StringCopier(MemoryPool* pool) : pool_(pool) {}
~StringCopier() {
if (_node)
_pool->deallocString(_node);
if (node_)
pool_->deallocString(node_);
}
void startString() {
_size = 0;
if (!_node)
_node = _pool->allocString(initialCapacity);
size_ = 0;
if (!node_)
node_ = pool_->allocString(initialCapacity);
}
JsonString save() {
ARDUINOJSON_ASSERT(_node != nullptr);
_node->data[_size] = 0;
StringNode* node = _pool->findString(adaptString(_node->data, _size));
ARDUINOJSON_ASSERT(node_ != nullptr);
node_->data[size_] = 0;
StringNode* node = pool_->findString(adaptString(node_->data, size_));
if (!node) {
node = _pool->reallocString(_node, _size);
_pool->addStringToList(node);
_node = nullptr; // next time we need a new string
node = pool_->reallocString(node_, size_);
pool_->addStringToList(node);
node_ = nullptr; // next time we need a new string
} else {
node->references++;
}
@ -50,30 +50,30 @@ class StringCopier {
}
void append(char c) {
if (_node && _size == _node->length)
_node = _pool->reallocString(_node, _size * 2U + 1);
if (_node)
_node->data[_size++] = c;
if (node_ && size_ == node_->length)
node_ = pool_->reallocString(node_, size_ * 2U + 1);
if (node_)
node_->data[size_++] = c;
}
bool isValid() const {
return _node != nullptr;
return node_ != nullptr;
}
size_t size() const {
return _size;
return size_;
}
JsonString str() const {
ARDUINOJSON_ASSERT(_node != nullptr);
_node->data[_size] = 0;
return JsonString(_node->data, _size, JsonString::Copied);
ARDUINOJSON_ASSERT(node_ != nullptr);
node_->data[size_] = 0;
return JsonString(node_->data, size_, JsonString::Copied);
}
private:
MemoryPool* _pool;
StringNode* _node = nullptr;
size_t _size = 0;
MemoryPool* pool_;
StringNode* node_ = nullptr;
size_t size_ = 0;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

18
src/ArduinoJson/StringStorage/StringMover.hpp
View File

@ -11,20 +11,20 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
class StringMover {
public:
StringMover(char* ptr) : _writePtr(ptr) {}
StringMover(char* ptr) : writePtr_(ptr) {}
void startString() {
_startPtr = _writePtr;
startPtr_ = writePtr_;
}
FORCE_INLINE JsonString save() {
JsonString s = str();
_writePtr++;
writePtr_++;
return s;
}
void append(char c) {
*_writePtr++ = c;
*writePtr_++ = c;
}
bool isValid() const {
@ -32,17 +32,17 @@ class StringMover {
}
JsonString str() const {
_writePtr[0] = 0; // terminator
return JsonString(_startPtr, size(), JsonString::Linked);
writePtr_[0] = 0; // terminator
return JsonString(startPtr_, size(), JsonString::Linked);
}
size_t size() const {
return size_t(_writePtr - _startPtr);
return size_t(writePtr_ - startPtr_);
}
private:
char* _writePtr;
char* _startPtr;
char* writePtr_;
char* startPtr_;
};
ARDUINOJSON_END_PRIVATE_NAMESPACE

22
src/ArduinoJson/Strings/Adapters/FlashString.hpp
View File

@ -16,20 +16,20 @@ class FlashString {
static const size_t typeSortKey = 1;
FlashString(const __FlashStringHelper* str, size_t sz)
: _str(reinterpret_cast<const char*>(str)), _size(sz) {}
: str_(reinterpret_cast<const char*>(str)), size_(sz) {}
bool isNull() const {
return !_str;
return !str_;
}
char operator[](size_t i) const {
ARDUINOJSON_ASSERT(_str != 0);
ARDUINOJSON_ASSERT(i <= _size);
return static_cast<char>(pgm_read_byte(_str + i));
ARDUINOJSON_ASSERT(str_ != 0);
ARDUINOJSON_ASSERT(i <= size_);
return static_cast<char>(pgm_read_byte(str_ + i));
}
size_t size() const {
return _size;
return size_;
}
friend bool stringEquals(FlashString a, SizedRamString b) {
@ -38,7 +38,7 @@ class FlashString {
ARDUINOJSON_ASSERT(!b.isNull());
if (a.size() != b.size())
return false;
return ::memcmp_P(b.data(), a._str, a._size) == 0;
return ::memcmp_P(b.data(), a.str_, a.size_) == 0;
}
friend int stringCompare(FlashString a, SizedRamString b) {
@ -46,7 +46,7 @@ class FlashString {
ARDUINOJSON_ASSERT(!a.isNull());
ARDUINOJSON_ASSERT(!b.isNull());
size_t minsize = a.size() < b.size() ? a.size() : b.size();
int res = ::memcmp_P(b.data(), a._str, minsize);
int res = ::memcmp_P(b.data(), a.str_, minsize);
if (res)
return -res;
if (a.size() < b.size())
@ -58,7 +58,7 @@ class FlashString {
friend void stringGetChars(FlashString s, char* p, size_t n) {
ARDUINOJSON_ASSERT(s.size() <= n);
::memcpy_P(p, s._str, n);
::memcpy_P(p, s.str_, n);
}
StringStoragePolicy::Copy storagePolicy() const {
@ -66,8 +66,8 @@ class FlashString {
}
private:
const char* _str;
size_t _size;
const char* str_;
size_t size_;
};
template <>

6
src/ArduinoJson/Strings/Adapters/JsonString.hpp
View File

@ -13,15 +13,15 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
class JsonStringAdapter : public SizedRamString {
public:
JsonStringAdapter(const JsonString& s)
: SizedRamString(s.c_str(), s.size()), _linked(s.isLinked()) {}
: SizedRamString(s.c_str(), s.size()), linked_(s.isLinked()) {}
StringStoragePolicy::LinkOrCopy storagePolicy() const {
StringStoragePolicy::LinkOrCopy policy = {_linked};
StringStoragePolicy::LinkOrCopy policy = {linked_};
return policy;
}
private:
bool _linked;
bool linked_;
};
template <>

32
src/ArduinoJson/Strings/Adapters/RamString.hpp
View File

@ -21,31 +21,31 @@ class ZeroTerminatedRamString {
public:
static const size_t typeSortKey = 3;
ZeroTerminatedRamString(const char* str) : _str(str) {}
ZeroTerminatedRamString(const char* str) : str_(str) {}
bool isNull() const {
return !_str;
return !str_;
}
size_t size() const {
return _str ? ::strlen(_str) : 0;
return str_ ? ::strlen(str_) : 0;
}
char operator[](size_t i) const {
ARDUINOJSON_ASSERT(_str != 0);
ARDUINOJSON_ASSERT(str_ != 0);
ARDUINOJSON_ASSERT(i <= size());
return _str[i];
return str_[i];
}
const char* data() const {
return _str;
return str_;
}
friend int stringCompare(ZeroTerminatedRamString a,
ZeroTerminatedRamString b) {
ARDUINOJSON_ASSERT(!a.isNull());
ARDUINOJSON_ASSERT(!b.isNull());
return ::strcmp(a._str, b._str);
return ::strcmp(a.str_, b.str_);
}
friend bool stringEquals(ZeroTerminatedRamString a,
@ -58,7 +58,7 @@ class ZeroTerminatedRamString {
}
protected:
const char* _str;
const char* str_;
};
template <typename TChar>
@ -101,24 +101,24 @@ class SizedRamString {
public:
static const size_t typeSortKey = 2;
SizedRamString(const char* str, size_t sz) : _str(str), _size(sz) {}
SizedRamString(const char* str, size_t sz) : str_(str), size_(sz) {}
bool isNull() const {
return !_str;
return !str_;
}
size_t size() const {
return _size;
return size_;
}
char operator[](size_t i) const {
ARDUINOJSON_ASSERT(_str != 0);
ARDUINOJSON_ASSERT(str_ != 0);
ARDUINOJSON_ASSERT(i <= size());
return _str[i];
return str_[i];
}
const char* data() const {
return _str;
return str_;
}
StringStoragePolicy::Copy storagePolicy() const {
@ -126,8 +126,8 @@ class SizedRamString {
}
protected:
const char* _str;
size_t _size;
const char* str_;
size_t size_;
};
template <typename TChar>

32
src/ArduinoJson/Strings/JsonString.hpp
View File

@ -16,51 +16,51 @@ class JsonString {
public:
enum Ownership { Copied, Linked };
JsonString() : _data(0), _size(0), _ownership(Linked) {}
JsonString() : data_(0), size_(0), ownership_(Linked) {}
JsonString(const char* data, Ownership ownership = Linked)
: _data(data), _size(data ? ::strlen(data) : 0), _ownership(ownership) {}
: data_(data), size_(data ? ::strlen(data) : 0), ownership_(ownership) {}
JsonString(const char* data, size_t sz, Ownership ownership = Linked)
: _data(data), _size(sz), _ownership(ownership) {}
: data_(data), size_(sz), ownership_(ownership) {}
// Returns a pointer to the characters.
const char* c_str() const {
return _data;
return data_;
}
// Returns true if the string is null.
bool isNull() const {
return !_data;
return !data_;
}
// Returns true if the string is stored by address.
// Returns false if the string is stored by copy.
bool isLinked() const {
return _ownership == Linked;
return ownership_ == Linked;
}
// Returns length of the string.
size_t size() const {
return _size;
return size_;
}
// Returns true if the string is non-null
explicit operator bool() const {
return _data != 0;
return data_ != 0;
}
// Returns true if strings are equal.
friend bool operator==(JsonString lhs, JsonString rhs) {
if (lhs._size != rhs._size)
if (lhs.size_ != rhs.size_)
return false;
if (lhs._data == rhs._data)
if (lhs.data_ == rhs.data_)
return true;
if (!lhs._data)
if (!lhs.data_)
return false;
if (!rhs._data)
if (!rhs.data_)
return false;
return memcmp(lhs._data, rhs._data, lhs._size) == 0;
return memcmp(lhs.data_, rhs.data_, lhs.size_) == 0;
}
// Returns true if strings differs.
@ -76,9 +76,9 @@ class JsonString {
#endif
private:
const char* _data;
size_t _size;
Ownership _ownership;
const char* data_;
size_t size_;
Ownership ownership_;
};
ARDUINOJSON_END_PUBLIC_NAMESPACE

18
src/ArduinoJson/Variant/ConverterImpl.hpp
View File

@ -195,35 +195,35 @@ struct Converter<decltype(nullptr)> : private detail::VariantAttorney {
namespace detail {
class MemoryPoolPrint : public Print {
public:
MemoryPoolPrint(MemoryPool* pool) : _copier(pool) {
_copier.startString();
MemoryPoolPrint(MemoryPool* pool) : copier_(pool) {
copier_.startString();
}
JsonString str() {
ARDUINOJSON_ASSERT(!overflowed());
return _copier.save();
return copier_.save();
}
size_t write(uint8_t c) {
_copier.append(char(c));
return _copier.isValid() ? 1 : 0;
copier_.append(char(c));
return copier_.isValid() ? 1 : 0;
}
size_t write(const uint8_t* buffer, size_t size) {
for (size_t i = 0; i < size; i++) {
_copier.append(char(buffer[i]));
if (!_copier.isValid())
copier_.append(char(buffer[i]));
if (!copier_.isValid())
return i;
}
return size;
}
bool overflowed() const {
return !_copier.isValid();
return !copier_.isValid();
}
private:
StringCopier _copier;
StringCopier copier_;
};
} // namespace detail

14
src/ArduinoJson/Variant/JsonVariant.hpp
View File

@ -16,27 +16,27 @@ class JsonVariant : public detail::VariantRefBase<JsonVariant>,
public:
// Creates an unbound reference.
JsonVariant() : _data(0), _pool(0) {}
JsonVariant() : data_(0), pool_(0) {}
// INTERNAL USE ONLY
JsonVariant(detail::MemoryPool* pool, detail::VariantData* data)
: _data(data), _pool(pool) {}
: data_(data), pool_(pool) {}
private:
FORCE_INLINE detail::MemoryPool* getPool() const {
return _pool;
return pool_;
}
FORCE_INLINE detail::VariantData* getData() const {
return _data;
return data_;
}
FORCE_INLINE detail::VariantData* getOrCreateData() const {
return _data;
return data_;
}
detail::VariantData* _data;
detail::MemoryPool* _pool;
detail::VariantData* data_;
detail::MemoryPool* pool_;
};
template <>

24
src/ArduinoJson/Variant/JsonVariantConst.hpp
View File

@ -30,39 +30,39 @@ class JsonVariantConst : public detail::VariantTag,
public:
// Creates an unbound reference.
JsonVariantConst() : _data(0) {}
JsonVariantConst() : data_(0) {}
// INTERNAL USE ONLY
explicit JsonVariantConst(const detail::VariantData* data) : _data(data) {}
explicit JsonVariantConst(const detail::VariantData* data) : data_(data) {}
// Returns true if the value is null or the reference is unbound.
// https://arduinojson.org/v6/api/jsonvariantconst/isnull/
FORCE_INLINE bool isNull() const {
using namespace detail;
return variantIsNull(_data);
return variantIsNull(data_);
}
// Returns true if the reference is unbound.
FORCE_INLINE bool isUnbound() const {
return !_data;
return !data_;
}
// Returns the number of bytes occupied by the value.
// https://arduinojson.org/v6/api/jsonvariantconst/memoryusage/
FORCE_INLINE size_t memoryUsage() const {
return _data ? _data->memoryUsage() : 0;
return data_ ? data_->memoryUsage() : 0;
}
// Returns the depth (nesting level) of the value.
// https://arduinojson.org/v6/api/jsonvariantconst/nesting/
FORCE_INLINE size_t nesting() const {
return variantNesting(_data);
return variantNesting(data_);
}
// Returns the size of the array or object.
// https://arduinojson.org/v6/api/jsonvariantconst/size/
size_t size() const {
return variantSize(_data);
return variantSize(data_);
}
// Casts the value to the specified type.
@ -93,7 +93,7 @@ class JsonVariantConst : public detail::VariantTag,
// Gets array's element at specified index.
// https://arduinojson.org/v6/api/jsonvariantconst/subscript/
FORCE_INLINE JsonVariantConst operator[](size_t index) const {
return JsonVariantConst(variantGetElement(_data, index));
return JsonVariantConst(variantGetElement(data_, index));
}
// Gets object's member with specified key.
@ -102,7 +102,7 @@ class JsonVariantConst : public detail::VariantTag,
FORCE_INLINE typename detail::enable_if<detail::IsString<TString>::value,
JsonVariantConst>::type
operator[](const TString& key) const {
return JsonVariantConst(variantGetMember(_data, detail::adaptString(key)));
return JsonVariantConst(variantGetMember(data_, detail::adaptString(key)));
}
// Gets object's member with specified key.
@ -111,7 +111,7 @@ class JsonVariantConst : public detail::VariantTag,
FORCE_INLINE typename detail::enable_if<detail::IsString<TChar*>::value,
JsonVariantConst>::type
operator[](TChar* key) const {
return JsonVariantConst(variantGetMember(_data, detail::adaptString(key)));
return JsonVariantConst(variantGetMember(data_, detail::adaptString(key)));
}
// Returns true if tge object contains the specified key.
@ -134,11 +134,11 @@ class JsonVariantConst : public detail::VariantTag,
protected:
const detail::VariantData* getData() const {
return _data;
return data_;
}
private:
const detail::VariantData* _data;
const detail::VariantData* data_;
};
ARDUINOJSON_END_PUBLIC_NAMESPACE

22
src/ArduinoJson/Variant/VariantCompare.hpp
View File

@ -81,12 +81,12 @@ struct Comparer<decltype(nullptr), void> : NullComparer {
};
struct ArrayComparer : ComparerBase {
const CollectionData* _rhs;
const CollectionData* rhs_;
explicit ArrayComparer(const CollectionData& rhs) : _rhs(&rhs) {}
explicit ArrayComparer(const CollectionData& rhs) : rhs_(&rhs) {}
CompareResult visitArray(const CollectionData& lhs) {
if (JsonArrayConst(&lhs) == JsonArrayConst(_rhs))
if (JsonArrayConst(&lhs) == JsonArrayConst(rhs_))
return COMPARE_RESULT_EQUAL;
else
return COMPARE_RESULT_DIFFER;
@ -94,12 +94,12 @@ struct ArrayComparer : ComparerBase {
};
struct ObjectComparer : ComparerBase {
const CollectionData* _rhs;
const CollectionData* rhs_;
explicit ObjectComparer(const CollectionData& rhs) : _rhs(&rhs) {}
explicit ObjectComparer(const CollectionData& rhs) : rhs_(&rhs) {}
CompareResult visitObject(const CollectionData& lhs) {
if (JsonObjectConst(&lhs) == JsonObjectConst(_rhs))
if (JsonObjectConst(&lhs) == JsonObjectConst(rhs_))
return COMPARE_RESULT_EQUAL;
else
return COMPARE_RESULT_DIFFER;
@ -107,15 +107,15 @@ struct ObjectComparer : ComparerBase {
};
struct RawComparer : ComparerBase {
const char* _rhsData;
size_t _rhsSize;
const char* rhsData_;
size_t rhsSize_;
explicit RawComparer(const char* rhsData, size_t rhsSize)
: _rhsData(rhsData), _rhsSize(rhsSize) {}
: rhsData_(rhsData), rhsSize_(rhsSize) {}
CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;
int n = memcmp(lhsData, _rhsData, size);
size_t size = rhsSize_ < lhsSize ? rhsSize_ : lhsSize;
int n = memcmp(lhsData, rhsData_, size);
if (n < 0)
return COMPARE_RESULT_LESS;
else if (n > 0)

98
src/ArduinoJson/Variant/VariantData.hpp
View File

@ -13,51 +13,51 @@
ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
class VariantData {
VariantContent _content; // must be first to allow cast from array to variant
uint8_t _flags;
VariantContent content_; // must be first to allow cast from array to variant
uint8_t flags_;
public:
VariantData() : _flags(VALUE_IS_NULL) {}
VariantData() : flags_(VALUE_IS_NULL) {}
void reset() {
_flags = VALUE_IS_NULL;
flags_ = VALUE_IS_NULL;
}
void operator=(const VariantData& src) {
_content = src._content;
_flags = uint8_t((_flags & OWNED_KEY_BIT) | (src._flags & ~OWNED_KEY_BIT));
content_ = src.content_;
flags_ = uint8_t((flags_ & OWNED_KEY_BIT) | (src.flags_ & ~OWNED_KEY_BIT));
}
template <typename TVisitor>
typename TVisitor::result_type accept(TVisitor& visitor) const {
switch (type()) {
case VALUE_IS_FLOAT:
return visitor.visitFloat(_content.asFloat);
return visitor.visitFloat(content_.asFloat);
case VALUE_IS_ARRAY:
return visitor.visitArray(_content.asCollection);
return visitor.visitArray(content_.asCollection);
case VALUE_IS_OBJECT:
return visitor.visitObject(_content.asCollection);
return visitor.visitObject(content_.asCollection);
case VALUE_IS_LINKED_STRING:
case VALUE_IS_OWNED_STRING:
return visitor.visitString(_content.asString.data,
_content.asString.size);
return visitor.visitString(content_.asString.data,
content_.asString.size);
case VALUE_IS_OWNED_RAW:
case VALUE_IS_LINKED_RAW:
return visitor.visitRawJson(_content.asString.data,
_content.asString.size);
return visitor.visitRawJson(content_.asString.data,
content_.asString.size);
case VALUE_IS_SIGNED_INTEGER:
return visitor.visitSignedInteger(_content.asSignedInteger);
return visitor.visitSignedInteger(content_.asSignedInteger);
case VALUE_IS_UNSIGNED_INTEGER:
return visitor.visitUnsignedInteger(_content.asUnsignedInteger);
return visitor.visitUnsignedInteger(content_.asUnsignedInteger);
case VALUE_IS_BOOLEAN:
return visitor.visitBoolean(_content.asBoolean != 0);
return visitor.visitBoolean(content_.asBoolean != 0);
default:
return visitor.visitNull();
@ -76,14 +76,14 @@ class VariantData {
bool asBoolean() const;
const char* getOwnedString() const {
if (_flags & OWNED_VALUE_BIT)
return _content.asString.data;
if (flags_ & OWNED_VALUE_BIT)
return content_.asString.data;
else
return nullptr;
}
CollectionData* asArray() {
return isArray() ? &_content.asCollection : 0;
return isArray() ? &content_.asCollection : 0;
}
const CollectionData* asArray() const {
@ -91,11 +91,11 @@ class VariantData {
}
const CollectionData* asCollection() const {
return isCollection() ? &_content.asCollection : 0;
return isCollection() ? &content_.asCollection : 0;
}
CollectionData* asObject() {
return isObject() ? &_content.asCollection : 0;
return isObject() ? &content_.asCollection : 0;
}
const CollectionData* asObject() const {
@ -103,7 +103,7 @@ class VariantData {
}
bool isArray() const {
return (_flags & VALUE_IS_ARRAY) != 0;
return (flags_ & VALUE_IS_ARRAY) != 0;
}
bool isBoolean() const {
@ -111,17 +111,17 @@ class VariantData {
}
bool isCollection() const {
return (_flags & COLLECTION_MASK) != 0;
return (flags_ & COLLECTION_MASK) != 0;
}
template <typename T>
bool isInteger() const {
switch (type()) {
case VALUE_IS_UNSIGNED_INTEGER:
return canConvertNumber<T>(_content.asUnsignedInteger);
return canConvertNumber<T>(content_.asUnsignedInteger);
case VALUE_IS_SIGNED_INTEGER:
return canConvertNumber<T>(_content.asSignedInteger);
return canConvertNumber<T>(content_.asSignedInteger);
default:
return false;
@ -129,7 +129,7 @@ class VariantData {
}
bool isFloat() const {
return (_flags & NUMBER_BIT) != 0;
return (flags_ & NUMBER_BIT) != 0;
}
bool isString() const {
@ -137,7 +137,7 @@ class VariantData {
}
bool isObject() const {
return (_flags & VALUE_IS_OBJECT) != 0;
return (flags_ & VALUE_IS_OBJECT) != 0;
}
bool isNull() const {
@ -150,36 +150,36 @@ class VariantData {
void setBoolean(bool value) {
setType(VALUE_IS_BOOLEAN);
_content.asBoolean = value;
content_.asBoolean = value;
}
void setFloat(JsonFloat value) {
setType(VALUE_IS_FLOAT);
_content.asFloat = value;
content_.asFloat = value;
}
void setLinkedRaw(const char* data, size_t n) {
setType(VALUE_IS_LINKED_RAW);
_content.asString.data = data;
_content.asString.size = n;
content_.asString.data = data;
content_.asString.size = n;
}
void setOwnedRaw(const char* data, size_t n) {
setType(VALUE_IS_OWNED_RAW);
_content.asString.data = data;
_content.asString.size = n;
content_.asString.data = data;
content_.asString.size = n;
}
template <typename T>
typename enable_if<is_unsigned<T>::value>::type setInteger(T value) {
setType(VALUE_IS_UNSIGNED_INTEGER);
_content.asUnsignedInteger = static_cast<JsonUInt>(value);
content_.asUnsignedInteger = static_cast<JsonUInt>(value);
}
template <typename T>
typename enable_if<is_signed<T>::value>::type setInteger(T value) {
setType(VALUE_IS_SIGNED_INTEGER);
_content.asSignedInteger = value;
content_.asSignedInteger = value;
}
void setNull() {
@ -192,37 +192,37 @@ class VariantData {
setType(VALUE_IS_LINKED_STRING);
else
setType(VALUE_IS_OWNED_STRING);
_content.asString.data = s.c_str();
_content.asString.size = s.size();
content_.asString.data = s.c_str();
content_.asString.size = s.size();
}
CollectionData& toArray() {
setType(VALUE_IS_ARRAY);
_content.asCollection.clear();
return _content.asCollection;
content_.asCollection.clear();
return content_.asCollection;
}
CollectionData& toObject() {
setType(VALUE_IS_OBJECT);
_content.asCollection.clear();
return _content.asCollection;
content_.asCollection.clear();
return content_.asCollection;
}
size_t memoryUsage() const {
switch (type()) {
case VALUE_IS_OWNED_STRING:
case VALUE_IS_OWNED_RAW:
return sizeofString(_content.asString.size);
return sizeofString(content_.asString.size);
case VALUE_IS_OBJECT:
case VALUE_IS_ARRAY:
return _content.asCollection.memoryUsage();
return content_.asCollection.memoryUsage();
default:
return 0;
}
}
size_t size() const {
return isCollection() ? _content.asCollection.size() : 0;
return isCollection() ? content_.asCollection.size() : 0;
}
VariantData* getElement(size_t index) const {
@ -241,18 +241,18 @@ class VariantData {
}
void movePointers(ptrdiff_t variantDistance) {
if (_flags & COLLECTION_MASK)
_content.asCollection.movePointers(variantDistance);
if (flags_ & COLLECTION_MASK)
content_.asCollection.movePointers(variantDistance);
}
uint8_t type() const {
return _flags & VALUE_MASK;
return flags_ & VALUE_MASK;
}
private:
void setType(uint8_t t) {
_flags &= OWNED_KEY_BIT;
_flags |= t;
flags_ &= OWNED_KEY_BIT;
flags_ |= t;
}
};

34
src/ArduinoJson/Variant/VariantImpl.hpp
View File

@ -19,16 +19,16 @@ template <typename T>
inline T VariantData::asIntegral() const {
switch (type()) {
case VALUE_IS_BOOLEAN:
return _content.asBoolean;
return content_.asBoolean;
case VALUE_IS_UNSIGNED_INTEGER:
return convertNumber<T>(_content.asUnsignedInteger);
return convertNumber<T>(content_.asUnsignedInteger);
case VALUE_IS_SIGNED_INTEGER:
return convertNumber<T>(_content.asSignedInteger);
return convertNumber<T>(content_.asSignedInteger);
case VALUE_IS_LINKED_STRING:
case VALUE_IS_OWNED_STRING:
return parseNumber<T>(_content.asString.data);
return parseNumber<T>(content_.asString.data);
case VALUE_IS_FLOAT:
return convertNumber<T>(_content.asFloat);
return convertNumber<T>(content_.asFloat);
default:
return 0;
}
@ -37,12 +37,12 @@ inline T VariantData::asIntegral() const {
inline bool VariantData::asBoolean() const {
switch (type()) {
case VALUE_IS_BOOLEAN:
return _content.asBoolean;
return content_.asBoolean;
case VALUE_IS_SIGNED_INTEGER:
case VALUE_IS_UNSIGNED_INTEGER:
return _content.asUnsignedInteger != 0;
return content_.asUnsignedInteger != 0;
case VALUE_IS_FLOAT:
return _content.asFloat != 0;
return content_.asFloat != 0;
case VALUE_IS_NULL:
return false;
default:
@ -55,16 +55,16 @@ template <typename T>
inline T VariantData::asFloat() const {
switch (type()) {
case VALUE_IS_BOOLEAN:
return static_cast<T>(_content.asBoolean);
return static_cast<T>(content_.asBoolean);
case VALUE_IS_UNSIGNED_INTEGER:
return static_cast<T>(_content.asUnsignedInteger);
return static_cast<T>(content_.asUnsignedInteger);
case VALUE_IS_SIGNED_INTEGER:
return static_cast<T>(_content.asSignedInteger);
return static_cast<T>(content_.asSignedInteger);
case VALUE_IS_LINKED_STRING:
case VALUE_IS_OWNED_STRING:
return parseNumber<T>(_content.asString.data);
return parseNumber<T>(content_.asString.data);
case VALUE_IS_FLOAT:
return static_cast<T>(_content.asFloat);
return static_cast<T>(content_.asFloat);
default:
return 0;
}
@ -73,10 +73,10 @@ inline T VariantData::asFloat() const {
inline JsonString VariantData::asString() const {
switch (type()) {
case VALUE_IS_LINKED_STRING:
return JsonString(_content.asString.data, _content.asString.size,
return JsonString(content_.asString.data, content_.asString.size,
JsonString::Linked);
case VALUE_IS_OWNED_STRING:
return JsonString(_content.asString.data, _content.asString.size,
return JsonString(content_.asString.data, content_.asString.size,
JsonString::Copied);
default:
return JsonString();
@ -86,10 +86,10 @@ inline JsonString VariantData::asString() const {
inline JsonString VariantData::asRaw() const {
switch (type()) {
case VALUE_IS_LINKED_RAW:
return JsonString(_content.asString.data, _content.asString.size,
return JsonString(content_.asString.data, content_.asString.size,
JsonString::Linked);
case VALUE_IS_OWNED_RAW:
return JsonString(_content.asString.data, _content.asString.size,
return JsonString(content_.asString.data, content_.asString.size,
JsonString::Copied);
default:
return JsonString();

42
src/ArduinoJson/Variant/VariantSlot.hpp
View File

@ -17,10 +17,10 @@ class VariantSlot {
// CAUTION: same layout as VariantData
// we cannot use composition because it adds padding
// (+20% on ESP8266 for example)
VariantContent _content;
uint8_t _flags;
VariantSlotDiff _next;
const char* _key;
VariantContent content_;
uint8_t flags_;
VariantSlotDiff next_;
const char* key_;
public:
// Must be a POD!
@ -30,15 +30,15 @@ class VariantSlot {
// - no inheritance
VariantData* data() {
return reinterpret_cast<VariantData*>(&_content);
return reinterpret_cast<VariantData*>(&content_);
}
const VariantData* data() const {
return reinterpret_cast<const VariantData*>(&_content);
return reinterpret_cast<const VariantData*>(&content_);
}
VariantSlot* next() {
return _next ? this + _next : 0;
return next_ ? this + next_ : 0;
}
const VariantSlot* next() const {
@ -48,9 +48,9 @@ class VariantSlot {
VariantSlot* next(size_t distance) {
VariantSlot* slot = this;
while (distance--) {
if (!slot->_next)
if (!slot->next_)
return 0;
slot += slot->_next;
slot += slot->next_;
}
return slot;
}
@ -64,7 +64,7 @@ class VariantSlot {
numeric_limits<VariantSlotDiff>::lowest());
ARDUINOJSON_ASSERT(!slot || slot - this <=
numeric_limits<VariantSlotDiff>::highest());
_next = VariantSlotDiff(slot ? slot - this : 0);
next_ = VariantSlotDiff(slot ? slot - this : 0);
}
void setNextNotNull(VariantSlot* slot) {
@ -73,35 +73,35 @@ class VariantSlot {
numeric_limits<VariantSlotDiff>::lowest());
ARDUINOJSON_ASSERT(slot - this <=
numeric_limits<VariantSlotDiff>::highest());
_next = VariantSlotDiff(slot - this);
next_ = VariantSlotDiff(slot - this);
}
void setKey(JsonString k) {
ARDUINOJSON_ASSERT(k);
if (k.isLinked())
_flags &= VALUE_MASK;
flags_ &= VALUE_MASK;
else
_flags |= OWNED_KEY_BIT;
_key = k.c_str();
flags_ |= OWNED_KEY_BIT;
key_ = k.c_str();
}
const char* key() const {
return _key;
return key_;
}
bool ownsKey() const {
return (_flags & OWNED_KEY_BIT) != 0;
return (flags_ & OWNED_KEY_BIT) != 0;
}
void clear() {
_next = 0;
_flags = 0;
_key = 0;
next_ = 0;
flags_ = 0;
key_ = 0;
}
void movePointers(ptrdiff_t variantDistance) {
if (_flags & COLLECTION_MASK)
_content.asCollection.movePointers(variantDistance);
if (flags_ & COLLECTION_MASK)
content_.asCollection.movePointers(variantDistance);
}
};