Rename `ObjectConstRef` to `JsonObjectConst`

extras/tests/Misc/TypeTraits.cpp

@@ -190,7 +190,7 @@ TEST_CASE("Polyfills/type_traits") {
     CHECK((is_convertible<JsonObject, JsonVariantConst>::value == true));
     CHECK((is_convertible<MemberProxy<JsonObject, const char*>,
                           JsonVariantConst>::value == true));
-    CHECK((is_convertible<ObjectConstRef, JsonVariantConst>::value == true));
+    CHECK((is_convertible<JsonObjectConst, JsonVariantConst>::value == true));
     CHECK(
         (is_convertible<DynamicJsonDocument, JsonVariantConst>::value == true));
     CHECK((is_convertible<StaticJsonDocument<10>, JsonVariantConst>::value ==

src/ArduinoJson.hpp

@@ -51,8 +51,8 @@ using ARDUINOJSON_NAMESPACE::JsonArray;
 using ARDUINOJSON_NAMESPACE::JsonArrayConst;
 typedef ARDUINOJSON_NAMESPACE::Float JsonFloat;
 typedef ARDUINOJSON_NAMESPACE::Integer JsonInteger;
-typedef ARDUINOJSON_NAMESPACE::ObjectConstRef JsonObjectConst;
 using ARDUINOJSON_NAMESPACE::JsonObject;
+using ARDUINOJSON_NAMESPACE::JsonObjectConst;
 typedef ARDUINOJSON_NAMESPACE::Pair JsonPair;
 typedef ARDUINOJSON_NAMESPACE::PairConst JsonPairConst;
 typedef ARDUINOJSON_NAMESPACE::String JsonString;

src/ArduinoJson/Deserialization/Filter.hpp

@@ -21,7 +21,7 @@ class Filter {
   }
 
   bool allowObject() const {
-    return _variant == true || _variant.is<ObjectConstRef>();
+    return _variant == true || _variant.is<JsonObjectConst>();
   }
 
   bool allowValue() const {

src/ArduinoJson/Document/BasicJsonDocument.hpp

@@ -68,7 +68,7 @@ class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
           is_same<T, VariantRef>::value || is_same<T, VariantConstRef>::value ||
           is_same<T, JsonArray>::value || is_same<T, JsonArrayConst>::value ||
           is_same<T, JsonObject>::value ||
-          is_same<T, ObjectConstRef>::value>::type* = 0)
+          is_same<T, JsonObjectConst>::value>::type* = 0)
       : JsonDocument(allocPool(src.memoryUsage())) {
     set(src);
   }

src/ArduinoJson/Object/JsonObject.hpp

@@ -4,8 +4,9 @@
 
 #pragma once
 
+#include <ArduinoJson/Object/JsonObjectConst.hpp>
 #include <ArduinoJson/Object/MemberProxy.hpp>
-#include <ArduinoJson/Object/ObjectConstRef.hpp>
+
 
 namespace ARDUINOJSON_NAMESPACE {
 
@@ -26,8 +27,8 @@ class JsonObject : public VariantOperators<JsonObject> {
     return VariantRef(_pool, reinterpret_cast<VariantData*>(data));
   }
 
-  operator ObjectConstRef() const {
-    return ObjectConstRef(_data);
+  operator JsonObjectConst() const {
+    return JsonObjectConst(_data);
   }
 
   operator VariantConstRef() const {
@@ -70,14 +71,14 @@ class JsonObject : public VariantOperators<JsonObject> {
     _data->clear();
   }
 
-  FORCE_INLINE bool set(ObjectConstRef src) {
+  FORCE_INLINE bool set(JsonObjectConst src) {
     if (!_data || !src._data)
       return false;
     return _data->copyFrom(*src._data, _pool);
   }
 
   FORCE_INLINE bool operator==(JsonObject rhs) const {
-    return ObjectConstRef(_data) == ObjectConstRef(rhs._data);
+    return JsonObjectConst(_data) == JsonObjectConst(rhs._data);
   }
 
   template <typename TString>

src/ArduinoJson/Object/ObjectConstRef.hpp → src/ArduinoJson/Object/JsonObjectConst.hpp

@@ -9,15 +9,15 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-class ObjectConstRef : public VariantOperators<ObjectConstRef> {
+class JsonObjectConst : public VariantOperators<JsonObjectConst> {
   friend class JsonObject;
   friend class VariantAttorney;
 
  public:
   typedef ObjectConstIterator iterator;
 
-  ObjectConstRef() : _data(0) {}
-  ObjectConstRef(const CollectionData* data) : _data(data) {}
+  JsonObjectConst() : _data(0) {}
+  JsonObjectConst(const CollectionData* data) : _data(data) {}
 
   operator VariantConstRef() const {
     return VariantConstRef(collectionToVariant(_data));
@@ -87,7 +87,7 @@ class ObjectConstRef : public VariantOperators<ObjectConstRef> {
     return VariantConstRef(getMember(adaptString(key)));
   }
 
-  FORCE_INLINE bool operator==(ObjectConstRef rhs) const {
+  FORCE_INLINE bool operator==(JsonObjectConst rhs) const {
     if (_data == rhs._data)
       return true;
 
@@ -119,12 +119,12 @@ class ObjectConstRef : public VariantOperators<ObjectConstRef> {
 };
 
 template <>
-struct Converter<ObjectConstRef> : private VariantAttorney {
+struct Converter<JsonObjectConst> : private VariantAttorney {
   static void toJson(VariantConstRef src, VariantRef dst) {
     variantCopyFrom(getData(dst), getData(src), getPool(dst));
   }
 
-  static ObjectConstRef fromJson(VariantConstRef src) {
+  static JsonObjectConst fromJson(VariantConstRef src) {
     const VariantData* data = getData(src);
     return data != 0 ? data->asObject() : 0;
   }

src/ArduinoJson/Variant/VariantCompare.hpp

@@ -101,7 +101,7 @@ struct ObjectComparer : ComparerBase {
   explicit ObjectComparer(const CollectionData& rhs) : _rhs(&rhs) {}
 
   CompareResult visitObject(const CollectionData& lhs) {
-    if (ObjectConstRef(&lhs) == ObjectConstRef(_rhs))
+    if (JsonObjectConst(&lhs) == JsonObjectConst(_rhs))
       return COMPARE_RESULT_EQUAL;
     else
       return COMPARE_RESULT_DIFFER;