feedc0de/ArduinoJson
1
0
Fork 0
forked from bblanchon/ArduinoJson
Code Pull Requests Activity

Kept only two namespaces ArduinoJson and ArduinoJson::Internals

Browse Source
This commit is contained in:
Benoit Blanchon
2018-01-19 08:32:15 +01:00
parent bae179ed67
commit e390587e91
53 changed files with 241 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/ArduinoJson/Data/ValueSaver.hpp
View File

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

9
src/ArduinoJson/Deserialization/JsonParser.hpp
View File

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

3
src/ArduinoJson/Deserialization/JsonParserImpl.hpp
View File

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

5
src/ArduinoJson/DynamicJsonBuffer.hpp
View File

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

9
src/ArduinoJson/JsonArray.hpp
View File

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

36
src/ArduinoJson/JsonArraySubscript.hpp
View File

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

4
src/ArduinoJson/JsonBuffer.hpp
View File

@ -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);
}
//

14
src/ArduinoJson/JsonBufferBase.hpp
View File

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

33
src/ArduinoJson/JsonObject.hpp
View File

@ -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,15 +54,16 @@ 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.
@ -66,17 +71,19 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
// 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));
}

18
src/ArduinoJson/JsonObjectSubscript.hpp
View File

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

102
src/ArduinoJson/JsonVariant.hpp
View File

