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

Moved .h files to include/

Browse Source
This commit is contained in:
Benoit Blanchon
2014-10-16 00:11:23 +02:00
parent 241ca79114
commit 58f155e135
46 changed files with 885 additions and 880 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
srcs/Arduino/Print.h → include/ArduinoJson/Arduino/Print.h
View File

@ -2,29 +2,29 @@
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#pragma once
#ifndef ARDUINO
#include <stddef.h>
#include <stdint.h>
// This class reproduces Arduino's Print
class Print
{
public:
virtual size_t write(uint8_t) = 0;
size_t print(const char[]);
size_t print(double, int = 2);
size_t print(long);
size_t println();
};
#else
#include <Print.h>
#endif
#pragma once
#ifndef ARDUINO
#include <stddef.h>
#include <stdint.h>
// This class reproduces Arduino's Print
class Print
{
public:
virtual size_t write(uint8_t) = 0;
size_t print(const char[]);
size_t print(double, int = 2);
size_t print(long);
size_t println();
};
#else
#include <Print.h>
#endif

52
srcs/Arduino/Printable.h → include/ArduinoJson/Arduino/Printable.h
View File

@ -1,26 +1,26 @@
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#pragma once
#ifndef ARDUINO
#include <stddef.h>
class Print;
class Printable
{
public:
virtual size_t printTo(Print& p) const = 0;
};
#else
#include <Printable.h>
#endif
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#pragma once
#ifndef ARDUINO
#include <stddef.h>
class Print;
class Printable
{
public:
virtual size_t printTo(Print& p) const = 0;
};
#else
#include <Printable.h>
#endif

86
srcs/Internals/CompactJsonWriter.h → include/ArduinoJson/Internals/CompactJsonWriter.h
View File

@ -1,43 +1,43 @@
#pragma once
#include "../Internals/JsonWriter.h"
class CompactJsonWriter : public JsonWriter
{
public:
explicit CompactJsonWriter(Print* sink)
: JsonWriter(sink)
{
}
virtual void beginArray()
{
_length += _sink->write('[');
}
virtual void endArray()
{
_length += _sink->write(']');
}
virtual void writeColon()
{
_length += _sink->write(':');
}
virtual void writeComma()
{
_length += _sink->write(',');
}
virtual void beginObject()
{
_length += _sink->write('{');
}
virtual void endObject()
{
_length += _sink->write('}');
}
};
#pragma once
#include "ArduinoJson/Internals/JsonWriter.h"
class CompactJsonWriter : public JsonWriter
{
public:
explicit CompactJsonWriter(Print* sink)
: JsonWriter(sink)
{
}
virtual void beginArray()
{
_length += _sink->write('[');
}
virtual void endArray()
{
_length += _sink->write(']');
}
virtual void writeColon()
{
_length += _sink->write(':');
}
virtual void writeComma()
{
_length += _sink->write(',');
}
virtual void beginObject()
{
_length += _sink->write('{');
}
virtual void endObject()
{
_length += _sink->write('}');
}
};

32
srcs/Internals/EscapedString.h → include/ArduinoJson/Internals/EscapedString.h
View File

