Implemented reference semantics for JsonVariant

This commit is contained in:
Benoit Blanchon
2018-08-21 17:56:16 +02:00
parent 0454bd1ef6
commit 9cbc891816
53 changed files with 1196 additions and 839 deletions

View File

@ -4,6 +4,8 @@
#pragma once
#include <stdlib.h> // size_t
#include "JsonFloat.hpp"
#include "JsonInteger.hpp"

View File

@ -0,0 +1,181 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#pragma once
#include "../Numbers/parseFloat.hpp"
#include "../Numbers/parseInteger.hpp"
#include "JsonVariantContent.hpp"
#include "JsonVariantType.hpp"
namespace ArduinoJson {
namespace Internals {
struct JsonVariantData {
JsonVariantType type;
JsonVariantContent content;
void setBoolean(bool value) {
type = JSON_BOOLEAN;
content.asInteger = static_cast<JsonUInt>(value);
}
void setFloat(JsonFloat value) {
type = JSON_FLOAT;
content.asFloat = value;
}
void setInteger(JsonInteger value) {
if (value > 0)
setPostiveInteger(static_cast<JsonUInt>(value));
else
setNegativeInteger(static_cast<JsonUInt>(-value));
}
void setNegativeInteger(JsonUInt value) {
type = JSON_NEGATIVE_INTEGER;
content.asInteger = value;
}
void setPostiveInteger(JsonUInt value) {
type = JSON_POSITIVE_INTEGER;
content.asInteger = value;
}
void setString(const char *value) {
type = JSON_STRING;
content.asString = value;
}
void setRaw(const char *data, size_t size) {
type = JSON_RAW;
content.asRaw.data = data;
content.asRaw.size = size;
}
void setNull() {
type = JSON_NULL;
}
void setArray(JsonArrayData &array) {
type = JSON_ARRAY;
content.asArray = &array;
}
void setObject(JsonObjectData &object) {
type = JSON_OBJECT;
content.asObject = &object;
}
JsonArrayData *asArray() const {
return type == JSON_ARRAY ? content.asArray : 0;
}
JsonObjectData *asObject() const {
return type == JSON_OBJECT ? content.asObject : 0;
}
template <typename T>
T asInteger() const {
switch (type) {
case JSON_NULL:
case JSON_RAW:
return 0;
case JSON_POSITIVE_INTEGER:
case JSON_BOOLEAN:
return T(content.asInteger);
case JSON_NEGATIVE_INTEGER:
return T(~content.asInteger + 1);
case JSON_STRING:
return parseInteger<T>(content.asString);
default:
return T(content.asFloat);
}
}
template <typename T>
T asFloat() const {
switch (type) {
case JSON_NULL:
case JSON_RAW:
return 0;
case JSON_POSITIVE_INTEGER:
case JSON_BOOLEAN:
return static_cast<T>(content.asInteger);
case JSON_NEGATIVE_INTEGER:
return -static_cast<T>(content.asInteger);
case JSON_STRING:
return parseFloat<T>(content.asString);
default:
return static_cast<T>(content.asFloat);
}
}
const char *asString() const {
return type == JSON_STRING ? content.asString : NULL;
}
bool isArray() const {
return type == Internals::JSON_ARRAY;
}
bool isBoolean() const {
return type == JSON_BOOLEAN;
}
bool isFloat() const {
return type == JSON_FLOAT || type == JSON_POSITIVE_INTEGER ||
type == JSON_NEGATIVE_INTEGER;
}
bool isInteger() const {
return type == JSON_POSITIVE_INTEGER || type == JSON_NEGATIVE_INTEGER;
}
bool isNull() const {
return type == JSON_NULL;
}
bool isObject() const {
return type == Internals::JSON_OBJECT;
}
bool isString() const {
return type == Internals::JSON_STRING;
}
template <typename Visitor>
void visit(Visitor &visitor) const {
switch (type) {
case JSON_FLOAT:
return visitor.acceptFloat(content.asFloat);
case JSON_ARRAY:
return visitor.acceptArray(*content.asArray);
case JSON_OBJECT:
return visitor.acceptObject(*content.asObject);
case JSON_STRING:
return visitor.acceptString(content.asString);
case JSON_RAW:
return visitor.acceptRawJson(content.asRaw.data, content.asRaw.size);
case JSON_NEGATIVE_INTEGER:
return visitor.acceptNegativeInteger(content.asInteger);
case JSON_POSITIVE_INTEGER:
return visitor.acceptPositiveInteger(content.asInteger);
case JSON_BOOLEAN:
return visitor.acceptBoolean(content.asInteger != 0);
default:
return visitor.acceptNull();
}
}
};
} // namespace Internals
} // namespace ArduinoJson

View File

@ -1,23 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#pragma once
namespace ArduinoJson {
namespace Internals {
template <typename T>
struct JsonVariantDefault {
static T get() {
return T();
}
};
template <typename T>
struct JsonVariantDefault<const T> : JsonVariantDefault<T> {};
template <typename T>
struct JsonVariantDefault<T&> : JsonVariantDefault<T> {};
}
}

View File