@ -36,7 +36,7 @@ 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 JsonVariantBase<JsonVariant> {
class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
template <typename Print>
friend class Internals::JsonSerializer;
@ -56,8 +56,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// JsonVariant(double value);
// JsonVariant(float value);
template <typename T>
JsonVariant(T value, typename TypeTraits::EnableIf<
TypeTraits::IsFloatingPoint<T>::value>::type * = 0) {
JsonVariant(T value, typename Internals::EnableIf<
Internals::IsFloatingPoint<T>::value>::type * = 0) {
using namespace Internals;
_type = JSON_FLOAT;
_content.asFloat = static_cast<JsonFloat>(value);
@ -65,8 +65,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
template <typename T>
DEPRECATED("Second argument is not supported anymore")
JsonVariant(T value, uint8_t,
typename TypeTraits::EnableIf<
TypeTraits::IsFloatingPoint<T>::value>::type * = 0) {
typename Internals::EnableIf<
Internals::IsFloatingPoint<T>::value>::type * = 0) {
using namespace Internals;
_type = JSON_FLOAT;
_content.asFloat = static_cast<JsonFloat>(value);
@ -79,9 +79,11 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// JsonVariant(signed long)
// JsonVariant(signed char)
template <typename T>
JsonVariant(T value, typename TypeTraits::EnableIf<
TypeTraits::IsSignedIntegral<T>::value ||
TypeTraits::IsSame<T, char>::value>::type * = 0) {
JsonVariant(
T value,
typename Internals::EnableIf<Internals::IsSignedIntegral<T>::value ||
Internals::IsSame<T, char>::value>::type * =
0) {
using namespace Internals;
if (value >= 0) {
_type = JSON_POSITIVE_INTEGER;
@ -96,8 +98,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// JsonVariant(unsigned long)
template <typename T>
JsonVariant(T value,
typename TypeTraits::EnableIf<
TypeTraits::IsUnsignedIntegral<T>::value>::type * = 0) {
typename Internals::EnableIf<
Internals::IsUnsignedIntegral<T>::value>::type * = 0) {
using namespace Internals;
_type = JSON_POSITIVE_INTEGER;
_content.asInteger = static_cast<JsonUInt>(value);
@ -110,7 +112,7 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
template <typename TChar>
JsonVariant(
const TChar *value,
typename TypeTraits::EnableIf<TypeTraits::IsChar<TChar>::value>::type * =
typename Internals::EnableIf<Internals::IsChar<TChar>::value>::type * =
0) {
_type = Internals::JSON_STRING;
_content.asString = reinterpret_cast<const char *>(value);
@ -144,14 +146,13 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// unsigned int as<unsigned int>() const;
// unsigned long as<unsigned long>() const;
template <typename T>
const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value, T>::type
const typename Internals::EnableIf<Internals::IsIntegral<T>::value, T>::type
as() const {
return variantAsInteger<T>();
}
// bool as<bool>() const
template <typename T>
const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
T>::type
const typename Internals::EnableIf<Internals::IsSame<T, bool>::value, T>::type
as() const {
return variantAsInteger<int>() != 0;
}
@ -159,8 +160,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// double as<double>() const;
// float as<float>() const;
template <typename T>
const typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
T>::type
const typename Internals::EnableIf<Internals::IsFloatingPoint<T>::value,
T>::type
as() const {
return variantAsFloat<T>();
}
@ -168,9 +169,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// const char* as<const char*>() const;
// const char* as<char*>() const;
template <typename T>
typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
TypeTraits::IsSame<T, char *>::value,
const char *>::type
typename Internals::EnableIf<Internals::IsSame<T, const char *>::value ||
Internals::IsSame<T, char *>::value,
const char *>::type
as() const {
return variantAsString();
}
@ -178,7 +179,7 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// std::string as<std::string>() const;
// String as<String>() const;
template <typename T>
typename TypeTraits::EnableIf<Internals::StringTraits<T>::has_append, T>::type
typename Internals::EnableIf<Internals::StringTraits<T>::has_append, T>::type
as() const {
const char *cstr = variantAsString();
if (cstr) return T(cstr);
@ -190,9 +191,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// JsonArray& as<JsonArray> const;
// JsonArray& as<JsonArray&> const;
template <typename T>
typename TypeTraits::EnableIf<
TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
JsonArray>::value,
typename Internals::EnableIf<
Internals::IsSame<typename Internals::RemoveReference<T>::type,
JsonArray>::value,
JsonArray &>::type
as() const {
return variantAsArray();
@ -200,9 +201,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
//
// const JsonArray& as<const JsonArray&> const;
template <typename T>
typename TypeTraits::EnableIf<
TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
const JsonArray>::value,
typename Internals::EnableIf<
Internals::IsSame<typename Internals::RemoveReference<T>::type,
const JsonArray>::value,
const JsonArray &>::type
as() const {
return variantAsArray();
@ -211,9 +212,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// JsonObject& as<JsonObject> const;
// JsonObject& as<JsonObject&> const;
template <typename T>
typename TypeTraits::EnableIf<
TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
JsonObject>::value,
typename Internals::EnableIf<
Internals::IsSame<typename Internals::RemoveReference<T>::type,
JsonObject>::value,
JsonObject &>::type
as() const {
return variantAsObject();
@ -222,9 +223,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// JsonObject& as<const JsonObject> const;
// JsonObject& as<const JsonObject&> const;
template <typename T>
typename TypeTraits::EnableIf<
TypeTraits::IsSame<typename TypeTraits::RemoveReference<T>::type,
const JsonObject>::value,
typename Internals::EnableIf<
Internals::IsSame<typename Internals::RemoveReference<T>::type,
const JsonObject>::value,
const JsonObject &>::type
as() const {
return variantAsObject();
@ -232,8 +233,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
//
// JsonVariant as<JsonVariant> const;
template <typename T>
typename TypeTraits::EnableIf<TypeTraits::IsSame<T, JsonVariant>::value,
T>::type
typename Internals::EnableIf<Internals::IsSame<T, JsonVariant>::value,
T>::type
as() const {
return *this;
}
@ -251,23 +252,22 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// bool is<unsigned int>() const;
// bool is<unsigned long>() const;
template <typename T>
typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value, bool>::type
is() const {
typename Internals::EnableIf<Internals::IsIntegral<T>::value, bool>::type is()
const {
return variantIsInteger();
}
//
// bool is<double>() const;
// bool is<float>() const;
template <typename T>
typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
bool>::type
typename Internals::EnableIf<Internals::IsFloatingPoint<T>::value, bool>::type
is() const {
return variantIsFloat();
}
//
// bool is<bool>() const
template <typename T>
typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value, bool>::type
typename Internals::EnableIf<Internals::IsSame<T, bool>::value, bool>::type
is() const {
return variantIsBoolean();
}
@ -275,9 +275,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// bool is<const char*>() const;
// bool is<char*>() const;
template <typename T>
typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
TypeTraits::IsSame<T, char *>::value,
bool>::type
typename Internals::EnableIf<Internals::IsSame<T, const char *>::value ||
Internals::IsSame<T, char *>::value,
bool>::type
is() const {
return variantIsString();
}
@ -286,11 +286,10 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// bool is<JsonArray&> const;
// bool is<const JsonArray&> const;
template <typename T>
typename TypeTraits::EnableIf<
TypeTraits::IsSame<
typename TypeTraits::RemoveConst<
typename TypeTraits::RemoveReference<T>::type>::type,
JsonArray>::value,
typename Internals::EnableIf<
Internals::IsSame<typename Internals::RemoveConst<
typename Internals::RemoveReference<T>::type>::type,
JsonArray>::value,
bool>::type
is() const {
return variantIsArray();
@ -300,11 +299,10 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
// bool is<JsonObject&> const;
// bool is<const JsonObject&> const;
template <typename T>
typename TypeTraits::EnableIf<
TypeTraits::IsSame<
typename TypeTraits::RemoveConst<
typename TypeTraits::RemoveReference<T>::type>::type,
JsonObject>::value,
typename Internals::EnableIf<
Internals::IsSame<typename Internals::RemoveConst<
typename Internals::RemoveReference<T>::type>::type,
JsonObject>::value,
bool>::type
is() const {
return variantIsObject();

6
src/ArduinoJson/JsonVariantBase.hpp
View File

@ -11,12 +11,14 @@
#include "Serialization/JsonPrintable.hpp"
namespace ArduinoJson {
namespace Internals {
template <typename TImpl>
class JsonVariantBase : public Internals::JsonPrintable<TImpl>,
class JsonVariantBase : public JsonPrintable<TImpl>,
public JsonVariantCasts<TImpl>,
public JsonVariantComparisons<TImpl>,
public JsonVariantOr<TImpl>,
public JsonVariantSubscripts<TImpl>,
public TypeTraits::JsonVariantTag {};
public JsonVariantTag {};
}
}

2
src/ArduinoJson/JsonVariantCasts.hpp
View File

@ -8,6 +8,7 @@
#include "Polyfills/attributes.hpp"
namespace ArduinoJson {
namespace Internals {
template <typename TImpl>
class JsonVariantCasts {
@ -55,3 +56,4 @@ class JsonVariantCasts {
}
};
}
}

30
src/ArduinoJson/JsonVariantComparisons.hpp
View File

@ -9,6 +9,7 @@
#include "TypeTraits/IsVariant.hpp"
namespace ArduinoJson {
namespace Internals {
template <typename TImpl>
class JsonVariantComparisons {
@ -20,10 +21,8 @@ class JsonVariantComparisons {
}
template <typename TComparand>
friend
typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value,
bool>::type
operator==(TComparand comparand, const JsonVariantComparisons &variant) {
friend typename EnableIf<!IsVariant<TComparand>::value, bool>::type
operator==(TComparand comparand, const JsonVariantComparisons &variant) {
return variant.equals(comparand);
}
@ -34,10 +33,8 @@ class JsonVariantComparisons {
}
template <typename TComparand>
friend
typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value,
bool>::type
operator!=(TComparand comparand, const JsonVariantComparisons &variant) {
friend typename EnableIf<!IsVariant<TComparand>::value, bool>::type
operator!=(TComparand comparand, const JsonVariantComparisons &variant) {
return !variant.equals(comparand);
}
@ -94,7 +91,7 @@ class JsonVariantComparisons {
}
template <typename T>
const typename Internals::JsonVariantAs<T>::type as() const {
const typename JsonVariantAs<T>::type as() const {
return impl()->template as<T>();
}
@ -104,18 +101,16 @@ class JsonVariantComparisons {
}
template <typename TString>
typename TypeTraits::EnableIf<Internals::StringTraits<TString>::has_equals,
bool>::type
equals(const TString &comparand) const {
typename EnableIf<StringTraits<TString>::has_equals, bool>::type equals(
const TString &comparand) const {
const char *value = as<const char *>();
return Internals::StringTraits<TString>::equals(comparand, value);
return StringTraits<TString>::equals(comparand, value);
}
template <typename TComparand>
typename TypeTraits::EnableIf<
!TypeTraits::IsVariant<TComparand>::value &&
!Internals::StringTraits<TComparand>::has_equals,
bool>::type
typename EnableIf<!IsVariant<TComparand>::value &&
!StringTraits<TComparand>::has_equals,
bool>::type
equals(const TComparand &comparand) const {
return as<TComparand>() == comparand;
}
@ -140,3 +135,4 @@ class JsonVariantComparisons {
}
};
}
}

8
src/ArduinoJson/JsonVariantImpl.hpp
View File

@ -58,7 +58,7 @@ inline T JsonVariant::variantAsInteger() const {
return T(~_content.asInteger + 1);
case JSON_STRING:
case JSON_UNPARSED:
return Polyfills::parseInteger<T>(_content.asString);
return parseInteger<T>(_content.asString);
default:
return T(_content.asFloat);
}
@ -86,7 +86,7 @@ inline T JsonVariant::variantAsFloat() const {
return -static_cast<T>(_content.asInteger);
case JSON_STRING:
case JSON_UNPARSED:
return Polyfills::parseFloat<T>(_content.asString);
return parseFloat<T>(_content.asString);
default:
return static_cast<T>(_content.asFloat);
}
@ -106,7 +106,7 @@ inline bool JsonVariant::variantIsInteger() const {
using namespace Internals;
return _type == JSON_POSITIVE_INTEGER || _type == JSON_NEGATIVE_INTEGER ||
(_type == JSON_UNPARSED && Polyfills::isInteger(_content.asString));
(_type == JSON_UNPARSED && isInteger(_content.asString));
}
inline bool JsonVariant::variantIsFloat() const {
@ -114,7 +114,7 @@ inline bool JsonVariant::variantIsFloat() const {
return _type == JSON_FLOAT || _type == JSON_POSITIVE_INTEGER ||
_type == JSON_NEGATIVE_INTEGER ||
(_type == JSON_UNPARSED && Polyfills::isFloat(_content.asString));
(_type == JSON_UNPARSED && isFloat(_content.asString));
}
#if ARDUINOJSON_ENABLE_STD_STREAM

2
src/ArduinoJson/JsonVariantOr.hpp
View File

@ -8,6 +8,7 @@
#include "Polyfills/attributes.hpp"
namespace ArduinoJson {
namespace Internals {
template <typename TImpl>
class JsonVariantOr {
@ -34,3 +35,4 @@ class JsonVariantOr {
}
};
}
}

28
src/ArduinoJson/JsonVariantSubscripts.hpp
View File

@ -10,6 +10,7 @@
#include "TypeTraits/EnableIf.hpp"
namespace ArduinoJson {
namespace Internals {
// Forward declarations.
class JsonArraySubscript;
@ -41,19 +42,18 @@ class JsonVariantSubscripts {
// const JsonObjectSubscript operator[](TKey) const;
// TKey = const std::string&, const String&
template <typename TString>
FORCE_INLINE typename TypeTraits::EnableIf<
Internals::StringTraits<TString>::has_equals,
const JsonObjectSubscript<const TString &> >::type
operator[](const TString &key) const {
FORCE_INLINE
typename EnableIf<StringTraits<TString>::has_equals,
const JsonObjectSubscript<const TString &> >::type
operator[](const TString &key) const {
return impl()->template as<JsonObject>()[key];
}
//
// const JsonObjectSubscript operator[](TKey) const;
// TKey = const std::string&, const String&
template <typename TString>
FORCE_INLINE typename TypeTraits::EnableIf<
Internals::StringTraits<TString>::has_equals,
JsonObjectSubscript<const TString &> >::type
FORCE_INLINE typename EnableIf<StringTraits<TString>::has_equals,
JsonObjectSubscript<const TString &> >::type
operator[](const TString &key) {
return impl()->template as<JsonObject>()[key];
}
@ -61,9 +61,8 @@ class JsonVariantSubscripts {
// JsonObjectSubscript operator[](TKey);
// TKey = const char*, const char[N], const FlashStringHelper*
template <typename TString>
FORCE_INLINE typename TypeTraits::EnableIf<
Internals::StringTraits<const TString *>::has_equals,
JsonObjectSubscript<const TString *> >::type
FORCE_INLINE typename EnableIf<StringTraits<const TString *>::has_equals,
JsonObjectSubscript<const TString *> >::type
operator[](const TString *key) {
return impl()->template as<JsonObject>()[key];
}
@ -71,10 +70,10 @@ class JsonVariantSubscripts {
// JsonObjectSubscript operator[](TKey);
// TKey = const char*, const char[N], const FlashStringHelper*
template <typename TString>
FORCE_INLINE typename TypeTraits::EnableIf<
Internals::StringTraits<TString *>::has_equals,
const JsonObjectSubscript<const TString *> >::type
operator[](const TString *key) const {
FORCE_INLINE
typename EnableIf<StringTraits<TString *>::has_equals,
const JsonObjectSubscript<const TString *> >::type
operator[](const TString *key) const {
return impl()->template as<JsonObject>()[key];
}
@ -84,3 +83,4 @@ class JsonVariantSubscripts {
}
};
}
}

2
src/ArduinoJson/Polyfills/ctype.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace Polyfills {
namespace Internals {
inline bool isdigit(char c) {
return '0' <= c && c <= '9';

2
src/ArduinoJson/Polyfills/isFloat.hpp
View File

@ -8,7 +8,7 @@
#include "./ctype.hpp"
namespace ArduinoJson {
namespace Polyfills {
namespace Internals {
inline bool isFloat(const char* s) {
if (!s) return false;

2
src/ArduinoJson/Polyfills/isInteger.hpp
View File

@ -7,7 +7,7 @@
#include "./ctype.hpp"
namespace ArduinoJson {
namespace Polyfills {
namespace Internals {
inline bool isInteger(const char* s) {
if (!s) return false;

2
src/ArduinoJson/Polyfills/math.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace Polyfills {
namespace Internals {
template <typename T>
bool isNaN(T x) {
return x != x;

4
src/ArduinoJson/Polyfills/parseFloat.hpp
View File

@ -9,11 +9,11 @@
#include "./math.hpp"
namespace ArduinoJson {
namespace Polyfills {
namespace Internals {
template <typename T>
inline T parseFloat(const char* s) {
typedef TypeTraits::FloatTraits<T> traits;
typedef FloatTraits<T> traits;
typedef typename traits::mantissa_type mantissa_t;
typedef typename traits::exponent_type exponent_t;

2
src/ArduinoJson/Polyfills/parseInteger.hpp
View File

@ -10,7 +10,7 @@
#include "./ctype.hpp"
namespace ArduinoJson {
namespace Polyfills {
namespace Internals {
template <typename T>
T parseInteger(const char *s) {
if (!s) return 0; // NULL

2
src/ArduinoJson/Serialization/FloatParts.hpp
View File

@ -56,7 +56,7 @@ struct FloatParts {
}
static int16_t normalize(TFloat& value) {
typedef TypeTraits::FloatTraits<TFloat> traits;
typedef FloatTraits<TFloat> traits;
int16_t powersOf10 = 0;
int8_t index = sizeof(TFloat) == 8 ? 8 : 5;

12
src/ArduinoJson/Serialization/JsonPrintable.hpp
View File

@ -29,8 +29,8 @@ template <typename T>
class JsonPrintable {
public:
template <typename Print>
typename TypeTraits::EnableIf<!StringTraits<Print>::has_append, size_t>::type
printTo(Print &print) const {
typename EnableIf<!StringTraits<Print>::has_append, size_t>::type printTo(
Print &print) const {
JsonWriter<Print> writer(print);
JsonSerializer<JsonWriter<Print> >::serialize(downcast(), writer);
return writer.bytesWritten();
@ -55,8 +55,8 @@ class JsonPrintable {
}
template <typename TString>
typename TypeTraits::EnableIf<StringTraits<TString>::has_append, size_t>::type
printTo(TString &str) const {
typename EnableIf<StringTraits<TString>::has_append, size_t>::type printTo(
TString &str) const {
DynamicStringBuilder<TString> sb(str);
return printTo(sb);
}
@ -78,14 +78,14 @@ class JsonPrintable {
}
template <typename Print>
typename TypeTraits::EnableIf<!StringTraits<Print>::has_append, size_t>::type
typename EnableIf<!StringTraits<Print>::has_append, size_t>::type
prettyPrintTo(Print &print) const {
IndentedPrint<Print> indentedPrint(print);
return prettyPrintTo(indentedPrint);
}
template <typename TString>
typename TypeTraits::EnableIf<StringTraits<TString>::has_append, size_t>::type
typename EnableIf<StringTraits<TString>::has_append, size_t>::type
prettyPrintTo(TString &str) const {
DynamicStringBuilder<TString> sb(str);
return prettyPrintTo(sb);

7
src/ArduinoJson/Serialization/JsonSerializer.hpp
View File

@ -9,14 +9,15 @@
namespace ArduinoJson {
class JsonArray;
class JsonArraySubscript;
class JsonObject;
template <typename TKey>
class JsonObjectSubscript;
class JsonVariant;
namespace Internals {
class JsonArraySubscript;
template <typename TKey>
class JsonObjectSubscript;
template <typename Writer>
class JsonSerializer {
public:

4
src/ArduinoJson/Serialization/JsonWriter.hpp
View File

@ -79,14 +79,14 @@ class JsonWriter {
template <typename TFloat>
void writeFloat(TFloat value) {
if (Polyfills::isNaN(value)) return writeRaw("NaN");
if (isNaN(value)) return writeRaw("NaN");
if (value < 0.0) {
writeRaw('-');
value = -value;
}
if (Polyfills::isInfinity(value)) return writeRaw("Infinity");
if (isInfinity(value)) return writeRaw("Infinity");
FloatParts<TFloat> parts(value);

7
src/ArduinoJson/StaticJsonBuffer.hpp
View File

@ -7,6 +7,7 @@
#include "JsonBufferBase.hpp"
namespace ArduinoJson {
namespace Internals {
class StaticJsonBufferBase : public JsonBufferBase<StaticJsonBufferBase> {
public:
@ -90,6 +91,7 @@ class StaticJsonBufferBase : public JsonBufferBase<StaticJsonBufferBase> {
size_t _capacity;
size_t _size;
};
}
#if defined(__clang__)
#pragma clang diagnostic push
@ -105,9 +107,10 @@ class StaticJsonBufferBase : public JsonBufferBase<StaticJsonBufferBase> {
// The template paramenter CAPACITY specifies the capacity of the buffer in
// bytes.
template <size_t CAPACITY>
class StaticJsonBuffer : public StaticJsonBufferBase {
class StaticJsonBuffer : public Internals::StaticJsonBufferBase {
public:
explicit StaticJsonBuffer() : StaticJsonBufferBase(_buffer, CAPACITY) {}
explicit StaticJsonBuffer()
: Internals::StaticJsonBufferBase(_buffer, CAPACITY) {}
private:
char _buffer[CAPACITY];

10
src/ArduinoJson/StringTraits/ArduinoStream.hpp
View File

@ -49,11 +49,11 @@ struct ArduinoStreamTraits {
};
template <typename TStream>
struct StringTraits<TStream,
// match any type that is derived from Stream:
typename TypeTraits::EnableIf<TypeTraits::IsBaseOf<
Stream, typename TypeTraits::RemoveReference<
TStream>::type>::value>::type>
struct StringTraits<
TStream,
// match any type that is derived from Stream:
typename EnableIf<
IsBaseOf<Stream, typename RemoveReference<TStream>::type>::value>::type>
: ArduinoStreamTraits {};
}
}

5
src/ArduinoJson/StringTraits/CharPointer.hpp
View File

@ -50,14 +50,13 @@ struct CharPointerTraits {
static const bool has_append = false;
static const bool has_equals = true;
static const bool should_duplicate = !TypeTraits::IsConst<TChar>::value;
static const bool should_duplicate = !IsConst<TChar>::value;
};
// char*, unsigned char*, signed char*
// const char*, const unsigned char*, const signed char*
template <typename TChar>
struct StringTraits<TChar*, typename TypeTraits::EnableIf<
TypeTraits::IsChar<TChar>::value>::type>
struct StringTraits<TChar*, typename EnableIf<IsChar<TChar>::value>::type>
: CharPointerTraits<TChar> {};
}
}

10
src/ArduinoJson/StringTraits/StdStream.hpp
View File

@ -48,11 +48,11 @@ struct StdStreamTraits {
};
template <typename TStream>
struct StringTraits<TStream,
// match any type that is derived from std::istream:
typename TypeTraits::EnableIf<TypeTraits::IsBaseOf<
std::istream, typename TypeTraits::RemoveReference<
TStream>::type>::value>::type>
struct StringTraits<
TStream,
// match any type that is derived from std::istream:
typename EnableIf<IsBaseOf<
std::istream, typename RemoveReference<TStream>::type>::value>::type>
: StdStreamTraits {};
}
}

2
src/ArduinoJson/TypeTraits/EnableIf.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that return the type T if Condition is true.
template <bool Condition, typename T = void>

2
src/ArduinoJson/TypeTraits/FloatTraits.hpp
View File

@ -10,7 +10,7 @@
#include "../Polyfills/math.hpp"
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
template <typename T, size_t = sizeof(T)>
struct FloatTraits {};

2
src/ArduinoJson/TypeTraits/IsArray.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that return the type T without the const modifier
template <typename T>

2
src/ArduinoJson/TypeTraits/IsBaseOf.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that returns true if Derived inherits from TBase is an
// integral type.

2
src/ArduinoJson/TypeTraits/IsChar.hpp
View File

@ -7,7 +7,7 @@
#include "IsSame.hpp"
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that returns true if T is a charater
template <typename T>

2
src/ArduinoJson/TypeTraits/IsConst.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that return the type T without the const modifier
template <typename T>

2
src/ArduinoJson/TypeTraits/IsFloatingPoint.hpp
View File

@ -7,7 +7,7 @@
#include "IsSame.hpp"
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that returns true if T is a floating point type
template <typename T>

8
src/ArduinoJson/TypeTraits/IsIntegral.hpp
View File

@ -9,14 +9,14 @@
#include "IsUnsignedIntegral.hpp"
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that returns true if T is an integral type.
template <typename T>
struct IsIntegral {
static const bool value = TypeTraits::IsSignedIntegral<T>::value ||
TypeTraits::IsUnsignedIntegral<T>::value ||
TypeTraits::IsSame<T, char>::value;
static const bool value = IsSignedIntegral<T>::value ||
IsUnsignedIntegral<T>::value ||
IsSame<T, char>::value;
// CAUTION: differs from std::is_integral as it doesn't include bool
};

2
src/ArduinoJson/TypeTraits/IsSame.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that returns true if types T and U are the same.
template <typename T, typename U>

16
src/ArduinoJson/TypeTraits/IsSignedIntegral.hpp
View File

@ -8,23 +8,21 @@
#include "IsSame.hpp"
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that returns true if T is an integral type.
template <typename T>
struct IsSignedIntegral {
static const bool value = TypeTraits::IsSame<T, signed char>::value ||
TypeTraits::IsSame<T, signed short>::value ||
TypeTraits::IsSame<T, signed int>::value ||
TypeTraits::IsSame<T, signed long>::value ||
static const bool value =
IsSame<T, signed char>::value || IsSame<T, signed short>::value ||
IsSame<T, signed int>::value || IsSame<T, signed long>::value ||
#if ARDUINOJSON_USE_LONG_LONG
TypeTraits::IsSame<T, signed long long>::value ||
IsSame<T, signed long long>::value ||
#endif
#if ARDUINOJSON_USE_INT64
TypeTraits::IsSame<T, signed __int64>::value ||
IsSame<T, signed __int64>::value ||
#endif
false;
false;
};
}
}

16
src/ArduinoJson/TypeTraits/IsUnsignedIntegral.hpp
View File

@ -8,23 +8,21 @@
#include "IsSame.hpp"
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that returns true if T is an integral type.
template <typename T>
struct IsUnsignedIntegral {
static const bool value = TypeTraits::IsSame<T, unsigned char>::value ||
TypeTraits::IsSame<T, unsigned short>::value ||
TypeTraits::IsSame<T, unsigned int>::value ||
TypeTraits::IsSame<T, unsigned long>::value ||
static const bool value =
IsSame<T, unsigned char>::value || IsSame<T, unsigned short>::value ||
IsSame<T, unsigned int>::value || IsSame<T, unsigned long>::value ||
#if ARDUINOJSON_USE_LONG_LONG
TypeTraits::IsSame<T, unsigned long long>::value ||
IsSame<T, unsigned long long>::value ||
#endif
#if ARDUINOJSON_USE_INT64
TypeTraits::IsSame<T, unsigned __int64>::value ||
IsSame<T, unsigned __int64>::value ||
#endif
false;
false;
};
}
}

2
src/ArduinoJson/TypeTraits/IsVariant.hpp
View File

@ -7,7 +7,7 @@
#include "IsBaseOf.hpp"
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
class JsonVariantTag {};

2
src/ArduinoJson/TypeTraits/RemoveConst.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that return the type T without the const modifier
template <typename T>

2
src/ArduinoJson/TypeTraits/RemoveReference.hpp
View File

@ -5,7 +5,7 @@
#pragma once
namespace ArduinoJson {
namespace TypeTraits {
namespace Internals {
// A meta-function that return the type T without the reference modifier.
template <typename T>

2
test/DynamicJsonBuffer/alloc.cpp
View File

@ -6,6 +6,8 @@
#include <catch.hpp>
#include <sstream>
using namespace ArduinoJson::Internals;
static bool isAligned(void* ptr) {
const size_t mask = sizeof(void*) - 1;
size_t addr = reinterpret_cast<size_t>(ptr);

2
test/DynamicJsonBuffer/no_memory.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h>
#include <catch.hpp>
using namespace ArduinoJson::Internals;
struct NoMemoryAllocator {
void* allocate(size_t) {
return NULL;

2
test/Misc/TypeTraits.cpp
View File

@ -5,7 +5,7 @@
#include <ArduinoJson.h>
#include <catch.hpp>
using namespace ArduinoJson::TypeTraits;
using namespace ArduinoJson::Internals;
TEST_CASE("TypeTraits") {
SECTION("IsBaseOf") {

2
test/Polyfills/isFloat.cpp
View File

@ -5,7 +5,7 @@
#include <ArduinoJson/Polyfills/isFloat.hpp>
#include <catch.hpp>
using namespace ArduinoJson::Polyfills;
using namespace ArduinoJson::Internals;
TEST_CASE("isFloat()") {
SECTION("Input is NULL") {

2
test/Polyfills/isInteger.cpp
View File

@ -5,7 +5,7 @@
#include <ArduinoJson/Polyfills/isInteger.hpp>
#include <catch.hpp>
using namespace ArduinoJson::Polyfills;
using namespace ArduinoJson::Internals;
TEST_CASE("isInteger()") {
SECTION("Null") {

2
test/Polyfills/parseFloat.cpp
View File

@ -5,7 +5,7 @@
#include <ArduinoJson/Polyfills/parseFloat.hpp>
#include <catch.hpp>
using namespace ArduinoJson::Polyfills;
using namespace ArduinoJson::Internals;
template <typename T>
void check(const char* input, T expected) {

2
test/Polyfills/parseInteger.cpp
View File

@ -6,7 +6,7 @@
#include <ArduinoJson/Polyfills/parseInteger.hpp>
#include <catch.hpp>
using namespace ArduinoJson::Polyfills;
using namespace ArduinoJson::Internals;
template <typename T>
void check(const char* input, T expected) {

2
test/StaticJsonBuffer/startString.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h>
#include <catch.hpp>
using namespace ArduinoJson::Internals;
TEST_CASE("StaticJsonBuffer::startString()") {
SECTION("WorksWhenBufferIsBigEnough") {
StaticJsonBuffer<6> jsonBuffer;