Allow mixed configuration in compilation units (issue #809)

src/ArduinoJson/JsonVariant.hpp

@@ -17,7 +17,7 @@
 #include "Serialization/DynamicStringWriter.hpp"
 #include "SerializedValue.hpp"
 
-namespace ArduinoJson {
+namespace ARDUINOJSON_NAMESPACE {
 
 // Forward declarations.
 class JsonArray;
@@ -30,11 +30,10 @@ class JsonObject;
 // - a char, short, int or a long (signed or unsigned)
 // - a string (const char*)
 // - a reference to a JsonArray or JsonObject
-class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
+class JsonVariant : public JsonVariantBase<JsonVariant> {
  public:
   // Intenal use only
-  FORCE_INLINE JsonVariant(Internals::MemoryPool *memoryPool,
-                           Internals::JsonVariantData *data)
+  FORCE_INLINE JsonVariant(MemoryPool *memoryPool, JsonVariantData *data)
       : _memoryPool(memoryPool), _data(data) {}
 
   // Creates an uninitialized JsonVariant
@@ -43,8 +42,8 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // set(bool value)
   FORCE_INLINE bool set(bool value) {
     if (!_data) return false;
-    _data->type = Internals::JSON_BOOLEAN;
-    _data->content.asInteger = static_cast<Internals::JsonUInt>(value);
+    _data->type = JSON_BOOLEAN;
+    _data->content.asInteger = static_cast<JsonUInt>(value);
     return true;
   }
 
@@ -52,11 +51,10 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // set(float value);
   template <typename T>
   FORCE_INLINE bool set(
-      T value, typename Internals::enable_if<
-                   Internals::is_floating_point<T>::value>::type * = 0) {
+      T value, typename enable_if<is_floating_point<T>::value>::type * = 0) {
     if (!_data) return false;
-    _data->type = Internals::JSON_FLOAT;
-    _data->content.asFloat = static_cast<Internals::JsonFloat>(value);
+    _data->type = JSON_FLOAT;
+    _data->content.asFloat = static_cast<JsonFloat>(value);
     return true;
   }
 
@@ -66,18 +64,16 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // set(signed long)
   // set(signed char)
   template <typename T>
-  FORCE_INLINE bool set(
-      T value,
-      typename Internals::enable_if<Internals::is_integral<T>::value &&
-                                    Internals::is_signed<T>::value>::type * =
-          0) {
+  FORCE_INLINE bool set(T value,
+                        typename enable_if<is_integral<T>::value &&
+                                           is_signed<T>::value>::type * = 0) {
     if (!_data) return false;
     if (value >= 0) {
-      _data->type = Internals::JSON_POSITIVE_INTEGER;
-      _data->content.asInteger = static_cast<Internals::JsonUInt>(value);
+      _data->type = JSON_POSITIVE_INTEGER;
+      _data->content.asInteger = static_cast<JsonUInt>(value);
     } else {
-      _data->type = Internals::JSON_NEGATIVE_INTEGER;
-      _data->content.asInteger = ~static_cast<Internals::JsonUInt>(value) + 1;
+      _data->type = JSON_NEGATIVE_INTEGER;
+      _data->content.asInteger = ~static_cast<JsonUInt>(value) + 1;
     }
     return true;
   }
@@ -86,21 +82,19 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // set(unsigned int)
   // set(unsigned long)
   template <typename T>
-  FORCE_INLINE bool set(
-      T value,
-      typename Internals::enable_if<Internals::is_integral<T>::value &&
-                                    Internals::is_unsigned<T>::value>::type * =
-          0) {
+  FORCE_INLINE bool set(T value,
+                        typename enable_if<is_integral<T>::value &&
+                                           is_unsigned<T>::value>::type * = 0) {
     if (!_data) return false;
-    _data->type = Internals::JSON_POSITIVE_INTEGER;
-    _data->content.asInteger = static_cast<Internals::JsonUInt>(value);
+    _data->type = JSON_POSITIVE_INTEGER;
+    _data->content.asInteger = static_cast<JsonUInt>(value);
     return true;
   }
 
   // set(SerializedValue<const char *>)
-  FORCE_INLINE bool set(Internals::SerializedValue<const char *> value) {
+  FORCE_INLINE bool set(SerializedValue<const char *> value) {
     if (!_data) return false;
-    _data->type = Internals::JSON_LINKED_RAW;
+    _data->type = JSON_LINKED_RAW;
     _data->content.asRaw.data = value.data();
     _data->content.asRaw.size = value.size();
     return true;
@@ -111,19 +105,17 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // set(SerializedValue<const __FlashStringHelper*>)
   template <typename T>
   FORCE_INLINE bool set(
-      Internals::SerializedValue<T> value,
-      typename Internals::enable_if<
-          !Internals::is_same<const char *, T>::value>::type * = 0) {
+      SerializedValue<T> value,
+      typename enable_if<!is_same<const char *, T>::value>::type * = 0) {
     if (!_data) return false;
-    const char *dup =
-        Internals::makeString(value.data(), value.size()).save(_memoryPool);
+    const char *dup = makeString(value.data(), value.size()).save(_memoryPool);
     if (dup) {
-      _data->type = Internals::JSON_OWNED_RAW;
+      _data->type = JSON_OWNED_RAW;
       _data->content.asRaw.data = dup;
       _data->content.asRaw.size = value.size();
       return true;
     } else {
-      _data->type = Internals::JSON_NULL;
+      _data->type = JSON_NULL;
       return false;
     }
   }
@@ -131,36 +123,32 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // set(const std::string&)
   // set(const String&)
   template <typename T>
-  FORCE_INLINE bool set(
-      const T &value,
-      typename Internals::enable_if<Internals::IsString<T>::value>::type * =
-          0) {
+  FORCE_INLINE bool set(const T &value,
+                        typename enable_if<IsString<T>::value>::type * = 0) {
     if (!_data) return false;
-    const char *dup = Internals::makeString(value).save(_memoryPool);
+    const char *dup = makeString(value).save(_memoryPool);
     if (dup) {
-      _data->type = Internals::JSON_OWNED_STRING;
+      _data->type = JSON_OWNED_STRING;
       _data->content.asString = dup;
       return true;
     } else {
-      _data->type = Internals::JSON_NULL;
+      _data->type = JSON_NULL;
       return false;
     }
   }
 
   // set(char*)
   template <typename T>
-  FORCE_INLINE bool set(
-      T *value,
-      typename Internals::enable_if<Internals::IsString<T *>::value>::type * =
-          0) {
+  FORCE_INLINE bool set(T *value,
+                        typename enable_if<IsString<T *>::value>::type * = 0) {
     if (!_data) return false;
-    const char *dup = Internals::makeString(value).save(_memoryPool);
+    const char *dup = makeString(value).save(_memoryPool);
     if (dup) {
-      _data->type = Internals::JSON_OWNED_STRING;
+      _data->type = JSON_OWNED_STRING;
       _data->content.asString = dup;
       return true;
     } else {
-      _data->type = Internals::JSON_NULL;
+      _data->type = JSON_NULL;
       return false;
     }
   }
@@ -168,7 +156,7 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // set(const char*);
   FORCE_INLINE bool set(const char *value) {
     if (!_data) return false;
-    _data->type = Internals::JSON_LINKED_STRING;
+    _data->type = JSON_LINKED_STRING;
     _data->content.asString = value;
     return true;
   }
@@ -176,10 +164,10 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   bool set(const JsonVariant &value);
 
   FORCE_INLINE bool set(JsonArray array);
-  FORCE_INLINE bool set(const Internals::JsonArraySubscript &);
+  FORCE_INLINE bool set(const JsonArraySubscript &);
   FORCE_INLINE bool set(JsonObject object);
   template <typename TString>
-  FORCE_INLINE bool set(const Internals::JsonObjectSubscript<TString> &);
+  FORCE_INLINE bool set(const JsonObjectSubscript<TString> &);
 
   // Get the variant as the specified type.
   //
@@ -193,20 +181,19 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // unsigned int as<unsigned int>() const;
   // unsigned long as<unsigned long>() const;
   template <typename T>
-  FORCE_INLINE const typename Internals::enable_if<
-      Internals::is_integral<T>::value, T>::type
-  as() const {
+  FORCE_INLINE const typename enable_if<is_integral<T>::value, T>::type as()
+      const {
     if (!_data) return 0;
     switch (_data->type) {
-      case Internals::JSON_POSITIVE_INTEGER:
-      case Internals::JSON_BOOLEAN:
+      case JSON_POSITIVE_INTEGER:
+      case JSON_BOOLEAN:
         return T(_data->content.asInteger);
-      case Internals::JSON_NEGATIVE_INTEGER:
+      case JSON_NEGATIVE_INTEGER:
         return T(~_data->content.asInteger + 1);
-      case Internals::JSON_LINKED_STRING:
-      case Internals::JSON_OWNED_STRING:
-        return Internals::parseInteger<T>(_data->content.asString);
-      case Internals::JSON_FLOAT:
+      case JSON_LINKED_STRING:
+      case JSON_OWNED_STRING:
+        return parseInteger<T>(_data->content.asString);
+      case JSON_FLOAT:
         return T(_data->content.asFloat);
       default:
         return 0;
@@ -214,29 +201,27 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   }
   // bool as<bool>() const
   template <typename T>
-  FORCE_INLINE const typename Internals::enable_if<
-      Internals::is_same<T, bool>::value, T>::type
-  as() const {
+  FORCE_INLINE const typename enable_if<is_same<T, bool>::value, T>::type as()
+      const {
     return as<int>() != 0;
   }
   //
   // double as<double>() const;
   // float as<float>() const;
   template <typename T>
-  FORCE_INLINE const typename Internals::enable_if<
-      Internals::is_floating_point<T>::value, T>::type
+  FORCE_INLINE const typename enable_if<is_floating_point<T>::value, T>::type
   as() const {
     if (!_data) return 0;
     switch (_data->type) {
-      case Internals::JSON_POSITIVE_INTEGER:
-      case Internals::JSON_BOOLEAN:
+      case JSON_POSITIVE_INTEGER:
+      case JSON_BOOLEAN:
         return static_cast<T>(_data->content.asInteger);
-      case Internals::JSON_NEGATIVE_INTEGER:
+      case JSON_NEGATIVE_INTEGER:
         return -static_cast<T>(_data->content.asInteger);
-      case Internals::JSON_LINKED_STRING:
-      case Internals::JSON_OWNED_STRING:
-        return Internals::parseFloat<T>(_data->content.asString);
-      case Internals::JSON_FLOAT:
+      case JSON_LINKED_STRING:
+      case JSON_OWNED_STRING:
+        return parseFloat<T>(_data->content.asString);
+      case JSON_FLOAT:
         return static_cast<T>(_data->content.asFloat);
       default:
         return 0;
@@ -246,14 +231,13 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // const char* as<const char*>() const;
   // const char* as<char*>() const;
   template <typename T>
-  FORCE_INLINE typename Internals::enable_if<
-      Internals::is_same<T, const char *>::value ||
-          Internals::is_same<T, char *>::value,
-      const char *>::type
+  FORCE_INLINE typename enable_if<is_same<T, const char *>::value ||
+                                      is_same<T, char *>::value,
+                                  const char *>::type
   as() const {
     if (!_data) return 0;
-    if (_data && (_data->type == Internals::JSON_LINKED_STRING ||
-                  _data->type == Internals::JSON_OWNED_STRING))
+    if (_data &&
+        (_data->type == JSON_LINKED_STRING || _data->type == JSON_OWNED_STRING))
       return _data->content.asString;
     else
       return 0;
@@ -262,10 +246,8 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // std::string as<std::string>() const;
   // String as<String>() const;
   template <typename T>
-  FORCE_INLINE
-      typename Internals::enable_if<Internals::IsWriteableString<T>::value,
-                                    T>::type
-      as() const {
+  FORCE_INLINE typename enable_if<IsWriteableString<T>::value, T>::type as()
+      const {
     const char *cstr = as<const char *>();
     if (cstr) return T(cstr);
     T s;
@@ -276,27 +258,22 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // JsonArray as<JsonArray>() const;
   // const JsonArray as<const JsonArray>() const;
   template <typename T>
-  FORCE_INLINE typename Internals::enable_if<
-      Internals::is_same<typename Internals::remove_const<T>::type,
-                         JsonArray>::value,
+  FORCE_INLINE typename enable_if<
+      is_same<typename remove_const<T>::type, JsonArray>::value,
       JsonArray>::type
   as() const;
   //
   // JsonObject as<JsonObject>() const;
   // const JsonObject as<const JsonObject>() const;
   template <typename T>
-  FORCE_INLINE typename Internals::enable_if<
-      Internals::is_same<typename Internals::remove_const<T>::type,
-                         JsonObject>::value,
-      T>::type
+  FORCE_INLINE typename enable_if<
+      is_same<typename remove_const<T>::type, JsonObject>::value, T>::type
   as() const;
   //
   // JsonVariant as<JsonVariant> const;
   template <typename T>
-  FORCE_INLINE
-      typename Internals::enable_if<Internals::is_same<T, JsonVariant>::value,
-                                    T>::type
-      as() const {
+  FORCE_INLINE typename enable_if<is_same<T, JsonVariant>::value, T>::type as()
+      const {
     return *this;
   }
 
@@ -313,69 +290,59 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   // bool is<unsigned int>() const;
   // bool is<unsigned long>() const;
   template <typename T>
-  FORCE_INLINE typename Internals::enable_if<Internals::is_integral<T>::value,
-                                             bool>::type
-  is() const {
-    return _data && (_data->type == Internals::JSON_POSITIVE_INTEGER ||
-                     _data->type == Internals::JSON_NEGATIVE_INTEGER);
+  FORCE_INLINE typename enable_if<is_integral<T>::value, bool>::type is()
+      const {
+    return _data && (_data->type == JSON_POSITIVE_INTEGER ||
+                     _data->type == JSON_NEGATIVE_INTEGER);
   }
   //
   // bool is<double>() const;
   // bool is<float>() const;
   template <typename T>
-  FORCE_INLINE
-      typename Internals::enable_if<Internals::is_floating_point<T>::value,
-                                    bool>::type
-      is() const {
-    return _data && (_data->type == Internals::JSON_FLOAT ||
-                     _data->type == Internals::JSON_POSITIVE_INTEGER ||
-                     _data->type == Internals::JSON_NEGATIVE_INTEGER);
+  FORCE_INLINE typename enable_if<is_floating_point<T>::value, bool>::type is()
+      const {
+    return _data &&
+           (_data->type == JSON_FLOAT || _data->type == JSON_POSITIVE_INTEGER ||
+            _data->type == JSON_NEGATIVE_INTEGER);
   }
   //
   // bool is<bool>() const
   template <typename T>
-  FORCE_INLINE typename Internals::enable_if<Internals::is_same<T, bool>::value,
-                                             bool>::type
-  is() const {
-    return _data && _data->type == Internals::JSON_BOOLEAN;
+  FORCE_INLINE typename enable_if<is_same<T, bool>::value, bool>::type is()
+      const {
+    return _data && _data->type == JSON_BOOLEAN;
   }
   //
   // bool is<const char*>() const;
   // bool is<char*>() const;
   template <typename T>
-  FORCE_INLINE typename Internals::enable_if<
-      Internals::is_same<T, const char *>::value ||
-          Internals::is_same<T, char *>::value,
-      bool>::type
+  FORCE_INLINE typename enable_if<
+      is_same<T, const char *>::value || is_same<T, char *>::value, bool>::type
   is() const {
-    return _data && (_data->type == Internals::JSON_LINKED_STRING ||
-                     _data->type == Internals::JSON_OWNED_STRING);
+    return _data && (_data->type == JSON_LINKED_STRING ||
+                     _data->type == JSON_OWNED_STRING);
   }
   //
   // bool is<JsonArray> const;
   // bool is<const JsonArray> const;
   template <typename T>
-  FORCE_INLINE typename Internals::enable_if<
-      Internals::is_same<typename Internals::remove_const<T>::type,
-                         JsonArray>::value,
-      bool>::type
+  FORCE_INLINE typename enable_if<
+      is_same<typename remove_const<T>::type, JsonArray>::value, bool>::type
   is() const {
-    return _data && _data->type == Internals::JSON_ARRAY;
+    return _data && _data->type == JSON_ARRAY;
   }
   //
   // bool is<JsonObject> const;
   // bool is<const JsonObject> const;
   template <typename T>
-  FORCE_INLINE typename Internals::enable_if<
-      Internals::is_same<typename Internals::remove_const<T>::type,
-                         JsonObject>::value,
-      bool>::type
+  FORCE_INLINE typename enable_if<
+      is_same<typename remove_const<T>::type, JsonObject>::value, bool>::type
   is() const {
-    return _data && _data->type == Internals::JSON_OBJECT;
+    return _data && _data->type == JSON_OBJECT;
   }
 
   FORCE_INLINE bool isNull() const {
-    return _data == 0 || _data->type == Internals::JSON_NULL;
+    return _data == 0 || _data->type == JSON_NULL;
   }
 
   FORCE_INLINE bool isInvalid() const {
@@ -389,35 +356,29 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
   //
   // JsonArray to<JsonArray>()
   template <typename T>
-  typename Internals::enable_if<Internals::is_same<T, JsonArray>::value,
-                                JsonArray>::type
-  to();
+  typename enable_if<is_same<T, JsonArray>::value, JsonArray>::type to();
   //
   // JsonObject to<JsonObject>()
   template <typename T>
-  typename Internals::enable_if<Internals::is_same<T, JsonObject>::value,
-                                JsonObject>::type
-  to();
+  typename enable_if<is_same<T, JsonObject>::value, JsonObject>::type to();
   //
   // JsonObject to<JsonVariant>()
   template <typename T>
-  typename Internals::enable_if<Internals::is_same<T, JsonVariant>::value,
-                                JsonVariant>::type
-  to();
+  typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type to();
 
  private:
-  Internals::MemoryPool *_memoryPool;
-  Internals::JsonVariantData *_data;
+  MemoryPool *_memoryPool;
+  JsonVariantData *_data;
 };
 
 class JsonVariantLocal : public JsonVariant {
  public:
-  explicit JsonVariantLocal(Internals::MemoryPool *memoryPool)
+  explicit JsonVariantLocal(MemoryPool *memoryPool)
       : JsonVariant(memoryPool, &_localData) {
-    _localData.type = Internals::JSON_NULL;
+    _localData.type = JSON_NULL;
   }
 
  private:
-  Internals::JsonVariantData _localData;
+  JsonVariantData _localData;
 };
-}  // namespace ArduinoJson
+}  // namespace ARDUINOJSON_NAMESPACE