Kept only two namespaces ArduinoJson and ArduinoJson::Internals

src/ArduinoJson/Data/ValueSaver.hpp

@@ -22,8 +22,8 @@ struct ValueSaver {
 };
 
 template <typename Source>
-struct ValueSaver<Source, typename TypeTraits::EnableIf<
-                              StringTraits<Source>::should_duplicate>::type> {
+struct ValueSaver<
+    Source, typename EnableIf<StringTraits<Source>::should_duplicate>::type> {
   template <typename Destination>
   static bool save(JsonBuffer* buffer, Destination& dest, Source source) {
     if (!StringTraits<Source>::is_null(source)) {
@@ -40,8 +40,8 @@ struct ValueSaver<Source, typename TypeTraits::EnableIf<
 
 // const char*, const signed char*, const unsigned char*
 template <typename Char>
-struct ValueSaver<Char*, typename TypeTraits::EnableIf<
-                             !StringTraits<Char*>::should_duplicate>::type> {
+struct ValueSaver<
+    Char*, typename EnableIf<!StringTraits<Char*>::should_duplicate>::type> {
   template <typename Destination>
   static bool save(JsonBuffer*, Destination& dest, Char* source) {
     dest = reinterpret_cast<const char*>(source);

src/ArduinoJson/Deserialization/JsonParser.hpp

@@ -71,7 +71,7 @@ class JsonParser {
 
 template <typename TJsonBuffer, typename TString, typename Enable = void>
 struct JsonParserBuilder {
-  typedef typename Internals::StringTraits<TString>::Reader InputReader;
+  typedef typename StringTraits<TString>::Reader InputReader;
   typedef JsonParser<InputReader, TJsonBuffer &> TParser;
 
   static TParser makeParser(TJsonBuffer *buffer, TString &json,
@@ -81,10 +81,9 @@ struct JsonParserBuilder {
 };
 
 template <typename TJsonBuffer, typename TChar>
-struct JsonParserBuilder<
-    TJsonBuffer, TChar *,
-    typename TypeTraits::EnableIf<!TypeTraits::IsConst<TChar>::value>::type> {
-  typedef typename Internals::StringTraits<TChar *>::Reader TReader;
+struct JsonParserBuilder<TJsonBuffer, TChar *,
+                         typename EnableIf<!IsConst<TChar>::value>::type> {
+  typedef typename StringTraits<TChar *>::Reader TReader;
   typedef StringWriter<TChar> TWriter;
   typedef JsonParser<TReader, TWriter> TParser;
 

src/ArduinoJson/Deserialization/JsonParserImpl.hpp

@@ -141,8 +141,7 @@ inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseObjectTo(
 template <typename TReader, typename TWriter>
 inline const char *
 ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseString() {
-  typename TypeTraits::RemoveReference<TWriter>::type::String str =
-      _writer.startString();
+  typename RemoveReference<TWriter>::type::String str = _writer.startString();
 
   skipSpacesAndComments(_reader);
   char c = _reader.current();

src/ArduinoJson/DynamicJsonBuffer.hpp

@@ -19,6 +19,7 @@
 #endif
 
 namespace ArduinoJson {
+namespace Internals {
 class DefaultAllocator {
  public:
   void* allocate(size_t size) {
@@ -151,6 +152,7 @@ class DynamicJsonBufferBase
   Block* _head;
   size_t _nextBlockCapacity;
 };
+}
 
 #if defined(__clang__)
 #pragma clang diagnostic pop
@@ -163,5 +165,6 @@ class DynamicJsonBufferBase
 // Implements a JsonBuffer with dynamic memory allocation.
 // You are strongly encouraged to consider using StaticJsonBuffer which is much
 // more suitable for embedded systems.
-typedef DynamicJsonBufferBase<DefaultAllocator> DynamicJsonBuffer;
+typedef Internals::DynamicJsonBufferBase<Internals::DefaultAllocator>
+    DynamicJsonBuffer;
 }

src/ArduinoJson/JsonArray.hpp

@@ -26,7 +26,9 @@ namespace ArduinoJson {
 // Forward declarations
 class JsonObject;
 class JsonBuffer;
+namespace Internals {
 class JsonArraySubscript;
+}
 
 // An array of JsonVariant.
 //
@@ -47,10 +49,10 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
       : Internals::List<JsonVariant>(buffer) {}
 
   // Gets the value at the specified index
-  const JsonArraySubscript operator[](size_t index) const;
+  const Internals::JsonArraySubscript operator[](size_t index) const;
 
   // Gets or sets the value at specified index
-  JsonArraySubscript operator[](size_t index);
+  Internals::JsonArraySubscript operator[](size_t index);
 
   // Adds the specified value at the end of the array.
   //
@@ -97,8 +99,7 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   // bool set(size_t index, TValue value, uint8_t decimals);
   // TValue = float, double
   template <typename T>
-  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
-                                bool>::type
+  typename Internals::EnableIf<Internals::IsFloatingPoint<T>::value, bool>::type
   set(size_t index, T value, uint8_t decimals) {
     return set_impl<const JsonVariant &>(index, JsonVariant(value, decimals));
   }

src/ArduinoJson/JsonArraySubscript.hpp

@@ -13,6 +13,7 @@
 #endif
 
 namespace ArduinoJson {
+namespace Internals {
 class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
  public:
   FORCE_INLINE JsonArraySubscript(JsonArray& array, size_t index)
@@ -47,7 +48,7 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
   }
 
   template <typename T>
-  FORCE_INLINE typename Internals::JsonVariantAs<T>::type as() const {
+  FORCE_INLINE typename JsonVariantAs<T>::type as() const {
     return _array.get<T>(_index);
   }
 
@@ -86,21 +87,6 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
   const size_t _index;
 };
 
-#if ARDUINOJSON_ENABLE_STD_STREAM
-inline std::ostream& operator<<(std::ostream& os,
-                                const JsonArraySubscript& source) {
-  return source.printTo(os);
-}
-#endif
-
-inline JsonArraySubscript JsonArray::operator[](size_t index) {
-  return JsonArraySubscript(*this, index);
-}
-
-inline const JsonArraySubscript JsonArray::operator[](size_t index) const {
-  return JsonArraySubscript(*const_cast<JsonArray*>(this), index);
-}
-
 template <typename TImpl>
 inline JsonArraySubscript JsonVariantSubscripts<TImpl>::operator[](
     size_t index) {
@@ -113,7 +99,23 @@ inline const JsonArraySubscript JsonVariantSubscripts<TImpl>::operator[](
   return impl()->template as<JsonArray>()[index];
 }
 
-}  // namespace ArduinoJson
+#if ARDUINOJSON_ENABLE_STD_STREAM
+inline std::ostream& operator<<(std::ostream& os,
+                                const JsonArraySubscript& source) {
+  return source.printTo(os);
+}
+#endif
+}
+
+inline Internals::JsonArraySubscript JsonArray::operator[](size_t index) {
+  return Internals::JsonArraySubscript(*this, index);
+}
+
+inline const Internals::JsonArraySubscript JsonArray::operator[](
+    size_t index) const {
+  return Internals::JsonArraySubscript(*const_cast<JsonArray*>(this), index);
+}
+}
 
 #ifdef _MSC_VER
 #pragma warning(pop)

src/ArduinoJson/JsonBuffer.hpp

@@ -42,8 +42,8 @@ class JsonBuffer : Internals::NonCopyable {
   // TValue = const std::string&, const String&,
   template <typename TString>
   DEPRECATED("char* are duplicated, you don't need strdup() anymore")
-  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
-                                const char *>::type strdup(const TString &src) {
+  typename Internals::EnableIf<!Internals::IsArray<TString>::value,
+                               const char *>::type strdup(const TString &src) {
     return Internals::StringTraits<TString>::duplicate(src, this);
   }
   //

src/ArduinoJson/JsonBufferBase.hpp

@@ -7,6 +7,7 @@
 #include "Deserialization/JsonParser.hpp"
 
 namespace ArduinoJson {
+namespace Internals {
 template <typename TDerived>
 class JsonBufferBase : public JsonBuffer {
  public:
@@ -25,8 +26,8 @@ class JsonBufferBase : public JsonBuffer {
   // JsonArray& parseArray(TString);
   // TString = const std::string&, const String&
   template <typename TString>
-  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
-                                JsonArray &>::type
+  typename Internals::EnableIf<!Internals::IsArray<TString>::value,
+                               JsonArray &>::type
   parseArray(const TString &json,
              uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
     return Internals::makeParser(that(), json, nestingLimit).parseArray();
@@ -62,8 +63,8 @@ class JsonBufferBase : public JsonBuffer {
   // JsonObject& parseObject(TString);
   // TString = const std::string&, const String&
   template <typename TString>
-  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
-                                JsonObject &>::type
+  typename Internals::EnableIf<!Internals::IsArray<TString>::value,
+                               JsonObject &>::type
   parseObject(const TString &json,
               uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
     return Internals::makeParser(that(), json, nestingLimit).parseObject();
@@ -91,8 +92,8 @@ class JsonBufferBase : public JsonBuffer {
   // JsonVariant parse(TString);
   // TString = const std::string&, const String&
   template <typename TString>
-  typename TypeTraits::EnableIf<!TypeTraits::IsArray<TString>::value,
-                                JsonVariant>::type
+  typename Internals::EnableIf<!Internals::IsArray<TString>::value,
+                               JsonVariant>::type
   parse(const TString &json,
         uint8_t nestingLimit = ARDUINOJSON_DEFAULT_NESTING_LIMIT) {
     return Internals::makeParser(that(), json, nestingLimit).parseVariant();
@@ -123,3 +124,4 @@ class JsonBufferBase : public JsonBuffer {
   }
 };
 }
+}

src/ArduinoJson/JsonObject.hpp

@@ -26,6 +26,10 @@ namespace ArduinoJson {
 // Forward declarations
 class JsonArray;
 class JsonBuffer;
+namespace Internals {
+template <typename>
+class JsonObjectSubscript;
+}
 
 // A dictionary of JsonVariant indexed by string (char*)
 //
@@ -50,33 +54,36 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
   // JsonObjectSubscript operator[](TKey)
   // TKey = const std::string&, const String&
   template <typename TString>
-  JsonObjectSubscript<const TString&> operator[](const TString& key) {
-    return JsonObjectSubscript<const TString&>(*this, key);
+  Internals::JsonObjectSubscript<const TString&> operator[](
+      const TString& key) {
+    return Internals::JsonObjectSubscript<const TString&>(*this, key);
   }
   //
   // JsonObjectSubscript operator[](TKey)
   // TKey = char*, const char*, char[], const char[N], const FlashStringHelper*
   template <typename TString>
-  JsonObjectSubscript<TString*> operator[](TString* key) {
-    return JsonObjectSubscript<TString*>(*this, key);
+  Internals::JsonObjectSubscript<TString*> operator[](TString* key) {
+    return Internals::JsonObjectSubscript<TString*>(*this, key);
   }
 
   // Gets the value associated with the specified key.
   //
   // const JsonObjectSubscript operator[](TKey) const;
   // TKey = const std::string&, const String&
   template <typename TString>
-  const JsonObjectSubscript<const TString&> operator[](
+  const Internals::JsonObjectSubscript<const TString&> operator[](
       const TString& key) const {
-    return JsonObjectSubscript<const TString&>(*const_cast<JsonObject*>(this),
-                                               key);
+    return Internals::JsonObjectSubscript<const TString&>(
+        *const_cast<JsonObject*>(this), key);
   }
   //
   // const JsonObjectSubscript operator[](TKey) const;
   // TKey = const char*, const char[N], const FlashStringHelper*
   template <typename TString>
-  const JsonObjectSubscript<TString*> operator[](TString* key) const {
-    return JsonObjectSubscript<TString*>(*const_cast<JsonObject*>(this), key);
+  const Internals::JsonObjectSubscript<TString*> operator[](
+      TString* key) const {
+    return Internals::JsonObjectSubscript<TString*>(
+        *const_cast<JsonObject*>(this), key);
   }
 
   // Sets the specified key with the specified value.
@@ -120,8 +127,8 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
   // TValue = float, double
   template <typename TValue, typename TString>
   DEPRECATED("Second argument is not supported anymore")
-  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<TValue>::value,
-                                bool>::type
+  typename Internals::EnableIf<Internals::IsFloatingPoint<TValue>::value,
+                               bool>::type
       set(const TString& key, TValue value, uint8_t) {
     return set_impl<const TString&, const JsonVariant&>(key,
                                                         JsonVariant(value));
@@ -132,8 +139,8 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
   // TValue = float, double
   template <typename TValue, typename TString>
   DEPRECATED("Second argument is not supported anymore")
-  typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<TValue>::value,
-                                bool>::type
+  typename Internals::EnableIf<Internals::IsFloatingPoint<TValue>::value,
+                               bool>::type
       set(TString* key, TValue value, uint8_t) {
     return set_impl<TString*, const JsonVariant&>(key, JsonVariant(value));
   }

src/ArduinoJson/JsonObjectSubscript.hpp

@@ -14,6 +14,7 @@
 #endif
 
 namespace ArduinoJson {
+namespace Internals {
 
 template <typename TStringRef>
 class JsonObjectSubscript
@@ -35,10 +36,8 @@ class JsonObjectSubscript
   // TValue = bool, char, long, int, short, float, double,
   //          std::string, String, JsonArray, JsonObject
   template <typename TValue>
-  FORCE_INLINE
-      typename TypeTraits::EnableIf<!TypeTraits::IsArray<TValue>::value,
-                                    this_type&>::type
-      operator=(const TValue& src) {
+  FORCE_INLINE typename EnableIf<!IsArray<TValue>::value, this_type&>::type
+  operator=(const TValue& src) {
     _object.set(_key, src);
     return *this;
   }
@@ -56,7 +55,7 @@ class JsonObjectSubscript
   }
 
   template <typename TValue>
-  FORCE_INLINE typename Internals::JsonVariantAs<TValue>::type as() const {
+  FORCE_INLINE typename JsonVariantAs<TValue>::type as() const {
     return _object.get<TValue>(_key);
   }
 
@@ -71,10 +70,8 @@ class JsonObjectSubscript
   // TValue = bool, char, long, int, short, float, double, RawJson, JsonVariant,
   //          std::string, String, JsonArray, JsonObject
   template <typename TValue>
-  FORCE_INLINE
-      typename TypeTraits::EnableIf<!TypeTraits::IsArray<TValue>::value,
-                                    bool>::type
-      set(const TValue& value) {
+  FORCE_INLINE typename EnableIf<!IsArray<TValue>::value, bool>::type set(
+      const TValue& value) {
     return _object.set(_key, value);
   }
   //
@@ -105,7 +102,8 @@ inline std::ostream& operator<<(std::ostream& os,
   return source.printTo(os);
 }
 #endif
-}  // namespace ArduinoJson
+}
+}
 
 #ifdef _MSC_VER
 #pragma warning(pop)