@ -1,20 +1,20 @@
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#pragma once
#include "../Arduino/Print.h"
namespace ArduinoJson
{
namespace Internals
{
class EscapedString
{
public:
static size_t printTo(const char*, Print*);
};
}
*/
#pragma once
#include "../Arduino/Print.h"
namespace ArduinoJson
{
namespace Internals
{
class EscapedString
{
public:
static size_t printTo(const char*, Print*);
};
}
}

100
srcs/Internals/IndentedPrint.h → include/ArduinoJson/Internals/IndentedPrint.h
View File

@ -1,53 +1,53 @@
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#pragma once
#include "../Arduino/Print.h"
namespace ArduinoJson
{
namespace Generator
{
// Decorator on top of Print to allow indented output.
// This class is used by JsonPrintable::prettyPrintTo() but can also be used
// for your own purpose, like logging.
class IndentedPrint : public Print
{
public:
IndentedPrint(Print& p)
: sink(&p)
{
level = 0;
tabSize = 2;
isNewLine = true;
}
virtual size_t write(uint8_t);
// Adds one level of indentation
void indent();
// Removes one level of indentation
void unindent();
// Set the number of space printed for each level of indentation
void setTabSize(uint8_t n);
private:
Print* sink;
uint8_t level : 4;
uint8_t tabSize : 3;
bool isNewLine : 1;
size_t writeTabs();
static const int MAX_LEVEL = 15; // because it's only 4 bits
static const int MAX_TAB_SIZE = 7; // because it's only 3 bits
};
}
}
*/
#pragma once
#include "../Arduino/Print.h"
namespace ArduinoJson
{
namespace Generator
{
// Decorator on top of Print to allow indented output.
// This class is used by JsonPrintable::prettyPrintTo() but can also be used
// for your own purpose, like logging.
class IndentedPrint : public Print
{
public:
IndentedPrint(Print& p)
: sink(&p)
{
level = 0;
tabSize = 2;
isNewLine = true;
}
virtual size_t write(uint8_t);
// Adds one level of indentation
void indent();
// Removes one level of indentation
void unindent();
// Set the number of space printed for each level of indentation
void setTabSize(uint8_t n);
private:
Print* sink;
uint8_t level : 4;
uint8_t tabSize : 3;
bool isNewLine : 1;
size_t writeTabs();
static const int MAX_LEVEL = 15; // because it's only 4 bits
static const int MAX_TAB_SIZE = 7; // because it's only 3 bits
};
}
}

360
srcs/Internals/JsonNode.h → include/ArduinoJson/Internals/JsonNode.h
View File

@ -1,181 +1,181 @@
#pragma once
class JsonBuffer;
class JsonWriter;
class JsonNodeIterator;
class JsonNode
{
friend class JsonNodeIterator;
enum JsonNodeType
{
JSON_UNDEFINED,
JSON_NULL,
JSON_ARRAY,
JSON_OBJECT,
JSON_KEY_VALUE,
JSON_BOOLEAN,
JSON_STRING,
JSON_LONG,
JSON_PROXY,
JSON_DOUBLE_0_DECIMALS,
JSON_DOUBLE_1_DECIMAL,
JSON_DOUBLE_2_DECIMALS,
// etc.
};
union JsonNodeContent
{
bool asBoolean;
double asDouble;
long asInteger;
const char* asString;
struct
{
const char* key;
JsonNode* value;
} asKey;
struct
{
JsonNode* child;
JsonBuffer* buffer;
} asContainer;
struct
{
JsonNode* target;
} asProxy;
};
public:
JsonNode()
: type(JSON_UNDEFINED), next(0)
{
}
void writeTo(JsonWriter&); // TODO: <- move in JsonNodeSerializer
void setAsArray(JsonBuffer* buffer)
{
type = JSON_ARRAY;
content.asContainer.child = 0;
content.asContainer.buffer = buffer;
}
void setAsBoolean(bool value)
{
type = JSON_BOOLEAN;
content.asBoolean = value;
}
void setAsLong(int value)
{
type = JSON_LONG;
content.asInteger = value;
}
void setAsString(char const* value)
{
type = JSON_STRING;
content.asString = value;
}
void setAsDouble(double value, int decimals)
{
type = static_cast<JsonNodeType>(JSON_DOUBLE_0_DECIMALS + decimals);
content.asDouble = value;
}
void setAsObject(JsonBuffer* buffer)
{
type = JSON_OBJECT;
content.asContainer.child = 0;
content.asContainer.buffer = buffer;
}
void setAsObjectKeyValue(const char* key, JsonNode* value)
{
type = JSON_KEY_VALUE;
content.asKey.key = key;
content.asKey.value = value;
}
bool getAsBoolean()
{
return type == JSON_BOOLEAN ? content.asBoolean : false;
}
double getAsDouble()
{
return type >= JSON_DOUBLE_0_DECIMALS ? content.asDouble : 0;
}
long getAsInteger()
{
return type == JSON_LONG ? content.asInteger : 0;
}
const char* getAsString()
{
return type == JSON_STRING ? content.asString : 0;
}
JsonBuffer* getContainerBuffer()
{
if (type == JSON_PROXY) return content.asProxy.target->getContainerBuffer();
return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.buffer : 0;
}
JsonNode* getContainerChild()
{
if (type == JSON_PROXY) return content.asProxy.target->getContainerChild();
return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.child : 0;
}
const char* getAsObjectKey()
{
return type == JSON_KEY_VALUE ? content.asKey.key : 0;
}
JsonNode* getAsObjectValue()
{
return type == JSON_KEY_VALUE ? content.asKey.value : 0;
}
JsonNode* getProxyTarget()
{
return type == JSON_PROXY ? content.asProxy.target : this;
}
bool isArray()
{
return type == JSON_ARRAY;
}
void addChild(JsonNode* childToAdd);
void removeChild(JsonNode* childToRemove);
void duplicate(JsonNode* other);
private:
JsonNode* next;
JsonNodeContent content;
JsonNodeType type;
inline void writeArrayTo(JsonWriter&);// TODO: <- move in JsonNodeSerializer
inline void writeObjectTo(JsonWriter&);// TODO: <- move in JsonNodeSerializer
void setAsProxyOfSelf();
void setAsProxyOf(JsonNode* target)
{
type = JSON_PROXY;
content.asProxy.target = target;
}
#pragma once
class JsonBuffer;
class JsonWriter;
class JsonNodeIterator;
class JsonNode
{
friend class JsonNodeIterator;
enum JsonNodeType
{
JSON_UNDEFINED,
JSON_NULL,
JSON_ARRAY,
JSON_OBJECT,
JSON_KEY_VALUE,
JSON_BOOLEAN,
JSON_STRING,
JSON_LONG,
JSON_PROXY,
JSON_DOUBLE_0_DECIMALS,
JSON_DOUBLE_1_DECIMAL,
JSON_DOUBLE_2_DECIMALS,
// etc.
};
union JsonNodeContent
{
bool asBoolean;
double asDouble;
long asInteger;
const char* asString;
struct
{
const char* key;
JsonNode* value;
} asKey;
struct
{
JsonNode* child;
JsonBuffer* buffer;
} asContainer;
struct
{
JsonNode* target;
} asProxy;
};
public:
JsonNode()
: type(JSON_UNDEFINED), next(0)
{
}
void writeTo(JsonWriter&); // TODO: <- move in JsonNodeSerializer
void setAsArray(JsonBuffer* buffer)
{
type = JSON_ARRAY;
content.asContainer.child = 0;
content.asContainer.buffer = buffer;
}
void setAsBoolean(bool value)
{
type = JSON_BOOLEAN;
content.asBoolean = value;
}
void setAsLong(int value)
{
type = JSON_LONG;
content.asInteger = value;
}
void setAsString(char const* value)
{
type = JSON_STRING;
content.asString = value;
}
void setAsDouble(double value, int decimals)
{
type = static_cast<JsonNodeType>(JSON_DOUBLE_0_DECIMALS + decimals);
content.asDouble = value;
}
void setAsObject(JsonBuffer* buffer)
{
type = JSON_OBJECT;
content.asContainer.child = 0;
content.asContainer.buffer = buffer;
}
void setAsObjectKeyValue(const char* key, JsonNode* value)
{
type = JSON_KEY_VALUE;
content.asKey.key = key;
content.asKey.value = value;
}
bool getAsBoolean()
{
return type == JSON_BOOLEAN ? content.asBoolean : false;
}
double getAsDouble()
{
return type >= JSON_DOUBLE_0_DECIMALS ? content.asDouble : 0;
}
long getAsInteger()
{
return type == JSON_LONG ? content.asInteger : 0;
}
const char* getAsString()
{
return type == JSON_STRING ? content.asString : 0;
}
JsonBuffer* getContainerBuffer()
{
if (type == JSON_PROXY) return content.asProxy.target->getContainerBuffer();
return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.buffer : 0;
}
JsonNode* getContainerChild()
{
if (type == JSON_PROXY) return content.asProxy.target->getContainerChild();
return type == JSON_ARRAY || type == JSON_OBJECT ? content.asContainer.child : 0;
}
const char* getAsObjectKey()
{
return type == JSON_KEY_VALUE ? content.asKey.key : 0;
}
JsonNode* getAsObjectValue()
{
return type == JSON_KEY_VALUE ? content.asKey.value : 0;
}
JsonNode* getProxyTarget()
{
return type == JSON_PROXY ? content.asProxy.target : this;
}
bool isArray()
{
return type == JSON_ARRAY;
}
void addChild(JsonNode* childToAdd);
void removeChild(JsonNode* childToRemove);
void duplicate(JsonNode* other);
private:
JsonNode* next;
JsonNodeContent content;
JsonNodeType type;
inline void writeArrayTo(JsonWriter&);// TODO: <- move in JsonNodeSerializer
inline void writeObjectTo(JsonWriter&);// TODO: <- move in JsonNodeSerializer
void setAsProxyOfSelf();
void setAsProxyOf(JsonNode* target)
{
type = JSON_PROXY;
content.asProxy.target = target;
}
};

74
srcs/Internals/JsonNodeIterator.h → include/ArduinoJson/Internals/JsonNodeIterator.h
View File

@ -1,37 +1,37 @@
#pragma once
#include "JsonNode.h"
class JsonNodeIterator
{
public:
explicit JsonNodeIterator(JsonNode* node)
: node(node)
{
}
bool operator!= (const JsonNodeIterator& other) const
{
return node != other.node;
}
void operator++()
{
node = node->next;
}
JsonNode* operator*() const
{
return node;
}
JsonNode* operator->() const
{
return node;
}
private:
JsonNode* node;
};
#pragma once
#include "JsonNode.h"
class JsonNodeIterator
{
public:
explicit JsonNodeIterator(JsonNode* node)
: node(node)
{
}
bool operator!= (const JsonNodeIterator& other) const
{
return node != other.node;
}
void operator++()
{
node = node->next;
}
JsonNode* operator*() const
{
return node;
}
JsonNode* operator->() const
{
return node;
}
private:
JsonNode* node;
};

74
srcs/Internals/JsonNodeWrapper.h → include/ArduinoJson/Internals/JsonNodeWrapper.h
View File

@ -1,37 +1,37 @@
#pragma once
#include "JsonNode.h"
class JsonValue;
class JsonNodeWrapper
{
friend JsonValue;
public:
JsonNodeWrapper()
: _node(0)
{
}
explicit JsonNodeWrapper(JsonNode* node)
: _node(node)
{
}
protected:
void duplicate(const JsonNodeWrapper& other)
{
if (!_node)
{
_node = other._node;
}
else
{
_node->duplicate(other._node);
}
}
JsonNode* _node;
};
#pragma once
#include "JsonNode.h"
class JsonValue;
class JsonNodeWrapper
{
friend JsonValue;
public:
JsonNodeWrapper()
: _node(0)
{
}
explicit JsonNodeWrapper(JsonNode* node)
: _node(node)
{
}
protected:
void duplicate(const JsonNodeWrapper& other)
{
if (!_node)
{
_node = other._node;
}
else
{
_node->duplicate(other._node);
}
}
JsonNode* _node;
};

0
srcs/Internals/JsonParser.h → include/ArduinoJson/Internals/JsonParser.h
View File

98
srcs/Internals/JsonWriter.h → include/ArduinoJson/Internals/JsonWriter.h
View File

@ -1,49 +1,49 @@
#pragma once
#include "../Arduino/Print.h"
class JsonWriter
{
public:
explicit JsonWriter(Print* sink)
: _sink(sink), _length(0)
{
}
size_t bytesWritten()
{
return _length;
}
virtual void beginArray() = 0;
virtual void endArray() = 0;
virtual void beginObject() = 0;
virtual void endObject() = 0;
void writeString(const char* value);
void writeInteger(long value);
void writeBoolean(bool value);
void writeDouble(double value, int decimals);
virtual void writeColon() = 0;
virtual void writeComma() = 0;
void writeEmptyArray()
{
_length += _sink->print("[]");
}
void writeEmptyObject()
{
_length += _sink->print("{}");
}
protected:
Print* _sink;
size_t _length;
};
#pragma once
#include "../Arduino/Print.h"
class JsonWriter
{
public:
explicit JsonWriter(Print* sink)
: _sink(sink), _length(0)
{
}
size_t bytesWritten()
{
return _length;
}
virtual void beginArray() = 0;
virtual void endArray() = 0;
virtual void beginObject() = 0;
virtual void endObject() = 0;
void writeString(const char* value);
void writeInteger(long value);
void writeBoolean(bool value);
void writeDouble(double value, int decimals);
virtual void writeColon() = 0;
virtual void writeComma() = 0;
void writeEmptyArray()
{
_length += _sink->print("[]");
}
void writeEmptyObject()
{
_length += _sink->print("{}");
}
protected:
Print* _sink;
size_t _length;
};

130
srcs/Internals/PrettyJsonWriter.h → include/ArduinoJson/Internals/PrettyJsonWriter.h
View File

@ -1,65 +1,65 @@
#pragma once
#include "JsonWriter.h"
#include "IndentedPrint.h"
using namespace ArduinoJson::Generator;
class PrettyJsonWriter : public JsonWriter
{
public:
explicit PrettyJsonWriter(IndentedPrint* sink)
: JsonWriter(sink), _indenter(sink)
{
}
virtual void beginArray()
{
_length += _sink->write('[');
indent();
}
virtual void endArray()
{
unindent();
_length += _sink->write(']');
}
virtual void writeColon()
{
_length += _sink->print(": ");
}
virtual void writeComma()
{
_length += _sink->write(',');
_length += _indenter->println();
}
virtual void beginObject()
{
_length += _sink->write('{');
indent();
}
virtual void endObject()
{
unindent();
_length += _sink->write('}');
}
private:
IndentedPrint* _indenter;
void indent()
{
_indenter->indent();
_length += _indenter->println();
}
void unindent()
{
_length += _indenter->println();
_indenter->unindent();
}
};
#pragma once
#include "JsonWriter.h"
#include "IndentedPrint.h"
using namespace ArduinoJson::Generator;
class PrettyJsonWriter : public JsonWriter
{
public:
explicit PrettyJsonWriter(IndentedPrint* sink)
: JsonWriter(sink), _indenter(sink)
{
}
virtual void beginArray()
{
_length += _sink->write('[');
indent();
}
virtual void endArray()
{
unindent();
_length += _sink->write(']');
}
virtual void writeColon()
{
_length += _sink->print(": ");
}
virtual void writeComma()
{
_length += _sink->write(',');
_length += _indenter->println();
}
virtual void beginObject()
{
_length += _sink->write('{');
indent();
}
virtual void endObject()
{
unindent();
_length += _sink->write('}');
}
private:
IndentedPrint* _indenter;
void indent()
{
_indenter->indent();
_length += _indenter->println();
}
void unindent()
{
_length += _indenter->println();
_indenter->unindent();
}
};

60
srcs/Internals/StringBuilder.h → include/ArduinoJson/Internals/StringBuilder.h
View File

@ -1,31 +1,31 @@
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#pragma once
#include "../Arduino/Print.h"
namespace ArduinoJson
{
namespace Internals
{
class StringBuilder : public Print
{
public:
StringBuilder(char* buf, int size)
: buffer(buf), capacity(size - 1), length(0)
{
buffer[0] = 0;
}
virtual size_t write(uint8_t c);
private:
char* buffer;
int capacity;
int length;
};
}
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#pragma once
#include "../Arduino/Print.h"
namespace ArduinoJson
{
namespace Internals
{
class StringBuilder : public Print
{
public:
StringBuilder(char* buf, int size)
: buffer(buf), capacity(size - 1), length(0)
{
buffer[0] = 0;
}
virtual size_t write(uint8_t c);
private:
char* buffer;
int capacity;
int length;
};
}
}

68
srcs/JsonArray.h → include/ArduinoJson/JsonArray.h
View File

@ -1,34 +1,34 @@
#pragma once
#include "JsonContainer.h"
class JsonArray : public JsonContainer
{
public:
JsonArray()
{
}
explicit JsonArray(JsonNode* node)
: JsonContainer(node)
{
}
JsonValue operator[](int index) const;
void add(bool value);
void add(const char* value);
void add(double value, int decimals=2);
void add(int value) { add((long) value); }
void add(long value);
void add(JsonContainer nestedArray); // TODO: should allow JsonValue too
JsonArray createNestedArray();
JsonObject createNestedObject();
bool success()
{
return _node && _node->isArray();
}
};
#pragma once
#include "JsonContainer.h"
class JsonArray : public JsonContainer
{
public:
JsonArray()
{
}
explicit JsonArray(JsonNode* node)
: JsonContainer(node)
{
}
JsonValue operator[](int index) const;
void add(bool value);
void add(const char* value);
void add(double value, int decimals=2);
void add(int value) { add((long) value); }
void add(long value);
void add(JsonContainer nestedArray); // TODO: should allow JsonValue too
JsonArray createNestedArray();
JsonObject createNestedObject();
bool success()
{
return _node && _node->isArray();
}
};

88
srcs/JsonBuffer.h → include/ArduinoJson/JsonBuffer.h
View File

@ -1,44 +1,44 @@
#pragma once
#include "JsonArray.h"
#include "JsonObject.h"
class JsonParser;
class JsonBuffer
{
friend class JsonContainer;
friend class JsonNode;
friend class JsonParser;
public:
virtual ~JsonBuffer() {};
JsonArray createArray()
{
return JsonArray(createArrayNode());
}
JsonObject createObject()
{
return JsonObject(createObjectNode());
}
JsonValue createValue();
JsonArray parseArray(char* string);
protected:
virtual void* allocateNode() = 0;
private:
JsonNode* createNode();
JsonNode* createArrayNode();
JsonNode* createBoolNode(bool value);
JsonNode* createDoubleNode(double value, int decimals);
JsonNode* createLongNode(long value);
JsonNode* createObjectNode();
JsonNode* createStringNode(const char* value);
};
#pragma once
#include "JsonArray.h"
#include "JsonObject.h"
class JsonParser;
class JsonBuffer
{
friend class JsonContainer;
friend class JsonNode;
friend class JsonParser;
public:
virtual ~JsonBuffer() {};
JsonArray createArray()
{
return JsonArray(createArrayNode());
}
JsonObject createObject()
{
return JsonObject(createObjectNode());
}
JsonValue createValue();
JsonArray parseArray(char* string);
protected:
virtual void* allocateNode() = 0;
private:
JsonNode* createNode();
JsonNode* createArrayNode();
JsonNode* createBoolNode(bool value);
JsonNode* createDoubleNode(double value, int decimals);
JsonNode* createLongNode(long value);
JsonNode* createObjectNode();
JsonNode* createStringNode(const char* value);
};

109
srcs/JsonContainer.h → include/ArduinoJson/JsonContainer.h
View File

@ -1,54 +1,55 @@
#pragma once
#include "Arduino/Printable.h"
#include "Internals/JsonNodeIterator.h"
#include "Internals/JsonNode.h"
#include "Internals/IndentedPrint.h"
#include "Internals/JsonNodeWrapper.h"
class JsonArray;
class JsonObject;
class JsonValue;
class JsonContainer : public Printable, public JsonNodeWrapper
{
// friend JsonValue;
friend JsonArray;
public:
JsonContainer() {}
explicit JsonContainer(JsonNode* node)
: JsonNodeWrapper(node)
{
}
size_t size() const;
bool operator==(JsonContainer const& other) const;
size_t printTo(char* buffer, size_t bufferSize) const;
virtual size_t printTo(Print& print) const;
size_t prettyPrintTo(char* buffer, size_t bufferSize) const;
size_t prettyPrintTo(ArduinoJson::Generator::IndentedPrint& print) const;
size_t prettyPrintTo(Print& print) const;
protected:
JsonNodeIterator beginChildren() const
{
return JsonNodeIterator(_node ? _node->getContainerChild() : 0);
}
JsonNodeIterator endChildren() const
{
return JsonNodeIterator(0);
}
void addChild(JsonNode*);
void removeChild(JsonNode*);
JsonNode* createNode();
};
#pragma once
#include "ArduinoJson/Arduino/Printable.h"
#include "ArduinoJson/Internals/JsonNodeIterator.h"
#include "ArduinoJson/Internals/JsonNode.h"
#include "ArduinoJson/Internals/IndentedPrint.h"
#include "ArduinoJson/Internals/JsonNodeWrapper.h"
class JsonArray;
class JsonObject;
class JsonValue;
class JsonContainer : public Printable, public JsonNodeWrapper
{
// friend JsonValue;
friend JsonArray;
public:
JsonContainer() {}
explicit JsonContainer(JsonNode* node)
: JsonNodeWrapper(node)
{
}
size_t size() const;
bool operator==(JsonContainer const& other) const;
size_t printTo(char* buffer, size_t bufferSize) const;
virtual size_t printTo(Print& print) const;
size_t prettyPrintTo(char* buffer, size_t bufferSize) const;
size_t prettyPrintTo(ArduinoJson::Generator::IndentedPrint& print) const;
size_t prettyPrintTo(Print& print) const;
protected:
JsonNodeIterator beginChildren() const
{
return JsonNodeIterator(_node ? _node->getContainerChild() : 0);
}
JsonNodeIterator endChildren() const
{
return JsonNodeIterator(0);
}
void addChild(JsonNode*);
void removeChild(JsonNode*);
JsonNode* createNode();
};

50
srcs/JsonObject.h → include/ArduinoJson/JsonObject.h
View File

@ -1,26 +1,26 @@
#pragma once
#include "JsonContainer.h"
class JsonObject : public JsonContainer
{
public:
JsonObject()
{
}
explicit JsonObject(JsonNode* node)
: JsonContainer(node)
{
}
JsonValue operator[](const char* key);
void remove(const char* key);
JsonArray createNestedArray(const char* key);
JsonObject createNestedObject(const char* key);
private:
JsonNode* getOrCreateNodeAt(const char* key);
#pragma once
#include "JsonContainer.h"
class JsonObject : public JsonContainer
{
public:
JsonObject()
{
}
explicit JsonObject(JsonNode* node)
: JsonContainer(node)
{
}
JsonValue operator[](const char* key);
void remove(const char* key);
JsonArray createNestedArray(const char* key);
JsonObject createNestedObject(const char* key);
private:
JsonNode* getOrCreateNodeAt(const char* key);
};

70
srcs/JsonValue.h → include/ArduinoJson/JsonValue.h
View File

@ -1,36 +1,36 @@
#pragma once
#include "Internals/JsonNodeWrapper.h"
class JsonArray;
class JsonContainer;
class JsonObject;
class JsonValue : public JsonNodeWrapper
{
public:
JsonValue() {}
explicit JsonValue(JsonNode* node)
: JsonNodeWrapper(node)
{
}
void operator=(bool);
void operator=(const char*);
void operator=(double x) { set(x, 2); }
void operator=(int);
void operator=(const JsonValue& value) { duplicate(value); }
void operator=(const JsonNodeWrapper& object) { duplicate(object); }
operator bool() const;
operator const char*() const;
operator double() const;
operator long() const;
operator int() const { return operator long(); }
operator JsonArray() const;
operator JsonObject() const;
void set(double value, int decimals);
#pragma once
#include "Internals/JsonNodeWrapper.h"
class JsonArray;
class JsonContainer;
class JsonObject;
class JsonValue : public JsonNodeWrapper
{
public:
JsonValue() {}
explicit JsonValue(JsonNode* node)
: JsonNodeWrapper(node)
{
}
void operator=(bool);
void operator=(const char*);
void operator=(double x) { set(x, 2); }
void operator=(int);
void operator=(const JsonValue& value) { duplicate(value); }
void operator=(const JsonNodeWrapper& object) { duplicate(object); }
operator bool() const;
operator const char*() const;
operator double() const;
operator long() const;
operator int() const { return operator long(); }
operator JsonArray() const;
operator JsonObject() const;
void set(double value, int decimals);
};

84
srcs/StaticJsonBuffer.h → include/ArduinoJson/StaticJsonBuffer.h
View File

@ -1,42 +1,42 @@
#pragma once
#include "JsonBuffer.h"
#include "JsonObject.h"
template<int CAPACITY>
class StaticJsonBuffer : public JsonBuffer
{
friend JsonObject;
public:
explicit StaticJsonBuffer()
: _size(0)
{
}
virtual ~StaticJsonBuffer() {}
int capacity()
{
return CAPACITY;
}
int size()
{
return _size;
}
protected:
virtual void* allocateNode()
{
if (_size >= CAPACITY) return 0;
return &_buffer[_size++];
}
private:
JsonNode _buffer[CAPACITY];
int _size;
};
#pragma once
#include "JsonBuffer.h"
#include "JsonObject.h"
template<int CAPACITY>
class StaticJsonBuffer : public JsonBuffer
{
friend JsonObject;
public:
explicit StaticJsonBuffer()
: _size(0)
{
}
virtual ~StaticJsonBuffer() {}
int capacity()
{
return CAPACITY;
}
int size()
{
return _size;
}
protected:
virtual void* allocateNode()
{
if (_size >= CAPACITY) return 0;
return &_buffer[_size++];
}
private:
JsonNode _buffer[CAPACITY];
int _size;
};

18
srcs/Arduino/Print.cpp
View File

@ -1,13 +1,13 @@
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#ifndef ARDUINO
#include "Print.h"
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#ifndef ARDUINO
#include "ArduinoJson/Arduino/Print.h"
#include <cstdio>
size_t Print::print(const char s[])
{
size_t n = 0;

7
srcs/CMakeLists.txt
View File

@ -1,3 +1,6 @@
file(GLOB_RECURSE SRCS_FILES *.cpp *.h)
file(GLOB_RECURSE INC_FILES ../include/*.h)
file(GLOB_RECURSE SRC_FILES *.cpp)
add_library(ArduinoJson ${SRCS_FILES})
include_directories(../include)
add_library(ArduinoJson ${SRC_FILES} ${INC_FILES})

2
srcs/Internals/CompactJsonWriter.cpp
View File

@ -1 +1 @@
#include "CompactJsonWriter.h"
#include "ArduinoJson/Internals/CompactJsonWriter.h"

10
srcs/Internals/EscapedString.cpp
View File

@ -1,9 +1,9 @@
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#include "EscapedString.h"
#include "ArduinoJson/Internals/EscapedString.h"
using namespace ArduinoJson::Internals;

2
srcs/Internals/IndentedPrint.cpp
View File

@ -1,4 +1,4 @@
#include "IndentedPrint.h"
#include "ArduinoJson/Internals/IndentedPrint.h"
using namespace ArduinoJson::Generator;

10
srcs/Internals/JsonNode.cpp
View File

@ -1,9 +1,9 @@
#include "JsonNode.h"
#include "ArduinoJson/Internals/JsonNode.h"
#include "JsonWriter.h"
#include "../JsonArray.h"
#include "../JsonObject.h"
#include "../JsonBuffer.h"
#include "ArduinoJson/Internals/JsonWriter.h"
#include "ArduinoJson/JsonArray.h"
#include "ArduinoJson/JsonObject.h"
#include "ArduinoJson/JsonBuffer.h"
void JsonNode::writeTo(JsonWriter& writer)
{

4
srcs/Internals/JsonParser.cpp
View File

@ -1,5 +1,5 @@
#include "JsonParser.h"
#include "../JsonBuffer.h"
#include "ArduinoJson/Internals/JsonParser.h"
#include "ArduinoJson/JsonBuffer.h"
#include <stdlib.h> // for strtol, strtod
#include <ctype.h>

4
srcs/Internals/JsonWriter.cpp
View File

@ -1,5 +1,5 @@
#include "JsonWriter.h"
#include "EscapedString.h"
#include "ArduinoJson/Internals/JsonWriter.h"
#include "ArduinoJson/Internals/EscapedString.h"
using namespace ArduinoJson::Internals;

2
srcs/Internals/PrettyJsonWriter.cpp
View File

@ -1 +1 @@
#include "PrettyJsonWriter.h"
#include "ArduinoJson/Internals/PrettyJsonWriter.h"

8
srcs/Internals/StringBuilder.cpp
View File

@ -1,9 +1,9 @@
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
/*
* Arduino JSON library
* Benoit Blanchon 2014 - MIT License
*/
#include "StringBuilder.h"
#include "ArduinoJson/Internals/StringBuilder.h"
using namespace ArduinoJson::Internals;

7
srcs/JsonArray.cpp
View File

@ -1,7 +1,6 @@
#include "JsonArray.h"
#include "JsonObject.h"
#include "JsonValue.h"
#include "ArduinoJson/JsonArray.h"
#include "ArduinoJson/JsonObject.h"
#include "ArduinoJson/JsonValue.h"
JsonValue JsonArray::operator[](int index) const
{

8
srcs/JsonBuffer.cpp
View File

@ -1,10 +1,10 @@
#include "JsonBuffer.h"
#include "ArduinoJson/JsonBuffer.h"
#include <new>
#include "JsonValue.h"
#include "Internals/JsonParser.h"
#include "Internals/JsonNode.h"
#include "ArduinoJson/JsonValue.h"
#include "ArduinoJson/Internals/JsonParser.h"
#include "ArduinoJson/Internals/JsonNode.h"
JsonValue JsonBuffer::createValue()
{

10
srcs/JsonContainer.cpp
View File

@ -1,9 +1,9 @@
#include "JsonContainer.h"
#include "ArduinoJson/JsonContainer.h"
#include "JsonBuffer.h"
#include "Internals/StringBuilder.h"
#include "Internals/CompactJsonWriter.h"
#include "Internals/PrettyJsonWriter.h"
#include "ArduinoJson/JsonBuffer.h"
#include "ArduinoJson/Internals/StringBuilder.h"
#include "ArduinoJson/Internals/CompactJsonWriter.h"
#include "ArduinoJson/Internals/PrettyJsonWriter.h"
using namespace ArduinoJson::Internals;

12
srcs/JsonObject.cpp
View File

@ -1,12 +1,12 @@
#include "JsonObject.h"
#include "ArduinoJson/JsonObject.h"
#include <string.h> // for strcmp
#include "JsonBuffer.h"
#include "JsonValue.h"
#include "Internals/EscapedString.h"
#include "Internals/JsonNode.h"
#include "Internals/StringBuilder.h"
#include "ArduinoJson/JsonBuffer.h"
#include "ArduinoJson/JsonValue.h"
#include "ArduinoJson/Internals/EscapedString.h"
#include "ArduinoJson/Internals/JsonNode.h"
#include "ArduinoJson/Internals/StringBuilder.h"
using namespace ArduinoJson::Internals;

8
srcs/JsonValue.cpp
View File

@ -1,8 +1,8 @@
#include "JsonValue.h"
#include "ArduinoJson/JsonValue.h"
#include "JsonArray.h"
#include "JsonObject.h"
#include "Internals/JsonNode.h"
#include "ArduinoJson/JsonArray.h"
#include "ArduinoJson/JsonObject.h"
#include "ArduinoJson/Internals/JsonNode.h"
void JsonValue::operator=(bool value)
{

4
tests/CMakeLists.txt
View File

@ -1,14 +1,16 @@
set(GTEST_DIR ../third-party/gtest-1.7.0)
file(GLOB_RECURSE INC_FILES ../include/*.h)
file(GLOB TESTS_FILES *.cpp)
include_directories(
../srcs
../include
${GTEST_DIR}
${GTEST_DIR}/include)
add_executable(ArduinoJsonTests
${TESTS_FILES}
${INC_FILES}
${GTEST_DIR}/src/gtest-all.cc
${GTEST_DIR}/src/gtest_main.cc)

4
tests/EscapedStringTests.cpp
View File

@ -1,7 +1,7 @@
#include <gtest/gtest.h>
#include <Internals/EscapedString.h>
#include <Internals/StringBuilder.h>
#include <ArduinoJson/Internals/EscapedString.h>
#include <ArduinoJson/Internals/StringBuilder.h>
using namespace ArduinoJson::Internals;

8
tests/Issue10.cpp
View File

@ -1,8 +1,8 @@
#include <gtest/gtest.h>
#include <JsonArray.h>
#include <JsonObject.h>
#include <JsonValue.h>
#include <StaticJsonBuffer.h>
#include <ArduinoJson/JsonArray.h>
#include <ArduinoJson/JsonObject.h>
#include <ArduinoJson/JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
using namespace ArduinoJson::Generator;

4
tests/JsonArray_Container_Tests.cpp
View File

@ -1,6 +1,6 @@
#include <gtest/gtest.h>
#include <StaticJsonBuffer.h>
#include <JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
#include <ArduinoJson/JsonValue.h>
class JsonArray_Container_Tests : public ::testing::Test
{

4
tests/JsonArray_Parser_Tests.cpp
View File

@ -1,6 +1,6 @@
#include <gtest/gtest.h>
#include <StaticJsonBuffer.h>
#include <JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
#include <ArduinoJson/JsonValue.h>
class JsonArray_Parser_Tests : public testing::Test
{

8
tests/JsonArray_PrettyPrintTo_Tests.cpp
View File

@ -4,10 +4,10 @@
*/
#include <gtest/gtest.h>
#include <JsonArray.h>
#include <JsonObject.h>
#include <JsonValue.h>
#include <StaticJsonBuffer.h>
#include <ArduinoJson/JsonArray.h>
#include <ArduinoJson/JsonObject.h>
#include <ArduinoJson/JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
class JsonArray_PrettyPrintTo_Tests : public testing::Test
{

6
tests/JsonArray_PrintTo_Tests.cpp
View File

@ -4,9 +4,9 @@
*/
#include <gtest/gtest.h>
#include <JsonArray.h>
#include <JsonObject.h>
#include <StaticJsonBuffer.h>
#include <ArduinoJson/JsonArray.h>
#include <ArduinoJson/JsonObject.h>
#include <ArduinoJson/StaticJsonBuffer.h>
class JsonArray_PrintTo_Tests : public testing::Test
{

4
tests/JsonObject_Container_Tests.cpp
View File

@ -1,6 +1,6 @@
#include <gtest/gtest.h>
#include <StaticJsonBuffer.h>
#include <JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
#include <ArduinoJson/JsonValue.h>
class JsonObject_Container_Tests : public ::testing::Test
{

6
tests/JsonObject_PrettyPrintTo_Tests.cpp
View File

@ -4,9 +4,9 @@
*/
#include <gtest/gtest.h>
#include <JsonObject.h>
#include <JsonValue.h>
#include <StaticJsonBuffer.h>
#include <ArduinoJson/JsonObject.h>
#include <ArduinoJson/JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
class JsonObject_PrettyPrintTo_Tests : public testing::Test
{

8
tests/JsonObject_Serialization_Tests.cpp
View File

@ -1,8 +1,8 @@
#include <gtest/gtest.h>
#include <JsonArray.h>
#include <JsonObject.h>
#include <JsonValue.h>
#include <StaticJsonBuffer.h>
#include <ArduinoJson/JsonArray.h>
#include <ArduinoJson/JsonObject.h>
#include <ArduinoJson/JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
class JsonObject_Serialization_Tests : public testing::Test
{

4
tests/JsonValueTests.cpp
View File

@ -1,6 +1,6 @@
#include <gtest/gtest.h>
#include <StaticJsonBuffer.h>
#include <JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
#include <ArduinoJson/JsonValue.h>
class JsonValueTests : public ::testing::Test
{

4
tests/StaticJsonBufferTests.cpp
View File

@ -1,6 +1,6 @@
#include <gtest/gtest.h>
#include <StaticJsonBuffer.h>
#include <JsonValue.h>
#include <ArduinoJson/StaticJsonBuffer.h>
#include <ArduinoJson/JsonValue.h>
TEST(StaticJsonBuffer, CapacityMatchTemplateParameter)
{

2
tests/StringBuilderTests.cpp
View File

@ -1,5 +1,5 @@
#include <gtest/gtest.h>
#include <Internals/StringBuilder.h>
#include <ArduinoJson/Internals/StringBuilder.h>
using namespace ArduinoJson::Internals;