From dd46813dc03fdd153ecc0a240d0bdf120502cee7 Mon Sep 17 00:00:00 2001 From: Benoit Blanchon Date: Fri, 21 Apr 2023 18:53:16 +0200 Subject: [PATCH] Change naming convention from `_member` to `member_` (fixes #1905) Ported from 31ce648e63160f2470308b9cbb47316be60dff13 --- extras/tests/Helpers/Allocators.hpp | 68 ++++----- extras/tests/Helpers/CustomReader.hpp | 10 +- extras/tests/Helpers/api/String.h | 28 ++-- extras/tests/JsonSerializer/CustomWriter.cpp | 8 +- extras/tests/JsonVariant/converters.cpp | 8 +- extras/tests/Misc/Readers.cpp | 10 +- extras/tests/Misc/conflicts.cpp | 3 + extras/tests/Misc/printable.cpp | 12 +- src/ArduinoJson/Array/ElementProxy.hpp | 16 +-- src/ArduinoJson/Array/JsonArray.hpp | 48 +++---- src/ArduinoJson/Array/JsonArrayConst.hpp | 30 ++-- src/ArduinoJson/Array/JsonArrayIterator.hpp | 54 ++++---- src/ArduinoJson/Collection/CollectionData.hpp | 6 +- src/ArduinoJson/Collection/CollectionImpl.hpp | 36 ++--- .../Deserialization/DeserializationError.hpp | 26 ++-- src/ArduinoJson/Deserialization/Filter.hpp | 18 +-- .../Deserialization/NestingLimit.hpp | 12 +- src/ArduinoJson/Deserialization/Reader.hpp | 8 +- .../Readers/ArduinoStreamReader.hpp | 10 +- .../Deserialization/Readers/FlashReader.hpp | 26 ++-- .../Readers/IteratorReader.hpp | 12 +- .../Deserialization/Readers/RamReader.hpp | 8 +- .../Readers/StdStreamReader.hpp | 10 +- src/ArduinoJson/Document/JsonDocument.hpp | 64 ++++----- src/ArduinoJson/Json/JsonDeserializer.hpp | 60 ++++---- src/ArduinoJson/Json/JsonSerializer.hpp | 28 ++-- src/ArduinoJson/Json/Latch.hpp | 30 ++-- src/ArduinoJson/Json/PrettyJsonSerializer.hpp | 14 +- src/ArduinoJson/Json/TextFormatter.hpp | 16 +-- src/ArduinoJson/Json/Utf16.hpp | 16 +-- src/ArduinoJson/Memory/MemoryPool.hpp | 130 +++++++++--------- src/ArduinoJson/Misc/SerializedValue.hpp | 22 +-- .../MsgPack/MsgPackDeserializer.hpp | 42 +++--- src/ArduinoJson/MsgPack/MsgPackSerializer.hpp | 10 +- src/ArduinoJson/Object/JsonObject.hpp | 54 ++++---- src/ArduinoJson/Object/JsonObjectConst.hpp | 36 ++--- src/ArduinoJson/Object/JsonObjectIterator.hpp | 54 ++++---- src/ArduinoJson/Object/JsonPair.hpp | 24 ++-- src/ArduinoJson/Object/MemberProxy.hpp | 20 +-- .../Polyfills/pgmspace_generic.hpp | 6 +- .../Polyfills/type_traits/is_convertible.hpp | 4 +- .../Serialization/CountingDecorator.hpp | 12 +- src/ArduinoJson/Serialization/Writer.hpp | 8 +- .../Writers/ArduinoStringWriter.hpp | 24 ++-- .../Serialization/Writers/PrintWriter.hpp | 8 +- .../Serialization/Writers/StdStreamWriter.hpp | 8 +- .../Serialization/Writers/StdStringWriter.hpp | 8 +- .../StringStorage/StringCopier.hpp | 48 +++---- src/ArduinoJson/StringStorage/StringMover.hpp | 18 +-- .../Strings/Adapters/FlashString.hpp | 22 +-- .../Strings/Adapters/JsonString.hpp | 6 +- .../Strings/Adapters/RamString.hpp | 32 ++--- src/ArduinoJson/Strings/JsonString.hpp | 32 ++--- src/ArduinoJson/Variant/ConverterImpl.hpp | 18 +-- src/ArduinoJson/Variant/JsonVariant.hpp | 14 +- src/ArduinoJson/Variant/JsonVariantConst.hpp | 24 ++-- src/ArduinoJson/Variant/VariantCompare.hpp | 22 +-- src/ArduinoJson/Variant/VariantData.hpp | 98 ++++++------- src/ArduinoJson/Variant/VariantImpl.hpp | 34 ++--- src/ArduinoJson/Variant/VariantSlot.hpp | 42 +++--- 60 files changed, 789 insertions(+), 786 deletions(-) diff --git a/extras/tests/Helpers/Allocators.hpp b/extras/tests/Helpers/Allocators.hpp index 862a5426..4a44b746 100644 --- a/extras/tests/Helpers/Allocators.hpp +++ b/extras/tests/Helpers/Allocators.hpp @@ -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( - _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( - _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_; }; diff --git a/extras/tests/Helpers/CustomReader.hpp b/extras/tests/Helpers/CustomReader.hpp index da19d3fb..66525a25 100644 --- a/extras/tests/Helpers/CustomReader.hpp +++ b/extras/tests/Helpers/CustomReader.hpp @@ -7,18 +7,18 @@ #include 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(length)); - return static_cast(_stream.gcount()); + stream_.read(buffer, static_cast(length)); + return static_cast(stream_.gcount()); } }; diff --git a/extras/tests/Helpers/api/String.h b/extras/tests/Helpers/api/String.h index 64c763f9..560fed94 100644 --- a/extras/tests/Helpers/api/String.h +++ b/extras/tests/Helpers/api/String.h @@ -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 {}; diff --git a/extras/tests/JsonSerializer/CustomWriter.cpp b/extras/tests/JsonSerializer/CustomWriter.cpp index 02a5452d..ffd87ee2 100644 --- a/extras/tests/JsonSerializer/CustomWriter.cpp +++ b/extras/tests/JsonSerializer/CustomWriter.cpp @@ -12,21 +12,21 @@ class CustomWriter { CustomWriter& operator=(const CustomWriter&) = delete; size_t write(uint8_t c) { - _str.append(1, static_cast(c)); + str_.append(1, static_cast(c)); return 1; } size_t write(const uint8_t* s, size_t n) { - _str.append(reinterpret_cast(s), n); + str_.append(reinterpret_cast(s), n); return n; } const std::string& str() const { - return _str; + return str_; } private: - std::string _str; + std::string str_; }; TEST_CASE("CustomWriter") { diff --git a/extras/tests/JsonVariant/converters.cpp b/extras/tests/JsonVariant/converters.cpp index 409b2438..7603c421 100644 --- a/extras/tests/JsonVariant/converters.cpp +++ b/extras/tests/JsonVariant/converters.cpp @@ -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 { diff --git a/extras/tests/Misc/Readers.cpp b/extras/tests/Misc/Readers.cpp index bd04e16e..0b8f4d50 100644 --- a/extras/tests/Misc/Readers.cpp +++ b/extras/tests/Misc/Readers.cpp @@ -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(length)); - return static_cast(_stream.gcount()); + stream_.read(buffer, static_cast(length)); + return static_cast(stream_.gcount()); } private: - std::istringstream _stream; + std::istringstream stream_; }; TEST_CASE("Reader") { diff --git a/extras/tests/Misc/conflicts.cpp b/extras/tests/Misc/conflicts.cpp index 09566825..2e33ea10 100644 --- a/extras/tests/Misc/conflicts.cpp +++ b/extras/tests/Misc/conflicts.cpp @@ -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" diff --git a/extras/tests/Misc/printable.cpp b/extras/tests/Misc/printable.cpp index 0adabbee..7ea0f4b7 100644 --- a/extras/tests/Misc/printable.cpp +++ b/extras/tests/Misc/printable.cpp @@ -34,21 +34,21 @@ struct PrintAllAtOnce { template 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") { diff --git a/src/ArduinoJson/Array/ElementProxy.hpp b/src/ArduinoJson/Array/ElementProxy.hpp index 1a9e9ce2..d6e9aa5d 100644 --- a/src/ArduinoJson/Array/ElementProxy.hpp +++ b/src/ArduinoJson/Array/ElementProxy.hpp @@ -17,10 +17,10 @@ class ElementProxy : public VariantRefBase>, 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>, 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 diff --git a/src/ArduinoJson/Array/JsonArray.hpp b/src/ArduinoJson/Array/JsonArray.hpp index 96c04a0e..06e3cc1b 100644 --- a/src/ArduinoJson/Array/JsonArray.hpp +++ b/src/ArduinoJson/Array/JsonArray.hpp @@ -21,30 +21,30 @@ class JsonArray : public detail::VariantOperators { 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(data)); + void* data = data_; // prevent warning cast-align + return JsonVariant(pool_, reinterpret_cast(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 { // 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 { // 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 { } 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 <> diff --git a/src/ArduinoJson/Array/JsonArrayConst.hpp b/src/ArduinoJson/Array/JsonArrayConst.hpp index 9c1be822..ad951f1a 100644 --- a/src/ArduinoJson/Array/JsonArrayConst.hpp +++ b/src/ArduinoJson/Array/JsonArrayConst.hpp @@ -24,9 +24,9 @@ class JsonArrayConst : public detail::VariantOperators { // 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 { } // 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 { // 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 <> diff --git a/src/ArduinoJson/Array/JsonArrayIterator.hpp b/src/ArduinoJson/Array/JsonArrayIterator.hpp index 3e1b7526..d9048b28 100644 --- a/src/ArduinoJson/Array/JsonArrayIterator.hpp +++ b/src/ArduinoJson/Array/JsonArrayIterator.hpp @@ -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 diff --git a/src/ArduinoJson/Collection/CollectionData.hpp b/src/ArduinoJson/Collection/CollectionData.hpp index 3b7c3aae..1ba09b1c 100644 --- a/src/ArduinoJson/Collection/CollectionData.hpp +++ b/src/ArduinoJson/Collection/CollectionData.hpp @@ -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); diff --git a/src/ArduinoJson/Collection/CollectionImpl.hpp b/src/ArduinoJson/Collection/CollectionImpl.hpp index 9470cd59..d9757744 100644 --- a/src/ArduinoJson/Collection/CollectionImpl.hpp +++ b/src/ArduinoJson/Collection/CollectionImpl.hpp @@ -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 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 @@ -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); } diff --git a/src/ArduinoJson/Deserialization/DeserializationError.hpp b/src/ArduinoJson/Deserialization/DeserializationError.hpp index 2e97a024..1bfc3939 100644 --- a/src/ArduinoJson/Deserialization/DeserializationError.hpp +++ b/src/ArduinoJson/Deserialization/DeserializationError.hpp @@ -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(_code) < + ARDUINOJSON_ASSERT(static_cast(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( - detail::pgm_read(messages + _code)); + detail::pgm_read(messages + code_)); } #endif private: - Code _code; + Code code_; }; #if ARDUINOJSON_ENABLE_STD_STREAM diff --git a/src/ArduinoJson/Deserialization/Filter.hpp b/src/ArduinoJson/Deserialization/Filter.hpp index 8857cedf..39883027 100644 --- a/src/ArduinoJson/Deserialization/Filter.hpp +++ b/src/ArduinoJson/Deserialization/Filter.hpp @@ -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(); + return variant_ == true || variant_.is(); } bool allowObject() const { - return _variant == true || _variant.is(); + return variant_ == true || variant_.is(); } bool allowValue() const { - return _variant == true; + return variant_ == true; } template 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 diff --git a/src/ArduinoJson/Deserialization/NestingLimit.hpp b/src/ArduinoJson/Deserialization/NestingLimit.hpp index 6d2f6754..6434275b 100644 --- a/src/ArduinoJson/Deserialization/NestingLimit.hpp +++ b/src/ArduinoJson/Deserialization/NestingLimit.hpp @@ -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(_value - 1)); + ARDUINOJSON_ASSERT(value_ > 0); + return NestingLimit(static_cast(value_ - 1)); } bool reached() const { - return _value == 0; + return value_ == 0; } private: - uint8_t _value; + uint8_t value_; }; } // namespace DeserializationOption diff --git a/src/ArduinoJson/Deserialization/Reader.hpp b/src/ArduinoJson/Deserialization/Reader.hpp index e52af6d5..5f18c7b3 100644 --- a/src/ArduinoJson/Deserialization/Reader.hpp +++ b/src/ArduinoJson/Deserialization/Reader.hpp @@ -15,18 +15,18 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE template 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 diff --git a/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp b/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp index ac4f212d..580879fd 100644 --- a/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp +++ b/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp @@ -12,20 +12,20 @@ template struct Reader::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(c) : -1; + return stream_->readBytes(&c, 1) ? static_cast(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 diff --git a/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp b/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp index da6880de..df2314ef 100644 --- a/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp +++ b/src/ArduinoJson/Deserialization/Readers/FlashReader.hpp @@ -10,45 +10,45 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE template <> struct Reader { - const char* _ptr; + const char* ptr_; public: explicit Reader(const __FlashStringHelper* ptr) - : _ptr(reinterpret_cast(ptr)) {} + : ptr_(reinterpret_cast(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 char* _ptr; - const char* _end; + const char* ptr_; + const char* end_; public: explicit BoundedReader(const __FlashStringHelper* ptr, size_t size) - : _ptr(reinterpret_cast(ptr)), _end(_ptr + size) {} + : ptr_(reinterpret_cast(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(_end - _ptr); + size_t available = static_cast(end_ - ptr_); if (available < length) length = available; - memcpy_P(buffer, _ptr, length); - _ptr += length; + memcpy_P(buffer, ptr_, length); + ptr_ += length; return length; } }; diff --git a/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp b/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp index 71890798..c0ca4a77 100644 --- a/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp +++ b/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp @@ -8,23 +8,23 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE template 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(*_ptr++); + if (ptr_ < end_) + return static_cast(*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; } }; diff --git a/src/ArduinoJson/Deserialization/Readers/RamReader.hpp b/src/ArduinoJson/Deserialization/Readers/RamReader.hpp index 78d01995..eff67bac 100644 --- a/src/ArduinoJson/Deserialization/Readers/RamReader.hpp +++ b/src/ArduinoJson/Deserialization/Readers/RamReader.hpp @@ -21,19 +21,19 @@ struct IsCharOrVoid : IsCharOrVoid {}; template struct Reader::value>::type> { - const char* _ptr; + const char* ptr_; public: explicit Reader(const void* ptr) - : _ptr(ptr ? reinterpret_cast(ptr) : "") {} + : ptr_(ptr ? reinterpret_cast(ptr) : "") {} int read() { - return static_cast(*_ptr++); + return static_cast(*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; } }; diff --git a/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp b/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp index ecace426..41e0c00a 100644 --- a/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp +++ b/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp @@ -12,19 +12,19 @@ template struct Reader::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(length)); - return static_cast(_stream->gcount()); + stream_->read(buffer, static_cast(length)); + return static_cast(stream_->gcount()); } private: - std::istream* _stream; + std::istream* stream_; }; ARDUINOJSON_END_PRIVATE_NAMESPACE diff --git a/src/ArduinoJson/Document/JsonDocument.hpp b/src/ArduinoJson/Document/JsonDocument.hpp index 4802ece2..4957fb42 100644 --- a/src/ArduinoJson/Document/JsonDocument.hpp +++ b/src/ArduinoJson/Document/JsonDocument.hpp @@ -24,16 +24,16 @@ class JsonDocument : public detail::VariantOperators { 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 { template 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 { 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 { // 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 { // 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 { // https://arduinojson.org/v6/api/jsondocument/containskey/ template 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 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 { FORCE_INLINE typename detail::enable_if::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 { FORCE_INLINE typename detail::enable_if::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 { // 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 { 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) { diff --git a/src/ArduinoJson/Json/JsonDeserializer.hpp b/src/ArduinoJson/Json/JsonDeserializer.hpp index 6f4dc6dc..d90dc41c 100644 --- a/src/ArduinoJson/Json/JsonDeserializer.hpp +++ b/src/ArduinoJson/Json/JsonDeserializer.hpp @@ -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 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 _latch; - MemoryPool* _pool; - char _buffer[64]; // using a member instead of a local variable because it + TStringStorage stringStorage_; + bool foundSomething_; + Latch 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 }; diff --git a/src/ArduinoJson/Json/JsonSerializer.hpp b/src/ArduinoJson/Json/JsonSerializer.hpp index e5c263a3..781c9c93 100644 --- a/src/ArduinoJson/Json/JsonSerializer.hpp +++ b/src/ArduinoJson/Json/JsonSerializer.hpp @@ -16,7 +16,7 @@ class JsonSerializer : public Visitor { 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 { 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 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 _formatter; + TextFormatter formatter_; }; ARDUINOJSON_END_PRIVATE_NAMESPACE diff --git a/src/ArduinoJson/Json/Latch.hpp b/src/ArduinoJson/Json/Latch.hpp index b36571e8..08070eb3 100644 --- a/src/ArduinoJson/Json/Latch.hpp +++ b/src/ArduinoJson/Json/Latch.hpp @@ -11,45 +11,45 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE template 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(c > 0 ? c : 0); - _loaded = true; + current_ = static_cast(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 }; diff --git a/src/ArduinoJson/Json/PrettyJsonSerializer.hpp b/src/ArduinoJson/Json/PrettyJsonSerializer.hpp index 974ade37..e8a92064 100644 --- a/src/ArduinoJson/Json/PrettyJsonSerializer.hpp +++ b/src/ArduinoJson/Json/PrettyJsonSerializer.hpp @@ -16,13 +16,13 @@ class PrettyJsonSerializer : public JsonSerializer { typedef JsonSerializer 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 { slot = slot->next(); base::write(slot ? ",\r\n" : "\r\n"); } - _nesting--; + nesting_--; indent(); base::write("]"); } else { @@ -43,7 +43,7 @@ class PrettyJsonSerializer : public JsonSerializer { 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 { slot = slot->next(); base::write(slot ? ",\r\n" : "\r\n"); } - _nesting--; + nesting_--; indent(); base::write("}"); } else { @@ -64,11 +64,11 @@ class PrettyJsonSerializer : public JsonSerializer { 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 diff --git a/src/ArduinoJson/Json/TextFormatter.hpp b/src/ArduinoJson/Json/TextFormatter.hpp index 6e319aa5..f8eb2822 100644 --- a/src/ArduinoJson/Json/TextFormatter.hpp +++ b/src/ArduinoJson/Json/TextFormatter.hpp @@ -20,13 +20,13 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE template 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(s), strlen(s)); + writer_.write(reinterpret_cast(s), strlen(s)); } void writeRaw(const char* s, size_t n) { - _writer.write(reinterpret_cast(s), n); + writer_.write(reinterpret_cast(s), n); } void writeRaw(const char* begin, const char* end) { - _writer.write(reinterpret_cast(begin), + writer_.write(reinterpret_cast(begin), static_cast(end - begin)); } template void writeRaw(const char (&s)[N]) { - _writer.write(reinterpret_cast(s), N - 1); + writer_.write(reinterpret_cast(s), N - 1); } void writeRaw(char c) { - _writer.write(static_cast(c)); + writer_.write(static_cast(c)); } protected: - CountingDecorator _writer; + CountingDecorator writer_; }; ARDUINOJSON_END_PRIVATE_NAMESPACE diff --git a/src/ArduinoJson/Json/Utf16.hpp b/src/ArduinoJson/Json/Utf16.hpp index ad22204f..6e314db2 100644 --- a/src/ArduinoJson/Json/Utf16.hpp +++ b/src/ArduinoJson/Json/Utf16.hpp @@ -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 diff --git a/src/ArduinoJson/Memory/MemoryPool.hpp b/src/ArduinoJson/Memory/MemoryPool.hpp index ee2f7402..af90addf 100644 --- a/src/ArduinoJson/Memory/MemoryPool.hpp +++ b/src/ArduinoJson/Memory/MemoryPool.hpp @@ -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 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( - _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( - _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(new_ptr) - static_cast(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(_end - _right); - memmove(new_right, _right, right_size); + size_t right_size = static_cast(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(_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(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 diff --git a/src/ArduinoJson/Misc/SerializedValue.hpp b/src/ArduinoJson/Misc/SerializedValue.hpp index 311f0d25..ae9abd3c 100644 --- a/src/ArduinoJson/Misc/SerializedValue.hpp +++ b/src/ArduinoJson/Misc/SerializedValue.hpp @@ -12,43 +12,43 @@ ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE template 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 class SerializedValue { 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 diff --git a/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp b/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp index 839c2c64..eb4a6980 100644 --- a/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp +++ b/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp @@ -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 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(c); @@ -232,7 +232,7 @@ class MsgPackDeserializer { } DeserializationError::Code readBytes(uint8_t* p, size_t n) { - if (_reader.readBytes(reinterpret_cast(p), n) == n) + if (reader_.readBytes(reinterpret_cast(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(c)); + stringStorage_.append(static_cast(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 diff --git a/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp b/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp index 45bf5fc8..65769a16 100644 --- a/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp +++ b/src/ArduinoJson/MsgPack/MsgPackSerializer.hpp @@ -19,7 +19,7 @@ class MsgPackSerializer : public Visitor { public: static const bool producesText = false; - MsgPackSerializer(TWriter writer) : _writer(writer) {} + MsgPackSerializer(TWriter writer) : writer_(writer) {} template typename enable_if::type visitFloat(T value32) { @@ -177,15 +177,15 @@ class MsgPackSerializer : public Visitor { 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 @@ -194,7 +194,7 @@ class MsgPackSerializer : public Visitor { writeBytes(reinterpret_cast(&value), sizeof(value)); } - CountingDecorator _writer; + CountingDecorator writer_; }; ARDUINOJSON_END_PRIVATE_NAMESPACE diff --git a/src/ArduinoJson/Object/JsonObject.hpp b/src/ArduinoJson/Object/JsonObject.hpp index 0c9cd9e2..42cf5ffd 100644 --- a/src/ArduinoJson/Object/JsonObject.hpp +++ b/src/ArduinoJson/Object/JsonObject.hpp @@ -20,61 +20,61 @@ class JsonObject : public detail::VariantOperators { 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(data)); + void* data = data_; // prevent warning cast-align + return JsonVariant(pool_, reinterpret_cast(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 { // ⚠️ 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 { // ⚠️ 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 { // https://arduinojson.org/v6/api/jsonobject/remove/ template 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 { // https://arduinojson.org/v6/api/jsonobject/remove/ template 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 { FORCE_INLINE typename detail::enable_if::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 { FORCE_INLINE typename detail::enable_if::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 { 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 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 <> diff --git a/src/ArduinoJson/Object/JsonObjectConst.hpp b/src/ArduinoJson/Object/JsonObjectConst.hpp index a72cad30..3495b07b 100644 --- a/src/ArduinoJson/Object/JsonObjectConst.hpp +++ b/src/ArduinoJson/Object/JsonObjectConst.hpp @@ -19,51 +19,51 @@ class JsonObjectConst : public detail::VariantOperators { 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 { // https://arduinojson.org/v6/api/jsonobjectconst/containskey/ template 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 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 { 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 { 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 { private: const detail::VariantData* getData() const { - return collectionToVariant(_data); + return collectionToVariant(data_); } - const detail::CollectionData* _data; + const detail::CollectionData* data_; }; template <> diff --git a/src/ArduinoJson/Object/JsonObjectIterator.hpp b/src/ArduinoJson/Object/JsonObjectIterator.hpp index defcc109..55c09ed7 100644 --- a/src/ArduinoJson/Object/JsonObjectIterator.hpp +++ b/src/ArduinoJson/Object/JsonObjectIterator.hpp @@ -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 diff --git a/src/ArduinoJson/Object/JsonPair.hpp b/src/ArduinoJson/Object/JsonPair.hpp index e1a92022..862a6579 100644 --- a/src/ArduinoJson/Object/JsonPair.hpp +++ b/src/ArduinoJson/Object/JsonPair.hpp @@ -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 diff --git a/src/ArduinoJson/Object/MemberProxy.hpp b/src/ArduinoJson/Object/MemberProxy.hpp index 6d397db7..78e5a521 100644 --- a/src/ArduinoJson/Object/MemberProxy.hpp +++ b/src/ArduinoJson/Object/MemberProxy.hpp @@ -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 diff --git a/src/ArduinoJson/Polyfills/pgmspace_generic.hpp b/src/ArduinoJson/Polyfills/pgmspace_generic.hpp index 750bb438..dc47581f 100644 --- a/src/ArduinoJson/Polyfills/pgmspace_generic.hpp +++ b/src/ArduinoJson/Polyfills/pgmspace_generic.hpp @@ -54,14 +54,14 @@ inline T pgm_read(const T* p) { template 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 diff --git a/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp b/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp index 22d4a065..7c4810f3 100644 --- a/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp +++ b/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp @@ -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 diff --git a/src/ArduinoJson/Serialization/CountingDecorator.hpp b/src/ArduinoJson/Serialization/CountingDecorator.hpp index 767d5ace..b38a22df 100644 --- a/src/ArduinoJson/Serialization/CountingDecorator.hpp +++ b/src/ArduinoJson/Serialization/CountingDecorator.hpp @@ -11,23 +11,23 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE template 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 diff --git a/src/ArduinoJson/Serialization/Writer.hpp b/src/ArduinoJson/Serialization/Writer.hpp index 3d18c97b..f6ba225d 100644 --- a/src/ArduinoJson/Serialization/Writer.hpp +++ b/src/ArduinoJson/Serialization/Writer.hpp @@ -12,18 +12,18 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE template 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 diff --git a/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp b/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp index 89440cc0..c6432487 100644 --- a/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp +++ b/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp @@ -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(c); + buffer_[size_++] = static_cast(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 diff --git a/src/ArduinoJson/Serialization/Writers/PrintWriter.hpp b/src/ArduinoJson/Serialization/Writers/PrintWriter.hpp index e4da4221..49f6a6e9 100644 --- a/src/ArduinoJson/Serialization/Writers/PrintWriter.hpp +++ b/src/ArduinoJson/Serialization/Writers/PrintWriter.hpp @@ -13,18 +13,18 @@ class Writer< TDestination, typename enable_if::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 diff --git a/src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp b/src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp index 36d0c5bc..fdfead73 100644 --- a/src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp +++ b/src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp @@ -13,21 +13,21 @@ class Writer< TDestination, typename enable_if::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(c)); + os_->put(static_cast(c)); return 1; } size_t write(const uint8_t* s, size_t n) { - _os->write(reinterpret_cast(s), + os_->write(reinterpret_cast(s), static_cast(n)); return n; } private: - std::ostream* _os; + std::ostream* os_; }; ARDUINOJSON_END_PRIVATE_NAMESPACE diff --git a/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp b/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp index eb9dd3f1..1f8afaa8 100644 --- a/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp +++ b/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp @@ -24,20 +24,20 @@ template class Writer::value>::type> { public: - Writer(TDestination& str) : _str(&str) {} + Writer(TDestination& str) : str_(&str) {} size_t write(uint8_t c) { - _str->push_back(static_cast(c)); + str_->push_back(static_cast(c)); return 1; } size_t write(const uint8_t* s, size_t n) { - _str->append(reinterpret_cast(s), n); + str_->append(reinterpret_cast(s), n); return n; } private: - TDestination* _str; + TDestination* str_; }; ARDUINOJSON_END_PRIVATE_NAMESPACE diff --git a/src/ArduinoJson/StringStorage/StringCopier.hpp b/src/ArduinoJson/StringStorage/StringCopier.hpp index 4e451d39..449ce253 100644 --- a/src/ArduinoJson/StringStorage/StringCopier.hpp +++ b/src/ArduinoJson/StringStorage/StringCopier.hpp @@ -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 diff --git a/src/ArduinoJson/StringStorage/StringMover.hpp b/src/ArduinoJson/StringStorage/StringMover.hpp index a70565cb..584b2531 100644 --- a/src/ArduinoJson/StringStorage/StringMover.hpp +++ b/src/ArduinoJson/StringStorage/StringMover.hpp @@ -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 diff --git a/src/ArduinoJson/Strings/Adapters/FlashString.hpp b/src/ArduinoJson/Strings/Adapters/FlashString.hpp index 96ef60df..eaffe7e3 100644 --- a/src/ArduinoJson/Strings/Adapters/FlashString.hpp +++ b/src/ArduinoJson/Strings/Adapters/FlashString.hpp @@ -16,20 +16,20 @@ class FlashString { static const size_t typeSortKey = 1; FlashString(const __FlashStringHelper* str, size_t sz) - : _str(reinterpret_cast(str)), _size(sz) {} + : str_(reinterpret_cast(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(pgm_read_byte(_str + i)); + ARDUINOJSON_ASSERT(str_ != 0); + ARDUINOJSON_ASSERT(i <= size_); + return static_cast(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 <> diff --git a/src/ArduinoJson/Strings/Adapters/JsonString.hpp b/src/ArduinoJson/Strings/Adapters/JsonString.hpp index 926b9f0e..5db7c208 100644 --- a/src/ArduinoJson/Strings/Adapters/JsonString.hpp +++ b/src/ArduinoJson/Strings/Adapters/JsonString.hpp @@ -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 <> diff --git a/src/ArduinoJson/Strings/Adapters/RamString.hpp b/src/ArduinoJson/Strings/Adapters/RamString.hpp index f2f6a3f6..12c67c94 100644 --- a/src/ArduinoJson/Strings/Adapters/RamString.hpp +++ b/src/ArduinoJson/Strings/Adapters/RamString.hpp @@ -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 @@ -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 diff --git a/src/ArduinoJson/Strings/JsonString.hpp b/src/ArduinoJson/Strings/JsonString.hpp index 0914200e..538dbc8a 100644 --- a/src/ArduinoJson/Strings/JsonString.hpp +++ b/src/ArduinoJson/Strings/JsonString.hpp @@ -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 diff --git a/src/ArduinoJson/Variant/ConverterImpl.hpp b/src/ArduinoJson/Variant/ConverterImpl.hpp index 32bdc9ee..c94387e3 100644 --- a/src/ArduinoJson/Variant/ConverterImpl.hpp +++ b/src/ArduinoJson/Variant/ConverterImpl.hpp @@ -195,35 +195,35 @@ struct Converter : 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 diff --git a/src/ArduinoJson/Variant/JsonVariant.hpp b/src/ArduinoJson/Variant/JsonVariant.hpp index 690b38df..d1f122e9 100644 --- a/src/ArduinoJson/Variant/JsonVariant.hpp +++ b/src/ArduinoJson/Variant/JsonVariant.hpp @@ -16,27 +16,27 @@ class JsonVariant : public detail::VariantRefBase, 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 <> diff --git a/src/ArduinoJson/Variant/JsonVariantConst.hpp b/src/ArduinoJson/Variant/JsonVariantConst.hpp index 9b1913b5..606df083 100644 --- a/src/ArduinoJson/Variant/JsonVariantConst.hpp +++ b/src/ArduinoJson/Variant/JsonVariantConst.hpp @@ -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::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::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 diff --git a/src/ArduinoJson/Variant/VariantCompare.hpp b/src/ArduinoJson/Variant/VariantCompare.hpp index bb60b8a4..42445c6b 100644 --- a/src/ArduinoJson/Variant/VariantCompare.hpp +++ b/src/ArduinoJson/Variant/VariantCompare.hpp @@ -81,12 +81,12 @@ struct Comparer : 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) diff --git a/src/ArduinoJson/Variant/VariantData.hpp b/src/ArduinoJson/Variant/VariantData.hpp index ffe6d5aa..7685c60e 100644 --- a/src/ArduinoJson/Variant/VariantData.hpp +++ b/src/ArduinoJson/Variant/VariantData.hpp @@ -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::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 bool isInteger() const { switch (type()) { case VALUE_IS_UNSIGNED_INTEGER: - return canConvertNumber(_content.asUnsignedInteger); + return canConvertNumber(content_.asUnsignedInteger); case VALUE_IS_SIGNED_INTEGER: - return canConvertNumber(_content.asSignedInteger); + return canConvertNumber(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 enable_if::value>::type setInteger(T value) { setType(VALUE_IS_UNSIGNED_INTEGER); - _content.asUnsignedInteger = static_cast(value); + content_.asUnsignedInteger = static_cast(value); } template typename enable_if::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; } }; diff --git a/src/ArduinoJson/Variant/VariantImpl.hpp b/src/ArduinoJson/Variant/VariantImpl.hpp index ef5c4ab8..0d55dff8 100644 --- a/src/ArduinoJson/Variant/VariantImpl.hpp +++ b/src/ArduinoJson/Variant/VariantImpl.hpp @@ -19,16 +19,16 @@ template inline T VariantData::asIntegral() const { switch (type()) { case VALUE_IS_BOOLEAN: - return _content.asBoolean; + return content_.asBoolean; case VALUE_IS_UNSIGNED_INTEGER: - return convertNumber(_content.asUnsignedInteger); + return convertNumber(content_.asUnsignedInteger); case VALUE_IS_SIGNED_INTEGER: - return convertNumber(_content.asSignedInteger); + return convertNumber(content_.asSignedInteger); case VALUE_IS_LINKED_STRING: case VALUE_IS_OWNED_STRING: - return parseNumber(_content.asString.data); + return parseNumber(content_.asString.data); case VALUE_IS_FLOAT: - return convertNumber(_content.asFloat); + return convertNumber(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 inline T VariantData::asFloat() const { switch (type()) { case VALUE_IS_BOOLEAN: - return static_cast(_content.asBoolean); + return static_cast(content_.asBoolean); case VALUE_IS_UNSIGNED_INTEGER: - return static_cast(_content.asUnsignedInteger); + return static_cast(content_.asUnsignedInteger); case VALUE_IS_SIGNED_INTEGER: - return static_cast(_content.asSignedInteger); + return static_cast(content_.asSignedInteger); case VALUE_IS_LINKED_STRING: case VALUE_IS_OWNED_STRING: - return parseNumber(_content.asString.data); + return parseNumber(content_.asString.data); case VALUE_IS_FLOAT: - return static_cast(_content.asFloat); + return static_cast(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(); diff --git a/src/ArduinoJson/Variant/VariantSlot.hpp b/src/ArduinoJson/Variant/VariantSlot.hpp index cd35abd2..5bffba5d 100644 --- a/src/ArduinoJson/Variant/VariantSlot.hpp +++ b/src/ArduinoJson/Variant/VariantSlot.hpp @@ -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(&_content); + return reinterpret_cast(&content_); } const VariantData* data() const { - return reinterpret_cast(&_content); + return reinterpret_cast(&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::lowest()); ARDUINOJSON_ASSERT(!slot || slot - this <= numeric_limits::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::lowest()); ARDUINOJSON_ASSERT(slot - this <= numeric_limits::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); } };