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

Ported from 31ce648e63160f2470308b9cbb47316be60dff13

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<AllocatedBlock*>(
-        _upstream->allocate(sizeof(AllocatedBlock) + n - 1));
+        upstream_->allocate(sizeof(AllocatedBlock) + n - 1));
     if (block) {
-      _log << AllocatorLog::Allocate(n);
+      log_ << AllocatorLog::Allocate(n);
       block->size = n;
       return block->payload;
     } else {
-      _log << AllocatorLog::AllocateFail(n);
+      log_ << AllocatorLog::AllocateFail(n);
       return nullptr;
     }
   }
 
   void deallocate(void* p) override {
     auto block = AllocatedBlock::fromPayload(p);
-    _log << AllocatorLog::Deallocate(block->size);
-    _upstream->deallocate(block);
+    log_ << AllocatorLog::Deallocate(block->size);
+    upstream_->deallocate(block);
   }
 
   void* reallocate(void* p, size_t n) override {
     auto block = AllocatedBlock::fromPayload(p);
     auto oldSize = block->size;
     block = reinterpret_cast<AllocatedBlock*>(
-        _upstream->reallocate(block, sizeof(AllocatedBlock) + n - 1));
+        upstream_->reallocate(block, sizeof(AllocatedBlock) + n - 1));
     if (block) {
-      _log << AllocatorLog::Reallocate(oldSize, n);
+      log_ << AllocatorLog::Reallocate(oldSize, n);
       ARDUINOJSON_ASSERT(block->size == oldSize);
       block->size = n;
       return block->payload;
     } else {
-      _log << AllocatorLog::ReallocateFail(oldSize, n);
+      log_ << AllocatorLog::ReallocateFail(oldSize, n);
       return nullptr;
     }
   }
 
   void clearLog() {
-    _log = AllocatorLog();
+    log_ = AllocatorLog();
   }
 
   const AllocatorLog& log() const {
-    return _log;
+    return log_;
   }
 
  private:
@@ -151,36 +151,36 @@ class SpyingAllocator : public ArduinoJson::Allocator {
     }
   };
 
-  AllocatorLog _log;
-  Allocator* _upstream;
+  AllocatorLog log_;
+  Allocator* upstream_;
 };
 
 class ControllableAllocator : public ArduinoJson::Allocator {
  public:
   ControllableAllocator(
       Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
-      : _enabled(true), _upstream(upstream) {}
+      : enabled_(true), upstream_(upstream) {}
   virtual ~ControllableAllocator() {}
 
   void* allocate(size_t n) override {
-    return _enabled ? _upstream->allocate(n) : 0;
+    return enabled_ ? upstream_->allocate(n) : 0;
   }
 
   void deallocate(void* p) override {
-    _upstream->deallocate(p);
+    upstream_->deallocate(p);
   }
 
   void* reallocate(void* ptr, size_t n) override {
-    return _enabled ? _upstream->reallocate(ptr, n) : 0;
+    return enabled_ ? upstream_->reallocate(ptr, n) : 0;
   }
 
   void disable() {
-    _enabled = false;
+    enabled_ = false;
   }
 
  private:
-  bool _enabled;
-  Allocator* _upstream;
+  bool enabled_;
+  Allocator* upstream_;
 };
 
 class TimebombAllocator : public ArduinoJson::Allocator {
@@ -188,32 +188,32 @@ class TimebombAllocator : public ArduinoJson::Allocator {
   TimebombAllocator(
       size_t initialCountdown,
       Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
-      : _countdown(initialCountdown), _upstream(upstream) {}
+      : countdown_(initialCountdown), upstream_(upstream) {}
   virtual ~TimebombAllocator() {}
 
   void* allocate(size_t n) override {
-    if (!_countdown)
+    if (!countdown_)
       return nullptr;
-    _countdown--;
-    return _upstream->allocate(n);
+    countdown_--;
+    return upstream_->allocate(n);
   }
 
   void deallocate(void* p) override {
-    _upstream->deallocate(p);
+    upstream_->deallocate(p);
   }
 
   void* reallocate(void* ptr, size_t n) override {
-    if (!_countdown)
+    if (!countdown_)
       return nullptr;
-    _countdown--;
-    return _upstream->reallocate(ptr, n);
+    countdown_--;
+    return upstream_->reallocate(ptr, n);
   }
 
   void setCountdown(size_t value) {
-    _countdown = value;
+    countdown_ = value;
   }
 
  private:
-  size_t _countdown = 0;
-  Allocator* _upstream;
+  size_t countdown_ = 0;
+  Allocator* upstream_;
 };

extras/tests/Helpers/CustomReader.hpp

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

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 {};

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<char>(c));
+    str_.append(1, static_cast<char>(c));
     return 1;
   }
 
   size_t write(const uint8_t* s, size_t n) {
-    _str.append(reinterpret_cast<const char*>(s), n);
+    str_.append(reinterpret_cast<const char*>(s), n);
     return n;
   }
 
   const std::string& str() const {
-    return _str;
+    return str_;
   }
 
  private:
-  std::string _str;
+  std::string str_;
 };
 
 TEST_CASE("CustomWriter") {

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 {

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<std::streamsize>(length));
-    return static_cast<size_t>(_stream.gcount());
+    stream_.read(buffer, static_cast<std::streamsize>(length));
+    return static_cast<size_t>(stream_.gcount());
   }
 
  private:
-  std::istringstream _stream;
+  std::istringstream stream_;
 };
 
 TEST_CASE("Reader<Stream>") {

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"

extras/tests/Misc/printable.cpp

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

src/ArduinoJson/Array/ElementProxy.hpp

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

src/ArduinoJson/Array/JsonArray.hpp

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

src/ArduinoJson/Array/JsonArrayConst.hpp

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

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

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);

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

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<size_t>(_code) <
+    ARDUINOJSON_ASSERT(static_cast<size_t>(code_) <
                        sizeof(messages) / sizeof(messages[0]));
-    return messages[_code];
+    return messages[code_];
   }
 
 #if ARDUINOJSON_ENABLE_PROGMEM
@@ -82,12 +82,12 @@ class DeserializationError {
     ARDUINOJSON_DEFINE_PROGMEM_ARRAY(const char*, messages,
                                      {s0, s1, s2, s3, s4, s5});
     return reinterpret_cast<const __FlashStringHelper*>(
-        detail::pgm_read(messages + _code));
+        detail::pgm_read(messages + code_));
   }
 #endif
 
  private:
-  Code _code;
+  Code code_;
 };
 
 #if ARDUINOJSON_ENABLE_STD_STREAM

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<JsonArrayConst>();
+    return variant_ == true || variant_.is<JsonArrayConst>();
   }
 
   bool allowObject() const {
-    return _variant == true || _variant.is<JsonObjectConst>();
+    return variant_ == true || variant_.is<JsonObjectConst>();
   }
 
   bool allowValue() const {
-    return _variant == true;
+    return variant_ == true;
   }
 
   template <typename TKey>
   Filter operator[](const TKey& key) const {
-    if (_variant == true)  // "true" means "allow recursively"
+    if (variant_ == true)  // "true" means "allow recursively"
       return *this;
-    JsonVariantConst member = _variant[key];
-    return Filter(member.isNull() ? _variant["*"] : member);
+    JsonVariantConst member = variant_[key];
+    return Filter(member.isNull() ? variant_["*"] : member);
   }
 
  private:
-  JsonVariantConst _variant;
+  JsonVariantConst variant_;
 };
 }  // namespace DeserializationOption
 

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<uint8_t>(_value - 1));
+    ARDUINOJSON_ASSERT(value_ > 0);
+    return NestingLimit(static_cast<uint8_t>(value_ - 1));
   }
 
   bool reached() const {
-    return _value == 0;
+    return value_ == 0;
   }
 
  private:
-  uint8_t _value;
+  uint8_t value_;
 };
 }  // namespace DeserializationOption
 

src/ArduinoJson/Deserialization/Reader.hpp

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

src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp

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

src/ArduinoJson/Deserialization/Readers/FlashReader.hpp

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

src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp

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

src/ArduinoJson/Deserialization/Readers/RamReader.hpp

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

src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp

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

src/ArduinoJson/Document/JsonDocument.hpp

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

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

src/ArduinoJson/Json/JsonSerializer.hpp

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

src/ArduinoJson/Json/Latch.hpp

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

src/ArduinoJson/Json/PrettyJsonSerializer.hpp

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

