Rename ArrayConstRef to JsonArrayConst

extras/tests/Misc/TypeTraits.cpp

@@ -186,7 +186,7 @@ TEST_CASE("Polyfills/type_traits") {
     CHECK((is_convertible<JsonArray, JsonVariantConst>::value == true));
     CHECK((is_convertible<ElementProxy<JsonArray>, JsonVariantConst>::value ==
            true));
-    CHECK((is_convertible<ArrayConstRef, JsonVariantConst>::value == true));
+    CHECK((is_convertible<JsonArrayConst, JsonVariantConst>::value == true));
     CHECK((is_convertible<ObjectRef, JsonVariantConst>::value == true));
     CHECK((is_convertible<MemberProxy<ObjectRef, const char*>,
                           JsonVariantConst>::value == true));

src/ArduinoJson.hpp

@@ -47,8 +47,8 @@
 #include "ArduinoJson/compatibility.hpp"
 
 namespace ArduinoJson {
-typedef ARDUINOJSON_NAMESPACE::ArrayConstRef JsonArrayConst;
 using ARDUINOJSON_NAMESPACE::JsonArray;
+using ARDUINOJSON_NAMESPACE::JsonArrayConst;
 typedef ARDUINOJSON_NAMESPACE::Float JsonFloat;
 typedef ARDUINOJSON_NAMESPACE::Integer JsonInteger;
 typedef ARDUINOJSON_NAMESPACE::ObjectConstRef JsonObjectConst;

src/ArduinoJson/Array/ArrayIterator.hpp

@@ -79,12 +79,12 @@ class VariantConstPtr {
   VariantConstRef _variant;
 };
 
-class ArrayConstRefIterator {
+class JsonArrayConstIterator {
   friend class JsonArray;
 
  public:
-  ArrayConstRefIterator() : _slot(0) {}
+  JsonArrayConstIterator() : _slot(0) {}
-  explicit ArrayConstRefIterator(const VariantSlot* slot) : _slot(slot) {}
+  explicit JsonArrayConstIterator(const VariantSlot* slot) : _slot(slot) {}
 
   VariantConstRef operator*() const {
     return VariantConstRef(_slot->data());
@@ -93,20 +93,20 @@ class ArrayConstRefIterator {
     return VariantConstPtr(_slot->data());
   }
 
-  bool operator==(const ArrayConstRefIterator& other) const {
+  bool operator==(const JsonArrayConstIterator& other) const {
     return _slot == other._slot;
   }
 
-  bool operator!=(const ArrayConstRefIterator& other) const {
+  bool operator!=(const JsonArrayConstIterator& other) const {
     return _slot != other._slot;
   }
 
-  ArrayConstRefIterator& operator++() {
+  JsonArrayConstIterator& operator++() {
     _slot = _slot->next();
     return *this;
   }
 
-  ArrayConstRefIterator& operator+=(size_t distance) {
+  JsonArrayConstIterator& operator+=(size_t distance) {
     _slot = _slot->next(distance);
     return *this;
   }

src/ArduinoJson/Array/JsonArray.hpp

@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include <ArduinoJson/Array/ArrayConstRef.hpp>
 #include <ArduinoJson/Array/ElementProxy.hpp>
+#include <ArduinoJson/Array/JsonArrayConst.hpp>
 
 namespace ARDUINOJSON_NAMESPACE {
 
@@ -26,8 +26,8 @@ class JsonArray : public VariantOperators<JsonArray> {
     return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
   }
 
-  operator ArrayConstRef() const {
+  operator JsonArrayConst() const {
-    return ArrayConstRef(_data);
+    return JsonArrayConst(_data);
   }
 
   VariantRef add() const {
@@ -57,14 +57,14 @@ class JsonArray : public VariantOperators<JsonArray> {
   }
 
   // Copy a JsonArray
-  FORCE_INLINE bool set(ArrayConstRef src) const {
+  FORCE_INLINE bool set(JsonArrayConst src) const {
     if (!_data || !src._data)
       return false;
     return _data->copyFrom(*src._data, _pool);
   }
 
   FORCE_INLINE bool operator==(JsonArray rhs) const {
-    return ArrayConstRef(_data) == ArrayConstRef(rhs._data);
+    return JsonArrayConst(_data) == JsonArrayConst(rhs._data);
   }
 
   // Removes element at specified position.

src/ArduinoJson/Array/JsonArrayConst.hpp

@@ -12,12 +12,12 @@ namespace ARDUINOJSON_NAMESPACE {
 
 class ObjectRef;
 
-class ArrayConstRef : public VariantOperators<ArrayConstRef> {
+class JsonArrayConst : public VariantOperators<JsonArrayConst> {
   friend class JsonArray;
   friend class VariantAttorney;
 
  public:
-  typedef ArrayConstRefIterator iterator;
+  typedef JsonArrayConstIterator iterator;
 
   FORCE_INLINE iterator begin() const {
     if (!_data)
@@ -29,10 +29,10 @@ class ArrayConstRef : public VariantOperators<ArrayConstRef> {
     return iterator();
   }
 
-  FORCE_INLINE ArrayConstRef() : _data(0) {}
+  FORCE_INLINE JsonArrayConst() : _data(0) {}
-  FORCE_INLINE ArrayConstRef(const CollectionData* data) : _data(data) {}
+  FORCE_INLINE JsonArrayConst(const CollectionData* data) : _data(data) {}
 
-  FORCE_INLINE bool operator==(ArrayConstRef rhs) const {
+  FORCE_INLINE bool operator==(JsonArrayConst rhs) const {
     if (_data == rhs._data)
       return true;
     if (!_data || !rhs._data)
@@ -92,12 +92,12 @@ class ArrayConstRef : public VariantOperators<ArrayConstRef> {
 };
 
 template <>
-struct Converter<ArrayConstRef> : private VariantAttorney {
+struct Converter<JsonArrayConst> : private VariantAttorney {
   static void toJson(VariantConstRef src, VariantRef dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static ArrayConstRef fromJson(VariantConstRef src) {
+  static JsonArrayConst fromJson(VariantConstRef src) {
     const VariantData* data = getData(src);
     return data ? data->asArray() : 0;
   }

src/ArduinoJson/Array/Utilities.hpp

@@ -64,15 +64,15 @@ inline typename enable_if<!is_array<T>::value, size_t>::type copyArray(
 
 // Copy a JsonArray to array
 template <typename T, size_t N>
-inline size_t copyArray(ArrayConstRef src, T (&dst)[N]) {
+inline size_t copyArray(JsonArrayConst src, T (&dst)[N]) {
   return copyArray(src, dst, N);
 }
 
 // Copy a JsonArray to ptr+size
 template <typename T>
-inline size_t copyArray(ArrayConstRef src, T* dst, size_t len) {
+inline size_t copyArray(JsonArrayConst src, T* dst, size_t len) {
   size_t i = 0;
-  for (ArrayConstRef::iterator it = src.begin(); it != src.end() && i < len;
+  for (JsonArrayConst::iterator it = src.begin(); it != src.end() && i < len;
        ++it)
     copyArray(*it, dst[i++]);
   return i;
@@ -97,7 +97,7 @@ inline typename enable_if<is_array<T>::value &&
                               is_base_of<JsonDocument, TSource>::value,
                           size_t>::type
 copyArray(const TSource& src, T& dst) {
-  return copyArray(src.template as<ArrayConstRef>(), dst);
+  return copyArray(src.template as<JsonArrayConst>(), dst);
 }
 
 }  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Deserialization/Filter.hpp

@@ -17,7 +17,7 @@ class Filter {
   }
 
   bool allowArray() const {
-    return _variant == true || _variant.is<ArrayConstRef>();
+    return _variant == true || _variant.is<JsonArrayConst>();
   }
 
   bool allowObject() const {

src/ArduinoJson/Document/BasicJsonDocument.hpp

@@ -66,7 +66,7 @@ class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
       const T& src,
       typename enable_if<
           is_same<T, VariantRef>::value || is_same<T, VariantConstRef>::value ||
-          is_same<T, JsonArray>::value || is_same<T, ArrayConstRef>::value ||
+          is_same<T, JsonArray>::value || is_same<T, JsonArrayConst>::value ||
           is_same<T, ObjectRef>::value ||
           is_same<T, ObjectConstRef>::value>::type* = 0)
       : JsonDocument(allocPool(src.memoryUsage())) {

src/ArduinoJson/Variant/Converter.hpp

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include <ArduinoJson/Namespace.hpp>
+
 namespace ARDUINOJSON_NAMESPACE {
 
 template <typename T, typename Enable = void>

src/ArduinoJson/Variant/VariantCompare.hpp

@@ -88,7 +88,7 @@ struct ArrayComparer : ComparerBase {
   explicit ArrayComparer(const CollectionData& rhs) : _rhs(&rhs) {}
 
   CompareResult visitArray(const CollectionData& lhs) {
-    if (ArrayConstRef(&lhs) == ArrayConstRef(_rhs))
+    if (JsonArrayConst(&lhs) == JsonArrayConst(_rhs))
       return COMPARE_RESULT_EQUAL;
     else
       return COMPARE_RESULT_DIFFER;

src/ArduinoJson/Variant/VariantConstRef.hpp

@@ -12,7 +12,6 @@
 #include <ArduinoJson/Strings/IsString.hpp>
 #include <ArduinoJson/Strings/StringAdapters.hpp>
 #include <ArduinoJson/Variant/VariantAttorney.hpp>
-#include <ArduinoJson/Variant/VariantConstRef.hpp>
 #include <ArduinoJson/Variant/VariantFunctions.hpp>
 #include <ArduinoJson/Variant/VariantOperators.hpp>
 #include <ArduinoJson/Variant/VariantTag.hpp>