@ -11,10 +11,10 @@ namespace Internals {
// Enumerated type to know the current type of a JsonVariant.
// The value determines which member of JsonVariantContent is used.
enum JsonVariantType {
JSON_UNDEFINED, // JsonVariant has not been initialized
JSON_UNPARSED, // JsonVariant contains an unparsed string
JSON_STRING, // JsonVariant stores a const char*
JSON_BOOLEAN, // JsonVariant stores a bool
JSON_NULL, // JsonVariant has not been initialized
JSON_RAW, // JsonVariant contains a raw string that should not be escaped
JSON_STRING, // JsonVariant stores a const char*
JSON_BOOLEAN, // JsonVariant stores a bool
JSON_POSITIVE_INTEGER, // JsonVariant stores an JsonUInt
JSON_NEGATIVE_INTEGER, // JsonVariant stores an JsonUInt that must be negated
JSON_ARRAY, // JsonVariant stores a pointer to a JsonArrayData

View File

@ -22,7 +22,7 @@ class List {
typedef ListIterator<T> iterator;
typedef ListConstIterator<T> const_iterator;
explicit List(JsonBuffer *buf) : _buffer(buf), _firstNode(NULL) {}
List() : _firstNode(NULL) {}
// Returns the numbers of elements in the list.
// For a JsonObjectData, it would return the number of key-value pairs
@ -32,8 +32,8 @@ class List {
return nodeCount;
}
iterator add() {
node_type *newNode = new (_buffer) node_type();
iterator add(JsonBuffer *buffer) {
node_type *newNode = new (buffer) node_type();
if (_firstNode) {
node_type *lastNode = _firstNode;
@ -71,11 +71,6 @@ class List {
}
}
JsonBuffer &buffer() const {
return *_buffer;
}
JsonBuffer *_buffer; // TODO!!
protected:
void clear() {
_firstNode = 0;

View File

@ -1,53 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#pragma once
#include "../JsonVariant.hpp"
#include "../Memory/JsonBuffer.hpp"
#include "../Polyfills/type_traits.hpp"
#include "../Strings/StringTypes.hpp"
namespace ArduinoJson {
namespace Internals {
template <typename Source, typename Enable = void>
struct ValueSaver {
template <typename Destination>
static bool save(JsonBuffer*, Destination& destination, Source source) {
destination = source;
return true;
}
};
// We duplicate all strings except const char*
template <typename TString>
struct ValueSaver<
TString, typename enable_if<IsString<TString>::value &&
!is_same<const char*, TString>::value>::type> {
template <typename Destination>
static bool save(JsonBuffer* buffer, Destination& dest, TString source) {
const char* dup = makeString(source).save(buffer);
if (!dup) return false;
dest = dup;
return true;
}
};
// We duplicate all SerializedValue<T> except SerializedValue<const char*>
template <typename TString>
struct ValueSaver<
const SerializedValue<TString>&,
typename enable_if<!is_same<const char*, TString>::value>::type> {
template <typename Destination>
static bool save(JsonBuffer* buffer, Destination& dest,
const SerializedValue<TString>& source) {
const char* dup = makeString(source.data(), source.size()).save(buffer);
if (!dup) return false;
dest = SerializedValue<const char*>(dup, source.size());
return true;
}
};
} // namespace Internals
} // namespace ArduinoJson

View File

@ -35,7 +35,7 @@ deserialize(TDocument &doc, const TString &input) {
return makeDeserializer<TDeserializer>(&doc.buffer(), makeReader(input),
makeStringStorage(doc.buffer(), input),
doc.nestingLimit)
.parse(doc.template to<JsonVariant>());
.parse(doc.template to<JsonVariantData>());
}
//
// DeserializationError deserialize(TDocument& doc, TChar* input);
@ -48,7 +48,7 @@ DeserializationError deserialize(TDocument &doc, TChar *input) {
return makeDeserializer<TDeserializer>(&doc.buffer(), makeReader(input),
makeStringStorage(doc.buffer(), input),
doc.nestingLimit)
.parse(doc.template to<JsonVariant>());
.parse(doc.template to<JsonVariantData>());
}
//
// DeserializationError deserialize(TDocument& doc, TChar* input, size_t
@ -63,7 +63,7 @@ DeserializationError deserialize(TDocument &doc, TChar *input,
return makeDeserializer<TDeserializer>(
&doc.buffer(), makeReader(input, inputSize),
makeStringStorage(doc.buffer(), input), doc.nestingLimit)
.parse(doc.template to<JsonVariant>());
.parse(doc.template to<JsonVariantData>());
}
//
// DeserializationError deserialize(TDocument& doc, TStream input);
@ -76,7 +76,7 @@ DeserializationError deserialize(TDocument &doc, TStream &input) {
return makeDeserializer<TDeserializer>(&doc.buffer(), makeReader(input),
makeStringStorage(doc.buffer(), input),
doc.nestingLimit)
.parse(doc.template to<JsonVariant>());
.parse(doc.template to<JsonVariantData>());
}
} // namespace Internals
} // namespace ArduinoJson

View File

@ -12,24 +12,21 @@
namespace ArduinoJson {
class DynamicJsonDocument {
Internals::DynamicJsonBuffer _buffer;
JsonVariant _root;
public:
uint8_t nestingLimit;
DynamicJsonDocument() : nestingLimit(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
DynamicJsonDocument(size_t capacity)
: _buffer(capacity), nestingLimit(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}
: nestingLimit(ARDUINOJSON_DEFAULT_NESTING_LIMIT), _buffer(capacity) {}
template <typename T>
bool is() const {
return _root.is<T>();
return getVariant().is<T>();
}
template <typename T>
typename Internals::JsonVariantAs<T>::type as() const {
return _root.as<T>();
return getVariant().as<T>();
}
// JsonObject to<JsonObject>()
@ -39,7 +36,7 @@ class DynamicJsonDocument {
to() {
clear();
JsonObject object(&_buffer);
_root = object;
getVariant().set(object);
return object;
}
@ -50,17 +47,27 @@ class DynamicJsonDocument {
to() {
clear();
JsonArray array(&_buffer);
_root = array;
getVariant().set(array);
return array;
}
// JsonVariant& to<JsonVariant>()
// JsonVariant to<JsonVariant>()
template <typename T>
typename Internals::enable_if<Internals::is_same<T, JsonVariant>::value,
T&>::type
JsonVariant>::type
to() {
clear();
return _root;
return getVariant();
}
// JsonVariantData& to<JsonVariantData>()
template <typename T>
typename Internals::enable_if<
Internals::is_same<T, Internals::JsonVariantData>::value,
Internals::JsonVariantData&>::type
to() {
clear();
return _rootData;
}
Internals::DynamicJsonBuffer& buffer() {
@ -69,7 +76,7 @@ class DynamicJsonDocument {
void clear() {
_buffer.clear();
_root = JsonVariant();
_rootData.setNull();
}
size_t memoryUsage() const {
@ -78,7 +85,15 @@ class DynamicJsonDocument {
template <typename Visitor>
void visit(Visitor& visitor) const {
return _root.visit(visitor);
return _rootData.visit(visitor);
}
private:
JsonVariant getVariant() const {
return JsonVariant(&_buffer, &_rootData);
}
mutable Internals::DynamicJsonBuffer _buffer;
mutable Internals::JsonVariantData _rootData;
};
} // namespace ArduinoJson

View File

@ -7,6 +7,8 @@
#include "../Deserialization/deserialize.hpp"
#include "../JsonVariant.hpp"
#include "../Memory/JsonBuffer.hpp"
#include "../Numbers/isFloat.hpp"
#include "../Numbers/isInteger.hpp"
#include "../Polyfills/type_traits.hpp"
#include "./EscapeSequence.hpp"
@ -23,7 +25,7 @@ class JsonDeserializer {
_stringStorage(stringStorage),
_nestingLimit(nestingLimit),
_loaded(false) {}
DeserializationError parse(JsonVariant &variant) {
DeserializationError parse(JsonVariantData &variant) {
DeserializationError err = skipSpacesAndComments();
if (err) return err;
@ -63,12 +65,12 @@ class JsonDeserializer {
return true;
}
DeserializationError parseArray(JsonVariant &variant) {
DeserializationError parseArray(JsonVariantData &variant) {
if (_nestingLimit == 0) return DeserializationError::TooDeep;
JsonArray array(_buffer);
if (array.isNull()) return DeserializationError::NoMemory;
variant = array;
JsonArrayData *array = new (_buffer) JsonArrayData;
if (!array) return DeserializationError::NoMemory;
variant.setArray(*array);
// Check opening braket
if (!eat('[')) return DeserializationError::InvalidInput;
@ -82,13 +84,15 @@ class JsonDeserializer {
// Read each value
for (;;) {
// Allocate slot in array
JsonVariantData *value = array->addSlot(_buffer);
if (!value) return DeserializationError::NoMemory;
// 1 - Parse value
JsonVariant value;
_nestingLimit--;
err = parse(value);
err = parse(*value);
_nestingLimit++;
if (err) return err;
if (!array.add(value)) return DeserializationError::NoMemory;
// 2 - Skip spaces
err = skipSpacesAndComments();
@ -100,12 +104,12 @@ class JsonDeserializer {
}
}
DeserializationError parseObject(JsonVariant &variant) {
DeserializationError parseObject(JsonVariantData &variant) {
if (_nestingLimit == 0) return DeserializationError::TooDeep;
JsonObject object(_buffer);
if (object.isNull()) return DeserializationError::NoMemory;
variant = object;
JsonObjectData *object = new (_buffer) JsonObjectData;
if (!object) return DeserializationError::NoMemory;
variant.setObject(*object);
// Check opening brace
if (!eat('{')) return DeserializationError::InvalidInput;
@ -129,13 +133,15 @@ class JsonDeserializer {
if (err) return err; // Colon
if (!eat(':')) return DeserializationError::InvalidInput;
// Allocate slot in object
JsonVariantData *value = object->addSlot(_buffer, key);
if (!value) return DeserializationError::NoMemory;
// Parse value
JsonVariant value;
_nestingLimit--;
err = parse(value);
err = parse(*value);
_nestingLimit++;
if (err) return err;
if (!object.set(key, value)) return DeserializationError::NoMemory;
// Skip spaces
err = skipSpacesAndComments();
@ -151,7 +157,7 @@ class JsonDeserializer {
}
}
DeserializationError parseValue(JsonVariant &variant) {
DeserializationError parseValue(JsonVariantData &variant) {
if (isQuote(current())) {
return parseStringValue(variant);
} else {
@ -167,11 +173,11 @@ class JsonDeserializer {
}
}
DeserializationError parseStringValue(JsonVariant &variant) {
DeserializationError parseStringValue(JsonVariantData &variant) {
const char *value;
DeserializationError err = parseQuotedString(&value);
if (err) return err;
variant = value;
variant.setString(value);
return DeserializationError::Ok;
}
@ -229,7 +235,7 @@ class JsonDeserializer {
return DeserializationError::Ok;
}
DeserializationError parseNumericValue(JsonVariant &result) {
DeserializationError parseNumericValue(JsonVariantData &result) {
char buffer[64];
uint8_t n = 0;
@ -242,15 +248,15 @@ class JsonDeserializer {
buffer[n] = 0;
if (isInteger(buffer)) {
result = parseInteger<JsonInteger>(buffer);
result.setInteger(parseInteger<JsonInteger>(buffer));
} else if (isFloat(buffer)) {
result = parseFloat<JsonFloat>(buffer);
result.setFloat(parseFloat<JsonFloat>(buffer));
} else if (!strcmp(buffer, "true")) {
result = true;
result.setBoolean(true);
} else if (!strcmp(buffer, "false")) {
result = false;
result.setBoolean(false);
} else if (!strcmp(buffer, "null")) {
result = static_cast<const char *>(0);
result.setNull();
} else {
return DeserializationError::InvalidInput;
}

View File

@ -20,10 +20,10 @@ class JsonSerializer {
_writer.writeFloat(value);
}
void acceptArray(const JsonArray &array) {
void acceptArray(const JsonArrayData &array) {
_writer.beginArray();
JsonArray::const_iterator it = array.begin();
JsonArrayData::const_iterator it = array.begin();
while (it != array.end()) {
it->visit(*this);
@ -36,10 +36,10 @@ class JsonSerializer {
_writer.endArray();
}
void acceptObject(const JsonObject &object) {
void acceptObject(const JsonObjectData &object) {
_writer.beginObject();
JsonObject::const_iterator it = object.begin();
JsonObjectData::const_iterator it = object.begin();
while (it != object.end()) {
_writer.writeString(it->key);
_writer.writeColon();

View File

@ -4,7 +4,8 @@
#pragma once
#include "./JsonArrayData.hpp"
#include "JsonArrayData.hpp"
#include "JsonArrayIterator.hpp"
namespace ArduinoJson {
@ -18,13 +19,13 @@ class JsonArray {
friend class JsonVariant;
public:
typedef Internals::JsonArrayData::iterator iterator;
typedef Internals::JsonArrayData::const_iterator const_iterator;
typedef JsonArrayIterator iterator;
JsonArray() : _data(0) {}
JsonArray(Internals::JsonArrayData* arr) : _data(arr) {}
JsonArray(Internals::JsonBuffer* buf)
: _data(new (buf) Internals::JsonArrayData(buf)) {}
JsonArray() : _buffer(0), _data(0) {}
explicit JsonArray(Internals::JsonBuffer* buf, Internals::JsonArrayData* arr)
: _buffer(buf), _data(arr) {}
explicit JsonArray(Internals::JsonBuffer* buf)
: _buffer(buf), _data(new (buf) Internals::JsonArrayData()) {}
// Adds the specified value at the end of the array.
//
@ -43,24 +44,15 @@ class JsonArray {
return add_impl<T*>(value);
}
iterator begin() {
iterator begin() const {
if (!_data) return iterator();
return _data->begin();
return iterator(_buffer, _data->begin());
}
const_iterator begin() const {
if (!_data) return const_iterator();
return _data->begin();
}
iterator end() {
iterator end() const {
return iterator();
}
const_iterator end() const {
return const_iterator();
}
// Imports a 1D array
template <typename T, size_t N>
bool copyFrom(T (&array)[N]) {
@ -100,8 +92,7 @@ class JsonArray {
template <typename T>
size_t copyTo(T* array, size_t len) const {
size_t i = 0;
for (const_iterator it = begin(); it != end() && i < len; ++it)
array[i++] = *it;
for (iterator it = begin(); it != end() && i < len; ++it) array[i++] = *it;
return i;
}
@ -110,7 +101,7 @@ class JsonArray {
void copyTo(T (&array)[N1][N2]) const {
if (!_data) return;
size_t i = 0;
for (const_iterator it = begin(); it != end() && i < N1; ++it) {
for (iterator it = begin(); it != end() && i < N1; ++it) {
it->as<JsonArray>().copyTo(array[i++]);
}
}
@ -129,21 +120,21 @@ class JsonArray {
// Gets the value at the specified index.
template <typename T>
typename Internals::JsonVariantAs<T>::type get(size_t index) const {
const_iterator it = begin() += index;
return it != end() ? it->as<T>() : Internals::JsonVariantDefault<T>::get();
iterator it = begin() += index;
return it != end() ? it->as<T>() : T();
}
// Check the type of the value at specified index.
template <typename T>
bool is(size_t index) const {
const_iterator it = begin() += index;
iterator it = begin() += index;
return it != end() ? it->is<T>() : false;
}
// Removes element at specified position.
void remove(iterator it) {
if (!_data) return;
_data->remove(it);
_data->remove(it.internal());
}
// Removes element at specified index.
@ -182,7 +173,7 @@ class JsonArray {
template <typename Visitor>
void visit(Visitor& visitor) const {
if (_data)
return visitor.acceptArray(*this);
visitor.acceptArray(*_data);
else
visitor.acceptNull();
}
@ -192,17 +183,18 @@ class JsonArray {
bool set_impl(size_t index, TValueRef value) {
iterator it = begin() += index;
if (it == end()) return false;
return Internals::ValueSaver<TValueRef>::save(_data->_buffer, *it, value);
return it->set(value);
}
template <typename TValueRef>
bool add_impl(TValueRef value) {
if (!_data) return false;
iterator it = _data->add();
iterator it = iterator(_buffer, _data->add(_buffer));
if (it == end()) return false;
return Internals::ValueSaver<TValueRef>::save(_data->_buffer, *it, value);
return it->set(value);
}
Internals::JsonBuffer* _buffer;
Internals::JsonArrayData* _data;
};
} // namespace ArduinoJson

View File

@ -4,9 +4,8 @@
#pragma once
#include "Data/JsonVariantData.hpp"
#include "Data/List.hpp"
#include "Data/ValueSaver.hpp"
#include "JsonVariant.hpp"
#include "Memory/JsonBufferAllocated.hpp"
#include "Polyfills/type_traits.hpp"
@ -19,8 +18,11 @@
namespace ArduinoJson {
namespace Internals {
struct JsonArrayData : List<JsonVariant>, JsonBufferAllocated {
explicit JsonArrayData(JsonBuffer *buf) throw() : List<JsonVariant>(buf) {}
struct JsonArrayData : List<JsonVariantData>, JsonBufferAllocated {
JsonVariantData* addSlot(JsonBuffer* buffer) {
iterator it = add(buffer);
return it != end() ? &*it : 0;
}
};
} // namespace Internals
} // namespace ArduinoJson

View File

@ -11,14 +11,14 @@ namespace ArduinoJson {
inline JsonArray JsonArray::createNestedArray() {
if (!_data) return JsonArray();
JsonArray array(_data->_buffer);
JsonArray array(_buffer);
if (!array.isNull()) add(array);
return array;
}
inline JsonObject JsonArray::createNestedObject() {
if (!_data) return JsonObject();
JsonObject object(_data->_buffer);
JsonObject object(_buffer);
if (!object.isNull()) add(object);
return object;
}

View File

@ -0,0 +1,72 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#pragma once
#include "Data/ListIterator.hpp"
#include "JsonVariant.hpp"
namespace ArduinoJson {
class JsonVariantPtr {
public:
JsonVariantPtr(Internals::JsonBuffer *buffer,
Internals::JsonVariantData *data)
: _variant(buffer, data) {}
JsonVariant *operator->() {
return &_variant;
}
JsonVariant &operator*() {
return _variant;
}
private:
JsonVariant _variant;
};
class JsonArrayIterator {
typedef Internals::ListIterator<Internals::JsonVariantData> internal_iterator;
public:
JsonArrayIterator() {}
explicit JsonArrayIterator(Internals::JsonBuffer *buffer,
internal_iterator iterator)
: _iterator(iterator), _buffer(buffer) {}
JsonVariant operator*() const {
return JsonVariant(_buffer, &*_iterator);
}
JsonVariantPtr operator->() {
return JsonVariantPtr(_buffer, &*_iterator);
}
bool operator==(const JsonArrayIterator &other) const {
return _iterator == other._iterator;
}
bool operator!=(const JsonArrayIterator &other) const {
return _iterator != other._iterator;
}
JsonArrayIterator &operator++() {
++_iterator;
return *this;
}
JsonArrayIterator &operator+=(size_t distance) {
_iterator += distance;
return *this;
}
internal_iterator internal() {
return _iterator;
}
private:
internal_iterator _iterator;
Internals::JsonBuffer *_buffer;
};
} // namespace ArduinoJson

View File

@ -20,7 +20,7 @@ class JsonArraySubscript : public JsonVariantBase<JsonArraySubscript> {
: _array(array), _index(index) {}
FORCE_INLINE JsonArraySubscript& operator=(const JsonArraySubscript& src) {
_array.set(_index, src);
_array.set(_index, src.as<JsonVariant>());
return *this;
}

View File

@ -5,29 +5,27 @@
#pragma once
#include "./JsonObjectData.hpp"
#include "./JsonObjectIterator.hpp"
namespace ArduinoJson {
class JsonObject {
friend class JsonVariant;
typedef Internals::JsonObjectData::iterator internal_iterator;
public:
typedef Internals::JsonObjectData::iterator iterator;
typedef Internals::JsonObjectData::const_iterator const_iterator;
typedef JsonObjectIterator iterator;
JsonObject() : _data(0) {}
JsonObject(Internals::JsonObjectData* object) : _data(object) {}
JsonObject(Internals::JsonBuffer* buf)
: _data(new (buf) Internals::JsonObjectData(buf)) {}
JsonObject() : _buffer(0), _data(0) {}
explicit JsonObject(Internals::JsonBuffer* buf,
Internals::JsonObjectData* object)
: _buffer(buf), _data(object) {}
explicit JsonObject(Internals::JsonBuffer* buf)
: _buffer(buf), _data(new (buf) Internals::JsonObjectData()) {}
iterator begin() {
iterator begin() const {
if (!_data) return iterator();
return _data->begin();
}
const_iterator begin() const {
if (!_data) return const_iterator();
return _data->begin();
return iterator(_buffer, _data->begin());
}
// Tells weither the specified key is present and associated with a value.
@ -46,14 +44,10 @@ class JsonObject {
return containsKey_impl<TString*>(key);
}
iterator end() {
iterator end() const {
return iterator();
}
const_iterator end() const {
return const_iterator();
}
// Creates and adds a JsonArray.
//
// JsonArray createNestedArray(TKey);
@ -165,7 +159,7 @@ class JsonObject {
void remove(iterator it) {
if (!_data) return;
_data->remove(it);
_data->remove(it.internal());
}
// Removes the specified key and the associated value.
@ -232,15 +226,15 @@ class JsonObject {
template <typename Visitor>
void visit(Visitor& visitor) const {
if (_data)
visitor.acceptObject(*this);
visitor.acceptObject(*_data);
else
return visitor.acceptNull();
visitor.acceptNull();
}
private:
template <typename TStringRef>
bool containsKey_impl(TStringRef key) const {
return findKey<TStringRef>(key) != end();
return findKey<TStringRef>(key) != _data->end();
}
template <typename TStringRef>
@ -251,30 +245,32 @@ class JsonObject {
// Returns the list node that matches the specified key.
template <typename TStringRef>
iterator findKey(TStringRef key) {
iterator it;
for (it = begin(); it != end(); ++it) {
internal_iterator findKey(TStringRef key) {
if (!_data) return internal_iterator();
internal_iterator it;
for (it = _data->begin(); it != _data->end(); ++it) {
if (Internals::makeString(key).equals(it->key)) break;
}
return it;
}
template <typename TStringRef>
const_iterator findKey(TStringRef key) const {
internal_iterator findKey(TStringRef key) const {
return const_cast<JsonObject*>(this)->findKey<TStringRef>(key);
}
template <typename TStringRef, typename TValue>
typename Internals::JsonVariantAs<TValue>::type get_impl(
TStringRef key) const {
const_iterator it = findKey<TStringRef>(key);
return it != end() ? it->value.as<TValue>()
: Internals::JsonVariantDefault<TValue>::get();
internal_iterator it = findKey<TStringRef>(key);
return it != _data->end() ? JsonVariant(_buffer, &it->value).as<TValue>()
: TValue();
}
template <typename TStringRef, typename TValue>
bool is_impl(TStringRef key) const {
const_iterator it = findKey<TStringRef>(key);
return it != end() ? it->value.is<TValue>() : false;
internal_iterator it = findKey<TStringRef>(key);
return it != _data->end() ? JsonVariant(_buffer, &it->value).is<TValue>()
: false;
}
template <typename TStringRef>
@ -291,21 +287,33 @@ class JsonObject {
if (Internals::makeString(key).is_null()) return false;
// search a matching key
iterator it = findKey<TStringRef>(key);
if (it == end()) {
internal_iterator it = findKey<TStringRef>(key);
if (it == _data->end()) {
// add the key
it = _data->add();
if (it == end()) return false;
bool key_ok =
Internals::ValueSaver<TStringRef>::save(_data->_buffer, it->key, key);
if (!key_ok) return false;
// TODO: use JsonPairData directly, we don't need an iterator
it = _data->add(_buffer);
if (it == _data->end()) return false;
if (!set_key(it, key)) return false;
}
// save the value
return Internals::ValueSaver<TValueRef>::save(_data->_buffer, it->value,
value);
return JsonVariant(_buffer, &it->value).set(value);
}
Internals::JsonObjectData* _data;
bool set_key(internal_iterator& it, const char* key) {
it->key = key;
return true;
}
template <typename T>
bool set_key(internal_iterator& it, const T& key) {
const char* dup = Internals::makeString(key).save(_buffer);
if (!dup) return false;
it->key = dup;
return true;
}
mutable Internals::JsonBuffer* _buffer;
mutable Internals::JsonObjectData* _data;
};
} // namespace ArduinoJson

View File

@ -5,7 +5,6 @@
#pragma once
#include "Data/List.hpp"
#include "Data/ValueSaver.hpp"
#include "JsonPair.hpp"
#include "Memory/JsonBufferAllocated.hpp"
#include "Polyfills/type_traits.hpp"
@ -19,8 +18,13 @@
namespace ArduinoJson {
namespace Internals {
struct JsonObjectData : List<JsonPair>, JsonBufferAllocated {
explicit JsonObjectData(JsonBuffer* buf) throw() : List<JsonPair>(buf) {}
struct JsonObjectData : List<JsonPairData>, JsonBufferAllocated {
JsonVariantData* addSlot(JsonBuffer* buffer, const char* key) {
iterator it = add(buffer);
if (it == end()) return 0;
it->key = key;
return &it->value;
}
};
} // namespace Internals
} // namespace ArduinoJson

View File

@ -22,7 +22,7 @@ inline JsonArray JsonObject::createNestedArray(TString* key) {
template <typename TStringRef>
inline JsonArray JsonObject::createNestedArray_impl(TStringRef key) {
if (!_data) return JsonArray();
JsonArray array(_data->_buffer);
JsonArray array(_buffer);
if (!array.isNull()) set(key, array);
return array;
}
@ -30,7 +30,7 @@ inline JsonArray JsonObject::createNestedArray_impl(TStringRef key) {
template <typename TStringRef>
inline JsonObject JsonObject::createNestedObject_impl(TStringRef key) {
if (!_data) return JsonObject();
JsonObject object(_data->_buffer);
JsonObject object(_buffer);
if (!object.isNull()) set(key, object);
return object;
}

View File

@ -0,0 +1,72 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#pragma once
#include "Data/ListIterator.hpp"
#include "JsonPair.hpp"
namespace ArduinoJson {
class JsonPairPtr {
public:
JsonPairPtr(Internals::JsonBuffer *buffer, Internals::JsonPairData *data)
: _pair(buffer, data) {}
const JsonPair *operator->() const {
return &_pair;
}
const JsonPair &operator*() const {
return _pair;
}
private:
JsonPair _pair;
};
// A read-write forward iterator for JsonArray
class JsonObjectIterator {
typedef Internals::ListIterator<Internals::JsonPairData> internal_iterator;
public:
JsonObjectIterator() {}
explicit JsonObjectIterator(Internals::JsonBuffer *buffer,
internal_iterator iterator)
: _buffer(buffer), _iterator(iterator) {}
JsonPair operator*() const {
return JsonPair(_buffer, &*_iterator);
}
JsonPairPtr operator->() {
return JsonPairPtr(_buffer, &*_iterator);
}
bool operator==(const JsonObjectIterator &other) const {
return _iterator == other._iterator;
}
bool operator!=(const JsonObjectIterator &other) const {
return _iterator != other._iterator;
}
JsonObjectIterator &operator++() {
++_iterator;
return *this;
}
JsonObjectIterator &operator+=(size_t distance) {
_iterator += distance;
return *this;
}
internal_iterator internal() {
return _iterator;
}
private:
Internals::JsonBuffer *_buffer;
internal_iterator _iterator;
};
} // namespace ArduinoJson

View File

@ -8,9 +8,30 @@
namespace ArduinoJson {
// A key value pair for JsonObjectData.
struct JsonPair {
namespace Internals {
struct JsonPairData {
const char* key;
JsonVariant value;
JsonVariantData value;
};
} // namespace Internals
// A key value pair for JsonObjectData.
class JsonPair {
public:
JsonPair(Internals::JsonBuffer* buffer, Internals::JsonPairData* data)
: _key(data->key), _value(buffer, &data->value) {}
const char* key() const {
return _key;
}
JsonVariant value() const {
return _value;
}
private:
const char* _key;
JsonVariant _value;
};
} // namespace ArduinoJson

View File

@ -7,10 +7,10 @@
#include <stddef.h>
#include <stdint.h> // for uint8_t
#include "Data/JsonVariantContent.hpp"
#include "Data/JsonVariantDefault.hpp"
#include "Data/JsonVariantType.hpp"
#include "Data/JsonVariantData.hpp"
#include "JsonVariant.hpp"
#include "JsonVariantBase.hpp"
#include "Memory/JsonBuffer.hpp"
#include "Polyfills/type_traits.hpp"
#include "Serialization/DynamicStringWriter.hpp"
#include "SerializedValue.hpp"
@ -30,84 +30,135 @@ class JsonObject;
// - a reference to a JsonArray or JsonObject
class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
public:
// Intenal use only
explicit JsonVariant(Internals::JsonBuffer *buffer,
Internals::JsonVariantData *data)
: _buffer(buffer), _data(data) {}
// Creates an uninitialized JsonVariant
JsonVariant() : _type(Internals::JSON_UNDEFINED) {}
JsonVariant() : _buffer(0), _data(0) {}
// Create a JsonVariant containing a boolean value.
// It will be serialized as "true" or "false" in JSON.
JsonVariant(bool value) {
using namespace Internals;
_type = JSON_BOOLEAN;
_content.asInteger = static_cast<JsonUInt>(value);
// set(bool value)
bool set(bool value) {
if (!_data) return false;
_data->setBoolean(value);
return true;
}
// Create a JsonVariant containing a floating point value.
// JsonVariant(double value);
// JsonVariant(float value);
// set(double value);
// set(float value);
template <typename T>
JsonVariant(T value,
typename Internals::enable_if<
Internals::is_floating_point<T>::value>::type * = 0) {
using namespace Internals;
_type = JSON_FLOAT;
_content.asFloat = static_cast<JsonFloat>(value);
bool set(T value, typename Internals::enable_if<
Internals::is_floating_point<T>::value>::type * = 0) {
if (!_data) return false;
_data->setFloat(static_cast<Internals::JsonFloat>(value));
return true;
}
// Create a JsonVariant containing an integer value.
// JsonVariant(char)
// JsonVariant(signed short)
// JsonVariant(signed int)
// JsonVariant(signed long)
// JsonVariant(signed char)
// set(char)
// set(signed short)
// set(signed int)
// set(signed long)
// set(signed char)
template <typename T>
JsonVariant(
T value,
typename Internals::enable_if<Internals::is_integral<T>::value &&
Internals::is_signed<T>::value>::type * =
0) {
using namespace Internals;
if (value >= 0) {
_type = JSON_POSITIVE_INTEGER;
_content.asInteger = static_cast<JsonUInt>(value);
bool set(T value,
typename Internals::enable_if<Internals::is_integral<T>::value &&
Internals::is_signed<T>::value>::type
* = 0) {
if (!_data) return false;
if (value >= 0)
_data->setPostiveInteger(static_cast<Internals::JsonUInt>(value));
else
_data->setNegativeInteger(~static_cast<Internals::JsonUInt>(value) + 1);
return true;
}
// set(unsigned short)
// set(unsigned int)
// set(unsigned long)
template <typename T>
bool set(T value,
typename Internals::enable_if<Internals::is_integral<T>::value &&
Internals::is_unsigned<T>::value>::type
* = 0) {
if (!_data) return false;
_data->setPostiveInteger(static_cast<Internals::JsonUInt>(value));
return true;
}
// set(SerializedValue<const char *>)
bool set(Internals::SerializedValue<const char *> value) {
if (!_data) return false;
_data->setRaw(value.data(), value.size());
return true;
}
// set(SerializedValue<std::string>)
// set(SerializedValue<String>)
// set(SerializedValue<const __FlashStringHelper*>)
template <typename T>
bool set(Internals::SerializedValue<T> value,
typename Internals::enable_if<
!Internals::is_same<const char *, T>::value>::type * = 0) {
if (!_data) return false;
const char *dup =
Internals::makeString(value.data(), value.size()).save(_buffer);
if (dup)
_data->setRaw(dup, value.size());
else
_data->setNull();
return true;
}
// set(const std::string&)
// set(const String&)
template <typename T>
bool set(const T &value,
typename Internals::enable_if<Internals::IsString<T>::value>::type
* = 0) {
if (!_data) return false;
const char *dup = Internals::makeString(value).save(_buffer);
if (dup) {
_data->setString(dup);
return true;
} else {
_type = JSON_NEGATIVE_INTEGER;
_content.asInteger = ~static_cast<JsonUInt>(value) + 1;
_data->setNull();
return false;
}
}
// JsonVariant(unsigned short)
// JsonVariant(unsigned int)
// JsonVariant(unsigned long)
template <typename T>
JsonVariant(
T value,
typename Internals::enable_if<Internals::is_integral<T>::value &&
Internals::is_unsigned<T>::value>::type * =
0) {
using namespace Internals;
_type = JSON_POSITIVE_INTEGER;
_content.asInteger = static_cast<JsonUInt>(value);
// set(const char*);
// set(const char[n]); // VLA
bool set(const char *value) {
if (!_data) return false;
_data->setString(value);
return true;
}
// set(const unsigned char*);
// set(const unsigned char[n]); // VLA
bool set(const unsigned char *value) {
return set(reinterpret_cast<const char *>(value));
}
// set(const signed char*);
// set(const signed char[n]); // VLA
bool set(const signed char *value) {
return set(reinterpret_cast<const char *>(value));
}
// Create a JsonVariant containing a string.
// JsonVariant(const char*);
// JsonVariant(const signed char*);
// JsonVariant(const unsigned char*);
template <typename TChar>
JsonVariant(const TChar *value,
typename Internals::enable_if<sizeof(TChar) == 1>::type * = 0) {
_type = Internals::JSON_STRING;
_content.asString = reinterpret_cast<const char *>(value);
bool set(const JsonVariant &value) {
if (!_data) return false;
if (value._data)
*_data = *value._data;
else
_data->setNull();
return true;
}
// Create a JsonVariant containing an unparsed string
JsonVariant(Internals::SerializedValue<const char *> value) {
_type = Internals::JSON_UNPARSED;
_content.asRaw.data = value.data();
_content.asRaw.size = value.size();
}
JsonVariant(JsonArray array);
JsonVariant(JsonObject object);
bool set(const JsonArray &array);
bool set(const Internals::JsonArraySubscript &);
bool set(const JsonObject &object);
template <typename TString>
bool set(const Internals::JsonObjectSubscript<TString> &);
// Get the variant as the specified type.
//
@ -123,14 +174,14 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
template <typename T>
const typename Internals::enable_if<Internals::is_integral<T>::value, T>::type
as() const {
return variantAsInteger<T>();
return _data ? _data->asInteger<T>() : T();
}
// bool as<bool>() const
template <typename T>
const typename Internals::enable_if<Internals::is_same<T, bool>::value,
T>::type
as() const {
return variantAsInteger<int>() != 0;
return _data && _data->asInteger<int>() != 0;
}
//
// double as<double>() const;
@ -139,7 +190,7 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
const typename Internals::enable_if<Internals::is_floating_point<T>::value,
T>::type
as() const {
return variantAsFloat<T>();
return _data ? _data->asFloat<T>() : 0;
}
//
// const char* as<const char*>() const;
@ -149,7 +200,7 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
Internals::is_same<T, char *>::value,
const char *>::type
as() const {
return variantAsString();
return _data ? _data->asString() : 0;
}
//
// std::string as<std::string>() const;
@ -157,7 +208,7 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
template <typename T>
typename Internals::enable_if<Internals::IsWriteableString<T>::value, T>::type
as() const {
const char *cstr = variantAsString();
const char *cstr = _data ? _data->asString() : 0;
if (cstr) return T(cstr);
T s;
serializeJson(*this, s);
@ -205,7 +256,7 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
template <typename T>
typename Internals::enable_if<Internals::is_integral<T>::value, bool>::type
is() const {
return variantIsInteger();
return _data && _data->isInteger();
}
//
// bool is<double>() const;
@ -214,14 +265,14 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
typename Internals::enable_if<Internals::is_floating_point<T>::value,
bool>::type
is() const {
return variantIsFloat();
return _data && _data->isFloat();
}
//
// bool is<bool>() const
template <typename T>
typename Internals::enable_if<Internals::is_same<T, bool>::value, bool>::type
is() const {
return variantIsBoolean();
return _data && _data->isBoolean();
}
//
// bool is<const char*>() const;
@ -231,7 +282,7 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
Internals::is_same<T, char *>::value,
bool>::type
is() const {
return variantIsString();
return _data && _data->isString();
}
//
// bool is<JsonArray> const;
@ -242,7 +293,7 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
JsonArray>::value,
bool>::type
is() const {
return variantIsArray();
return _data && _data->isArray();
}
//
// bool is<JsonObject> const;
@ -253,72 +304,24 @@ class JsonVariant : public Internals::JsonVariantBase<JsonVariant> {
JsonObject>::value,
bool>::type
is() const {
return variantIsObject();
return _data && _data->isObject();
}
// Returns true if the variant has a value
bool isNull() const {
return _type == Internals::JSON_UNDEFINED;
return _data == 0 || _data->isNull();
}
template <typename Visitor>
void visit(Visitor &visitor) const {
using namespace Internals;
switch (_type) {
case JSON_FLOAT:
return visitor.acceptFloat(_content.asFloat);
case JSON_ARRAY:
return visitor.acceptArray(_content.asArray);
case JSON_OBJECT:
return visitor.acceptObject(_content.asObject);
case JSON_STRING:
return visitor.acceptString(_content.asString);
case JSON_UNPARSED:
return visitor.acceptRawJson(_content.asRaw.data, _content.asRaw.size);
case JSON_NEGATIVE_INTEGER:
return visitor.acceptNegativeInteger(_content.asInteger);
case JSON_POSITIVE_INTEGER:
return visitor.acceptPositiveInteger(_content.asInteger);
case JSON_BOOLEAN:
return visitor.acceptBoolean(_content.asInteger != 0);
default: // JSON_UNDEFINED
return visitor.acceptNull();
}
if (_data)
_data->visit(visitor);
else
visitor.acceptNull();
}
private:
JsonArray variantAsArray() const;
JsonObject variantAsObject() const;
const char *variantAsString() const;
template <typename T>
T variantAsFloat() const;
template <typename T>
T variantAsInteger() const;
bool variantIsBoolean() const;
bool variantIsFloat() const;
bool variantIsInteger() const;
bool variantIsArray() const {
return _type == Internals::JSON_ARRAY;
}
bool variantIsObject() const {
return _type == Internals::JSON_OBJECT;
}
bool variantIsString() const {
return _type == Internals::JSON_STRING;
}
// The current type of the variant
Internals::JsonVariantType _type;
// The various alternatives for the value of the variant.
Internals::JsonVariantContent _content;
};
Internals::JsonBuffer *_buffer;
Internals::JsonVariantData *_data;
}; // namespace ArduinoJson
} // namespace ArduinoJson

View File

@ -5,6 +5,8 @@
#pragma once
#include "Data/IsVariant.hpp"
#include "Data/JsonFloat.hpp"
#include "Data/JsonInteger.hpp"
#include "Polyfills/type_traits.hpp"
#include "Strings/StringTypes.hpp"

View File

@ -8,8 +8,6 @@
#include "JsonArrayData.hpp"
#include "JsonObjectData.hpp"
#include "JsonVariant.hpp"
#include "Numbers/isFloat.hpp"
#include "Numbers/isInteger.hpp"
#include "Numbers/parseFloat.hpp"
#include "Numbers/parseInteger.hpp"
@ -17,22 +15,32 @@
namespace ArduinoJson {
inline JsonVariant::JsonVariant(JsonArray array) {
if (!array.isNull()) {
_type = Internals::JSON_ARRAY;
_content.asArray = array._data;
} else {
_type = Internals::JSON_UNDEFINED;
}
inline bool JsonVariant::set(const JsonArray& array) {
if (!_data) return false;
if (array._data)
_data->setArray(*array._data);
else
_data->setNull();
return true;
}
inline JsonVariant::JsonVariant(JsonObject object) {
if (!object.isNull()) {
_type = Internals::JSON_OBJECT;
_content.asObject = object._data;
} else {
_type = Internals::JSON_UNDEFINED;
}
inline bool JsonVariant::set(const Internals::JsonArraySubscript& value) {
return set(value.as<JsonVariant>());
}
inline bool JsonVariant::set(const JsonObject& object) {
if (!_data) return false;
if (object._data)
_data->setObject(*object._data);
else
_data->setNull();
return true;
}
template <typename TString>
inline bool JsonVariant::set(
const Internals::JsonObjectSubscript<TString>& value) {
return set(value.template as<JsonVariant>());
}
template <typename T>
@ -41,7 +49,7 @@ inline typename Internals::enable_if<
JsonArray>::value,
JsonArray>::type
JsonVariant::as() const {
return variantAsArray();
return _data ? JsonArray(_buffer, _data->asArray()) : JsonArray();
}
template <typename T>
@ -50,78 +58,6 @@ inline typename Internals::enable_if<
JsonObject>::value,
T>::type
JsonVariant::as() const {
return variantAsObject();
return _data ? JsonObject(_buffer, _data->asObject()) : JsonObject();
}
inline JsonArray JsonVariant::variantAsArray() const {
if (_type == Internals::JSON_ARRAY) return _content.asArray;
return JsonArray();
}
inline JsonObject JsonVariant::variantAsObject() const {
if (_type == Internals::JSON_OBJECT) return _content.asObject;
return JsonObject();
}
template <typename T>
inline T JsonVariant::variantAsInteger() const {
using namespace Internals;
switch (_type) {
case JSON_UNDEFINED:
case JSON_UNPARSED:
return 0;
case JSON_POSITIVE_INTEGER:
case JSON_BOOLEAN:
return T(_content.asInteger);
case JSON_NEGATIVE_INTEGER:
return T(~_content.asInteger + 1);
case JSON_STRING:
return parseInteger<T>(_content.asString);
default:
return T(_content.asFloat);
}
}
inline const char *JsonVariant::variantAsString() const {
using namespace Internals;
return _type == JSON_STRING ? _content.asString : NULL;
}
template <typename T>
inline T JsonVariant::variantAsFloat() const {
using namespace Internals;
switch (_type) {
case JSON_UNDEFINED:
case JSON_UNPARSED:
return 0;
case JSON_POSITIVE_INTEGER:
case JSON_BOOLEAN:
return static_cast<T>(_content.asInteger);
case JSON_NEGATIVE_INTEGER:
return -static_cast<T>(_content.asInteger);
case JSON_STRING:
return parseFloat<T>(_content.asString);
default:
return static_cast<T>(_content.asFloat);
}
}
inline bool JsonVariant::variantIsBoolean() const {
using namespace Internals;
return _type == JSON_BOOLEAN;
}
inline bool JsonVariant::variantIsInteger() const {
using namespace Internals;
return _type == JSON_POSITIVE_INTEGER || _type == JSON_NEGATIVE_INTEGER;
}
inline bool JsonVariant::variantIsFloat() const {
using namespace Internals;
return _type == JSON_FLOAT || _type == JSON_POSITIVE_INTEGER ||
_type == JSON_NEGATIVE_INTEGER;
}
} // namespace ArduinoJson

View File

@ -16,7 +16,7 @@ class JsonBufferAllocated {
return jsonBuffer->alloc(n);
}
void operator delete(void *, JsonBuffer *)throw();
void operator delete(void *, JsonBuffer *)throw() {}
};
} // namespace Internals
} // namespace ArduinoJson

View File

@ -24,17 +24,17 @@ class MsgPackDeserializer {
_stringStorage(stringStorage),
_nestingLimit(nestingLimit) {}
DeserializationError parse(JsonVariant &variant) {
DeserializationError parse(JsonVariantData &variant) {
uint8_t code;
if (!readByte(code)) return DeserializationError::IncompleteInput;
if ((code & 0x80) == 0) {
variant = code;
variant.setInteger(code);
return DeserializationError::Ok;
}
if ((code & 0xe0) == 0xe0) {
variant = static_cast<int8_t>(code);
variant.setInteger(static_cast<int8_t>(code));
return DeserializationError::Ok;
}
@ -48,15 +48,15 @@ class MsgPackDeserializer {
switch (code) {
case 0xc0:
variant = static_cast<char *>(0);
variant.setNull();
return DeserializationError::Ok;
case 0xc2:
variant = false;
variant.setBoolean(false);
return DeserializationError::Ok;
case 0xc3:
variant = true;
variant.setBoolean(true);
return DeserializationError::Ok;
case 0xcc:
@ -171,54 +171,54 @@ class MsgPackDeserializer {
}
template <typename T>
DeserializationError readInteger(JsonVariant &variant) {
DeserializationError readInteger(JsonVariantData &variant) {
T value;
if (!readInteger(value)) return DeserializationError::IncompleteInput;
variant = value;
variant.setInteger(value);
return DeserializationError::Ok;
}
template <typename T>
typename enable_if<sizeof(T) == 4, DeserializationError>::type readFloat(
JsonVariant &variant) {
JsonVariantData &variant) {
T value;
if (!readBytes(value)) return DeserializationError::IncompleteInput;
fixEndianess(value);
variant = value;
variant.setFloat(value);
return DeserializationError::Ok;
}
template <typename T>
typename enable_if<sizeof(T) == 8, DeserializationError>::type readDouble(
JsonVariant &variant) {
JsonVariantData &variant) {
T value;
if (!readBytes(value)) return DeserializationError::IncompleteInput;
fixEndianess(value);
variant = value;
variant.setFloat(value);
return DeserializationError::Ok;
}
template <typename T>
typename enable_if<sizeof(T) == 4, DeserializationError>::type readDouble(
JsonVariant &variant) {
JsonVariantData &variant) {
uint8_t i[8]; // input is 8 bytes
T value; // output is 4 bytes
uint8_t *o = reinterpret_cast<uint8_t *>(&value);
if (!readBytes(i, 8)) return DeserializationError::IncompleteInput;
doubleToFloat(i, o);
fixEndianess(value);
variant = value;
variant.setFloat(value);
return DeserializationError::Ok;
}
template <typename T>
DeserializationError readString(JsonVariant &variant) {
DeserializationError readString(JsonVariantData &variant) {
T size;
if (!readInteger(size)) return DeserializationError::IncompleteInput;
return readString(variant, size);
}
DeserializationError readString(JsonVariant &variant, size_t n) {
DeserializationError readString(JsonVariantData &variant, size_t n) {
typename remove_reference<TStringStorage>::type::String str =
_stringStorage.startString();
for (; n; --n) {
@ -228,64 +228,68 @@ class MsgPackDeserializer {
}
const char *s = str.c_str();
if (s == NULL) return DeserializationError::NoMemory;
variant = s;
variant.setString(s);
return DeserializationError::Ok;
}
template <typename TSize>
DeserializationError readArray(JsonVariant &variant) {
DeserializationError readArray(JsonVariantData &variant) {
TSize size;
if (!readInteger(size)) return DeserializationError::IncompleteInput;
return readArray(variant, size);
}
DeserializationError readArray(JsonVariant &variant, size_t n) {
JsonArray array(_buffer);
if (array.isNull()) return DeserializationError::NoMemory;
variant = array;
return readArray(array, n);
DeserializationError readArray(JsonVariantData &variant, size_t n) {
JsonArrayData *array = new (_buffer) JsonArrayData;
if (!array) return DeserializationError::NoMemory;
variant.setArray(*array);
return readArray(*array, n);
}
DeserializationError readArray(JsonArray array, size_t n) {
DeserializationError readArray(JsonArrayData &array, size_t n) {
if (_nestingLimit == 0) return DeserializationError::TooDeep;
--_nestingLimit;
for (; n; --n) {
JsonVariant variant;
DeserializationError err = parse(variant);
JsonVariantData *value = array.addSlot(_buffer);
if (!value) return DeserializationError::NoMemory;
DeserializationError err = parse(*value);
if (err) return err;
if (!array.add(variant)) return DeserializationError::NoMemory;
}
++_nestingLimit;
return DeserializationError::Ok;
}
template <typename TSize>
DeserializationError readObject(JsonVariant &variant) {
DeserializationError readObject(JsonVariantData &variant) {
TSize size;
if (!readInteger(size)) return DeserializationError::IncompleteInput;
return readObject(variant, size);
}
DeserializationError readObject(JsonVariant &variant, size_t n) {
JsonObject object(_buffer);
if (object.isNull()) return DeserializationError::NoMemory;
variant = object;
return readObject(object, n);
DeserializationError readObject(JsonVariantData &variant, size_t n) {
JsonObjectData *object = new (_buffer) JsonObjectData;
if (!object) return DeserializationError::NoMemory;
variant.setObject(*object);
return readObject(*object, n);
}
DeserializationError readObject(JsonObject object, size_t n) {
DeserializationError readObject(JsonObjectData &object, size_t n) {
if (_nestingLimit == 0) return DeserializationError::TooDeep;
--_nestingLimit;
for (; n; --n) {
DeserializationError err;
JsonVariant variant;
err = parse(variant);
JsonVariantData key;
DeserializationError err = parse(key);
if (err) return err;
const char *key = variant.as<char *>();
if (!key) return DeserializationError::NotSupported;
err = parse(variant);
if (!key.isString()) return DeserializationError::NotSupported;
JsonVariantData *value = object.addSlot(_buffer, key.asString());
if (!value) return DeserializationError::NoMemory;
err = parse(*value);
if (err) return err;
if (!object.set(key, variant)) return DeserializationError::NoMemory;
}
++_nestingLimit;
return DeserializationError::Ok;

View File

@ -36,7 +36,7 @@ class MsgPackSerializer {
}
}
void acceptArray(const JsonArray& array) {
void acceptArray(const JsonArrayData& array) {
size_t n = array.size();
if (n < 0x10) {
writeByte(uint8_t(0x90 + array.size()));
@ -47,13 +47,13 @@ class MsgPackSerializer {
writeByte(0xDD);
writeInteger(uint32_t(n));
}
for (JsonArray::const_iterator it = array.begin(); it != array.end();
for (JsonArrayData::const_iterator it = array.begin(); it != array.end();
++it) {
it->visit(*this);
}
}
void acceptObject(const JsonObject& object) {
void acceptObject(const JsonObjectData& object) {
size_t n = object.size();
if (n < 0x10) {
writeByte(uint8_t(0x80 + n));
@ -64,7 +64,7 @@ class MsgPackSerializer {
writeByte(0xDF);
writeInteger(uint32_t(n));
}
for (JsonObject::const_iterator it = object.begin(); it != object.end();
for (JsonObjectData::const_iterator it = object.begin(); it != object.end();
++it) {
acceptString(it->key);
it->value.visit(*this);

View File

@ -4,6 +4,7 @@
#pragma once
#include "../../Configuration.hpp"
#include "is_same.hpp"
namespace ArduinoJson {

View File

@ -9,11 +9,8 @@
namespace ArduinoJson {
template <size_t CAPACITY = sizeof(JsonVariant)>
template <size_t CAPACITY>
class StaticJsonDocument {
Internals::StaticJsonBuffer<CAPACITY> _buffer;
JsonVariant _root;
public:
uint8_t nestingLimit;
@ -25,12 +22,12 @@ class StaticJsonDocument {
template <typename T>
bool is() const {
return _root.is<T>();
return getVariant().template is<T>();
}
template <typename T>
typename Internals::JsonVariantAs<T>::type as() const {
return _root.as<T>();
return getVariant().template as<T>();
}
// JsonObject to<JsonObject>()
@ -40,7 +37,7 @@ class StaticJsonDocument {
to() {
clear();
JsonObject object(&_buffer);
_root = object;
getVariant().set(object);
return object;
}
@ -51,22 +48,32 @@ class StaticJsonDocument {
to() {
clear();
JsonArray array(&_buffer);
_root = array;
getVariant().set(array);
return array;
}
// JsonVariant to<JsonVariant>()
template <typename T>
typename Internals::enable_if<Internals::is_same<T, JsonVariant>::value,
T&>::type
JsonVariant>::type
to() {
clear();
return _root;
return getVariant();
}
// JsonVariantData& to<JsonVariantData>()
template <typename T>
typename Internals::enable_if<
Internals::is_same<T, Internals::JsonVariantData>::value,
Internals::JsonVariantData&>::type
to() {
clear();
return _rootData;
}
void clear() {
_buffer.clear();
_root = JsonVariant();
_rootData.setNull();
}
size_t memoryUsage() const {
@ -75,8 +82,16 @@ class StaticJsonDocument {
template <typename Visitor>
void visit(Visitor& visitor) const {
return _root.visit(visitor);
return getVariant().visit(visitor);
}
private:
JsonVariant getVariant() const {
return JsonVariant(&_buffer, &_rootData);
}
mutable Internals::StaticJsonBuffer<CAPACITY> _buffer;
mutable Internals::JsonVariantData _rootData;
};
} // namespace ArduinoJson

View File

@ -4,6 +4,8 @@
#pragma once
#include <string.h> // strcmp
namespace ArduinoJson {
namespace Internals {

View File

@ -26,6 +26,7 @@ class StlString {
}
bool equals(const char* expected) const {
if (!expected) return false;
return *_str == expected;
}