src/ArduinoJson/Json/TextFormatter.hpp

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

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

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 <typename TAdaptedString>
   StringNode* findString(const TAdaptedString& str) const {
-    for (auto node = _strings; node; node = node->next) {
+    for (auto node = strings_; node; node = node->next) {
       if (stringEquals(str, adaptString(node->data, node->length)))
         return node;
     }
@@ -146,12 +146,12 @@ class MemoryPool {
 
   StringNode* allocString(size_t length) {
     auto node = reinterpret_cast<StringNode*>(
-        _allocator->allocate(sizeofString(length)));
+        allocator_->allocate(sizeofString(length)));
     if (node) {
       node->length = uint16_t(length);
       node->references = 1;
     } else {
-      _overflowed = true;
+      overflowed_ = true;
     }
     return node;
   }
@@ -159,30 +159,30 @@ class MemoryPool {
   StringNode* reallocString(StringNode* node, size_t length) {
     ARDUINOJSON_ASSERT(node != nullptr);
     auto newNode = reinterpret_cast<StringNode*>(
-        _allocator->reallocate(node, sizeofString(length)));
+        allocator_->reallocate(node, sizeofString(length)));
     if (newNode) {
       newNode->length = uint16_t(length);
     } else {
-      _overflowed = true;
-      _allocator->deallocate(node);
+      overflowed_ = true;
+      allocator_->deallocate(node);
     }
     return newNode;
   }
 
   void deallocString(StringNode* node) {
-    _allocator->deallocate(node);
+    allocator_->deallocate(node);
   }
 
   void dereferenceString(const char* s) {
     StringNode* prev = nullptr;
-    for (auto node = _strings; node; node = node->next) {
+    for (auto node = strings_; node; node = node->next) {
       if (node->data == s) {
         if (--node->references == 0) {
           if (prev)
             prev->next = node->next;
           else
-            _strings = node->next;
-          _allocator->deallocate(node);
+            strings_ = node->next;
+          allocator_->deallocate(node);
         }
         return;
       }
@@ -191,17 +191,17 @@ class MemoryPool {
   }
 
   void clear() {
-    _right = _end;
-    _overflowed = false;
+    right_ = end_;
+    overflowed_ = false;
     deallocAllStrings();
   }
 
   bool canAlloc(size_t bytes) const {
-    return _begin + bytes <= _right;
+    return begin_ + bytes <= right_;
   }
 
   bool owns(void* p) const {
-    return _begin <= p && p < _end;
+    return begin_ <= p && p < end_;
   }
 
   // Workaround for missing placement new
@@ -214,8 +214,8 @@ class MemoryPool {
     if (bytes_reclaimed == 0)
       return;
 
-    void* old_ptr = _begin;
-    void* new_ptr = _allocator->reallocate(old_ptr, capacity());
+    void* old_ptr = begin_;
+    void* new_ptr = allocator_->reallocate(old_ptr, capacity());
 
     ptrdiff_t ptr_offset =
         static_cast<char*>(new_ptr) - static_cast<char*>(old_ptr);
@@ -227,37 +227,37 @@ class MemoryPool {
 
  private:
   ptrdiff_t squash() {
-    char* new_right = addPadding(_begin);
-    if (new_right >= _right)
+    char* new_right = addPadding(begin_);
+    if (new_right >= right_)
       return 0;
 
-    size_t right_size = static_cast<size_t>(_end - _right);
-    memmove(new_right, _right, right_size);
+    size_t right_size = static_cast<size_t>(end_ - right_);
+    memmove(new_right, right_, right_size);
 
-    ptrdiff_t bytes_reclaimed = _right - new_right;
-    _right = new_right;
-    _end = new_right + right_size;
+    ptrdiff_t bytes_reclaimed = right_ - new_right;
+    right_ = new_right;
+    end_ = new_right + right_size;
     return bytes_reclaimed;
   }
 
   // Move all pointers together
   // This funcion is called after a realloc.
   void movePointers(ptrdiff_t offset) {
-    _begin += offset;
-    _right += offset;
-    _end += offset;
+    begin_ += offset;
+    right_ += offset;
+    end_ += offset;
   }
 
   void checkInvariants() {
-    ARDUINOJSON_ASSERT(_begin <= _right);
-    ARDUINOJSON_ASSERT(_right <= _end);
-    ARDUINOJSON_ASSERT(isAligned(_right));
+    ARDUINOJSON_ASSERT(begin_ <= right_);
+    ARDUINOJSON_ASSERT(right_ <= end_);
+    ARDUINOJSON_ASSERT(isAligned(right_));
   }
 
   void deallocAllStrings() {
-    while (_strings) {
-      auto node = _strings;
-      _strings = node->next;
+    while (strings_) {
+      auto node = strings_;
+      strings_ = node->next;
       deallocString(node);
     }
   }
@@ -269,31 +269,31 @@ class MemoryPool {
 
   void* allocRight(size_t bytes) {
     if (!canAlloc(bytes)) {
-      _overflowed = true;
+      overflowed_ = true;
       return 0;
     }
-    _right -= bytes;
-    return _right;
+    right_ -= bytes;
+    return right_;
   }
 
   void allocPool(size_t capa) {
-    auto buf = capa ? reinterpret_cast<char*>(_allocator->allocate(capa)) : 0;
-    _begin = buf;
-    _end = _right = buf ? buf + capa : 0;
-    ARDUINOJSON_ASSERT(isAligned(_begin));
-    ARDUINOJSON_ASSERT(isAligned(_right));
-    ARDUINOJSON_ASSERT(isAligned(_end));
+    auto buf = capa ? reinterpret_cast<char*>(allocator_->allocate(capa)) : 0;
+    begin_ = buf;
+    end_ = right_ = buf ? buf + capa : 0;
+    ARDUINOJSON_ASSERT(isAligned(begin_));
+    ARDUINOJSON_ASSERT(isAligned(right_));
+    ARDUINOJSON_ASSERT(isAligned(end_));
   }
 
   void deallocPool() {
-    if (_begin)
-      _allocator->deallocate(_begin);
+    if (begin_)
+      allocator_->deallocate(begin_);
   }
 
-  Allocator* _allocator;
-  char *_begin, *_right, *_end;
-  bool _overflowed;
-  StringNode* _strings = nullptr;
+  Allocator* allocator_;
+  char *begin_, *right_, *end_;
+  bool overflowed_;
+  StringNode* strings_ = nullptr;
 };
 
 template <typename TAdaptedString>

src/ArduinoJson/Misc/SerializedValue.hpp

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

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

src/ArduinoJson/MsgPack/MsgPackSerializer.hpp

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

src/ArduinoJson/Object/JsonObject.hpp

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

src/ArduinoJson/Object/JsonObjectConst.hpp

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

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

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

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

src/ArduinoJson/Polyfills/pgmspace_generic.hpp

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

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

src/ArduinoJson/Serialization/CountingDecorator.hpp

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

src/ArduinoJson/Serialization/Writer.hpp

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

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<char>(c);
+    buffer_[size_++] = static_cast<char>(c);
     return 1;
   }
 
@@ -37,17 +37,17 @@ class Writer<::String, void> {
   }
 
   size_t flush() {
-    ARDUINOJSON_ASSERT(_size < bufferCapacity);
-    _buffer[_size] = 0;
-    if (_destination->concat(_buffer))
-      _size = 0;
-    return _size;
+    ARDUINOJSON_ASSERT(size_ < bufferCapacity);
+    buffer_[size_] = 0;
+    if (destination_->concat(buffer_))
+      size_ = 0;
+    return size_;
   }
 
  private:
-  ::String* _destination;
-  char _buffer[bufferCapacity];
-  size_t _size;
+  ::String* destination_;
+  char buffer_[bufferCapacity];
+  size_t size_;
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Serialization/Writers/PrintWriter.hpp

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

src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp

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

src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp

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

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

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

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

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 <>

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 <typename TChar>
@@ -101,24 +101,24 @@ class SizedRamString {
  public:
   static const size_t typeSortKey = 2;
 
-  SizedRamString(const char* str, size_t sz) : _str(str), _size(sz) {}
+  SizedRamString(const char* str, size_t sz) : str_(str), size_(sz) {}
 
   bool isNull() const {
-    return !_str;
+    return !str_;
   }
 
   size_t size() const {
-    return _size;
+    return size_;
   }
 
   char operator[](size_t i) const {
-    ARDUINOJSON_ASSERT(_str != 0);
+    ARDUINOJSON_ASSERT(str_ != 0);
     ARDUINOJSON_ASSERT(i <= size());
-    return _str[i];
+    return str_[i];
   }
 
   const char* data() const {
-    return _str;
+    return str_;
   }
 
   StringStoragePolicy::Copy storagePolicy() const {
@@ -126,8 +126,8 @@ class SizedRamString {
   }
 
  protected:
-  const char* _str;
-  size_t _size;
+  const char* str_;
+  size_t size_;
 };
 
 template <typename TChar>

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

src/ArduinoJson/Variant/ConverterImpl.hpp

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

src/ArduinoJson/Variant/JsonVariant.hpp

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

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<detail::IsString<TString>::value,
                                           JsonVariantConst>::type
   operator[](const TString& key) const {
-    return JsonVariantConst(variantGetMember(_data, detail::adaptString(key)));
+    return JsonVariantConst(variantGetMember(data_, detail::adaptString(key)));
   }
 
   // Gets object's member with specified key.
@@ -111,7 +111,7 @@ class JsonVariantConst : public detail::VariantTag,
   FORCE_INLINE typename detail::enable_if<detail::IsString<TChar*>::value,
                                           JsonVariantConst>::type
   operator[](TChar* key) const {
-    return JsonVariantConst(variantGetMember(_data, detail::adaptString(key)));
+    return JsonVariantConst(variantGetMember(data_, detail::adaptString(key)));
   }
 
   // Returns true if tge object contains the specified key.
@@ -134,11 +134,11 @@ class JsonVariantConst : public detail::VariantTag,
 
  protected:
   const detail::VariantData* getData() const {
-    return _data;
+    return data_;
   }
 
  private:
-  const detail::VariantData* _data;
+  const detail::VariantData* data_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Variant/VariantCompare.hpp

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

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

src/ArduinoJson/Variant/VariantImpl.hpp

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

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<VariantData*>(&_content);
+    return reinterpret_cast<VariantData*>(&content_);
   }
 
   const VariantData* data() const {
-    return reinterpret_cast<const VariantData*>(&_content);
+    return reinterpret_cast<const VariantData*>(&content_);
   }
 
   VariantSlot* next() {
-    return _next ? this + _next : 0;
+    return next_ ? this + next_ : 0;
   }
 
   const VariantSlot* next() const {
@@ -48,9 +48,9 @@ class VariantSlot {
   VariantSlot* next(size_t distance) {
     VariantSlot* slot = this;
     while (distance--) {
-      if (!slot->_next)
+      if (!slot->next_)
         return 0;
-      slot += slot->_next;
+      slot += slot->next_;
     }
     return slot;
   }
@@ -64,7 +64,7 @@ class VariantSlot {
                                     numeric_limits<VariantSlotDiff>::lowest());
     ARDUINOJSON_ASSERT(!slot || slot - this <=
                                     numeric_limits<VariantSlotDiff>::highest());
-    _next = VariantSlotDiff(slot ? slot - this : 0);
+    next_ = VariantSlotDiff(slot ? slot - this : 0);
   }
 
   void setNextNotNull(VariantSlot* slot) {
@@ -73,35 +73,35 @@ class VariantSlot {
                        numeric_limits<VariantSlotDiff>::lowest());
     ARDUINOJSON_ASSERT(slot - this <=
                        numeric_limits<VariantSlotDiff>::highest());
-    _next = VariantSlotDiff(slot - this);
+    next_ = VariantSlotDiff(slot - this);
   }
 
   void setKey(JsonString k) {
     ARDUINOJSON_ASSERT(k);
     if (k.isLinked())
-      _flags &= VALUE_MASK;
+      flags_ &= VALUE_MASK;
     else
-      _flags |= OWNED_KEY_BIT;
-    _key = k.c_str();
+      flags_ |= OWNED_KEY_BIT;
+    key_ = k.c_str();
   }
 
   const char* key() const {
-    return _key;
+    return key_;
   }
 
   bool ownsKey() const {
-    return (_flags & OWNED_KEY_BIT) != 0;
+    return (flags_ & OWNED_KEY_BIT) != 0;
   }
 
   void clear() {
-    _next = 0;
-    _flags = 0;
-    _key = 0;
+    next_ = 0;
+    flags_ = 0;
+    key_ = 0;
   }
 
   void movePointers(ptrdiff_t variantDistance) {
-    if (_flags & COLLECTION_MASK)
-      _content.asCollection.movePointers(variantDistance);
+    if (flags_ & COLLECTION_MASK)
+      content_.asCollection.movePointers(variantDistance);
   }
 };