Remove exiv2json sample and tests depending on it
Luis Díaz Más
3 years ago
parent
3b9fcb4b3d
commit
c6340caca7
@ -1,974 +0,0 @@
|
||||
// ***************************************************************** -*- C++ -*-
|
||||
/*
|
||||
Copyright (c) 2013 Johannes Häggqvist
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifdef _WINDLL
|
||||
#define JzonAPI __declspec(dllexport)
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
|
||||
#endif
|
||||
|
||||
#include "Jzon.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <stack>
|
||||
|
||||
namespace Jzon {
|
||||
class FormatInterpreter {
|
||||
public:
|
||||
FormatInterpreter() {
|
||||
SetFormat(NoFormat);
|
||||
}
|
||||
explicit FormatInterpreter(const Format& format) {
|
||||
SetFormat(format);
|
||||
}
|
||||
|
||||
void SetFormat(const Format& format) {
|
||||
this->format = format;
|
||||
indentationChar = (format.useTabs ? '\t' : ' ');
|
||||
spacing = (format.spacing ? " " : "");
|
||||
newline = (format.newline ? "\n" : spacing);
|
||||
}
|
||||
|
||||
std::string GetIndentation(size_t level) const {
|
||||
if (format.newline)
|
||||
return std::string(format.indentSize * level, indentationChar);
|
||||
return "";
|
||||
}
|
||||
|
||||
inline const std::string& GetNewline() const {
|
||||
return newline;
|
||||
}
|
||||
inline const std::string& GetSpacing() const {
|
||||
return spacing;
|
||||
}
|
||||
|
||||
private:
|
||||
Format format;
|
||||
char indentationChar;
|
||||
std::string newline;
|
||||
std::string spacing;
|
||||
};
|
||||
|
||||
inline bool IsWhitespace(char c) {
|
||||
return (c == '\n' || c == ' ' || c == '\t' || c == '\r' || c == '\f');
|
||||
}
|
||||
inline bool IsNumber(char c) {
|
||||
return ((c >= '0' && c <= '9') || c == '.' || c == '-');
|
||||
}
|
||||
|
||||
Object& Node::AsObject() {
|
||||
if (IsObject())
|
||||
return dynamic_cast<Object&>(*this);
|
||||
throw TypeException();
|
||||
}
|
||||
const Object& Node::AsObject() const {
|
||||
if (IsObject())
|
||||
return dynamic_cast<const Object&>(*this);
|
||||
throw TypeException();
|
||||
}
|
||||
Array& Node::AsArray() {
|
||||
if (IsArray())
|
||||
return dynamic_cast<Array&>(*this);
|
||||
throw TypeException();
|
||||
}
|
||||
const Array& Node::AsArray() const {
|
||||
if (IsArray())
|
||||
return dynamic_cast<const Array&>(*this);
|
||||
throw TypeException();
|
||||
}
|
||||
Value& Node::AsValue() {
|
||||
if (IsValue())
|
||||
return dynamic_cast<Value&>(*this);
|
||||
throw TypeException();
|
||||
}
|
||||
const Value& Node::AsValue() const {
|
||||
if (IsValue())
|
||||
return dynamic_cast<const Value&>(*this);
|
||||
throw TypeException();
|
||||
}
|
||||
|
||||
Node::Type Node::DetermineType(const std::string& json) {
|
||||
auto jsonIt = std::find_if(json.begin(), json.end(), IsWhitespace);
|
||||
if (jsonIt == json.end())
|
||||
return T_VALUE;
|
||||
|
||||
switch (*jsonIt) {
|
||||
case '{':
|
||||
return T_OBJECT;
|
||||
case '[':
|
||||
return T_ARRAY;
|
||||
default:
|
||||
return T_VALUE;
|
||||
}
|
||||
}
|
||||
|
||||
Value::Value() {
|
||||
SetNull();
|
||||
}
|
||||
Value::Value(const Value& rhs) {
|
||||
Set(rhs);
|
||||
}
|
||||
Value::Value(const Node& rhs) {
|
||||
const Value& value = rhs.AsValue();
|
||||
Set(value);
|
||||
}
|
||||
Value::Value(ValueType type, const std::string& value) {
|
||||
Set(type, value);
|
||||
}
|
||||
Value::Value(const std::string& value) {
|
||||
Set(value);
|
||||
}
|
||||
Value::Value(const char* value) {
|
||||
Set(value);
|
||||
}
|
||||
Value::Value(const int value) {
|
||||
Set(value);
|
||||
}
|
||||
Value::Value(const float value) {
|
||||
Set(value);
|
||||
}
|
||||
Value::Value(const double value) {
|
||||
Set(value);
|
||||
}
|
||||
Value::Value(const bool value) {
|
||||
Set(value);
|
||||
}
|
||||
Node::Type Value::GetType() const {
|
||||
return T_VALUE;
|
||||
}
|
||||
Value::ValueType Value::GetValueType() const {
|
||||
return type;
|
||||
}
|
||||
|
||||
std::string Value::ToString() const {
|
||||
if (IsNull()) {
|
||||
return "null";
|
||||
}
|
||||
return valueStr;
|
||||
}
|
||||
int Value::ToInt() const {
|
||||
if (IsNumber()) {
|
||||
std::stringstream sstr(valueStr);
|
||||
int val = 0;
|
||||
sstr >> val;
|
||||
return val;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
float Value::ToFloat() const {
|
||||
if (IsNumber()) {
|
||||
std::stringstream sstr(valueStr);
|
||||
float val = 0;
|
||||
sstr >> val;
|
||||
return val;
|
||||
}
|
||||
return 0.F;
|
||||
}
|
||||
double Value::ToDouble() const {
|
||||
if (IsNumber()) {
|
||||
std::stringstream sstr(valueStr);
|
||||
double val = 0;
|
||||
sstr >> val;
|
||||
return val;
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
bool Value::ToBool() const {
|
||||
if (IsBool()) {
|
||||
return (valueStr == "true");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void Value::SetNull() {
|
||||
valueStr = "";
|
||||
type = VT_NULL;
|
||||
}
|
||||
void Value::Set(const Value& value) {
|
||||
if (this != &value) {
|
||||
valueStr = value.valueStr;
|
||||
type = value.type;
|
||||
}
|
||||
}
|
||||
void Value::Set(ValueType type, const std::string& value) {
|
||||
valueStr = value;
|
||||
this->type = type;
|
||||
}
|
||||
void Value::Set(const std::string& value) {
|
||||
valueStr = UnescapeString(value);
|
||||
type = VT_STRING;
|
||||
}
|
||||
void Value::Set(const char* value) {
|
||||
valueStr = UnescapeString(std::string(value));
|
||||
type = VT_STRING;
|
||||
}
|
||||
void Value::Set(const int value) {
|
||||
std::stringstream sstr;
|
||||
sstr << value;
|
||||
valueStr = sstr.str();
|
||||
type = VT_NUMBER;
|
||||
}
|
||||
void Value::Set(const float value) {
|
||||
std::stringstream sstr;
|
||||
sstr << value;
|
||||
valueStr = sstr.str();
|
||||
type = VT_NUMBER;
|
||||
}
|
||||
void Value::Set(const double value) {
|
||||
std::stringstream sstr;
|
||||
sstr << value;
|
||||
valueStr = sstr.str();
|
||||
type = VT_NUMBER;
|
||||
}
|
||||
void Value::Set(const bool value) {
|
||||
valueStr = value ? "true" : "false";
|
||||
type = VT_BOOL;
|
||||
}
|
||||
|
||||
Value& Value::operator=(const Value& rhs) {
|
||||
if (this != &rhs)
|
||||
Set(rhs);
|
||||
return *this;
|
||||
}
|
||||
Value& Value::operator=(const Node& rhs) {
|
||||
if (this != &rhs)
|
||||
Set(rhs.AsValue());
|
||||
return *this;
|
||||
}
|
||||
Value& Value::operator=(const std::string& rhs) {
|
||||
Set(rhs);
|
||||
return *this;
|
||||
}
|
||||
Value& Value::operator=(const char* rhs) {
|
||||
Set(rhs);
|
||||
return *this;
|
||||
}
|
||||
Value& Value::operator=(const int rhs) {
|
||||
Set(rhs);
|
||||
return *this;
|
||||
}
|
||||
Value& Value::operator=(const float rhs) {
|
||||
Set(rhs);
|
||||
return *this;
|
||||
}
|
||||
Value& Value::operator=(const double rhs) {
|
||||
Set(rhs);
|
||||
return *this;
|
||||
}
|
||||
Value& Value::operator=(const bool rhs) {
|
||||
Set(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool Value::operator==(const Value& other) const {
|
||||
return ((type == other.type) && (valueStr == other.valueStr));
|
||||
}
|
||||
bool Value::operator!=(const Value& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
Node* Value::GetCopy() const {
|
||||
return new Value(*this);
|
||||
}
|
||||
|
||||
// This is not the most beautiful place for these, but it'll do
|
||||
using chrPair = struct {
|
||||
char first;
|
||||
const char* second;
|
||||
};
|
||||
static constexpr std::array<chrPair, 8> chars{
|
||||
chrPair{'\\', "\\\\"}, chrPair{'/', "\\/"}, chrPair{'\"', "\\\""}, chrPair{'\n', "\\n"},
|
||||
chrPair{'\t', "\\t"}, chrPair{'\b', "\\b"}, chrPair{'\f', "\\f"}, chrPair{'\r', "\\r"},
|
||||
};
|
||||
static constexpr char nullUnescaped = '\0';
|
||||
static constexpr const char* nullEscaped = "\0\0";
|
||||
const char* const& getEscaped(const char& c) {
|
||||
for (auto&& chr : chars) {
|
||||
if (chr.first == c) {
|
||||
return chr.second;
|
||||
}
|
||||
}
|
||||
return nullEscaped;
|
||||
}
|
||||
const char& getUnescaped(const char& c1, const char& c2) {
|
||||
for (auto&& chr : chars) {
|
||||
if (c1 == chars[0].first && c2 == chars[1].first) {
|
||||
return chr.first;
|
||||
}
|
||||
}
|
||||
return nullUnescaped;
|
||||
}
|
||||
|
||||
std::string Value::EscapeString(const std::string& value) {
|
||||
std::string escaped;
|
||||
|
||||
for (auto&& c : value) {
|
||||
auto&& a = getEscaped(c);
|
||||
if (a[0] != '\0') {
|
||||
escaped += a[0];
|
||||
escaped += a[1];
|
||||
} else {
|
||||
escaped += c;
|
||||
}
|
||||
}
|
||||
|
||||
return escaped;
|
||||
}
|
||||
std::string Value::UnescapeString(const std::string& value) {
|
||||
std::string unescaped;
|
||||
|
||||
for (auto it = value.cbegin(); it != value.cend(); ++it) {
|
||||
const char& c = (*it);
|
||||
char c2 = '\0';
|
||||
if (it + 1 != value.end())
|
||||
c2 = *(it + 1);
|
||||
|
||||
const char& a = getUnescaped(c, c2);
|
||||
if (a != '\0') {
|
||||
unescaped += a;
|
||||
if (it + 1 != value.end())
|
||||
++it;
|
||||
} else {
|
||||
unescaped += c;
|
||||
}
|
||||
}
|
||||
|
||||
return unescaped;
|
||||
}
|
||||
|
||||
Object::Object(const Object& other) {
|
||||
std::transform(other.children.begin(), other.children.end(), std::back_inserter(children),
|
||||
[](const NamedNodePtr& child) { return NamedNodePtr(child.first, child.second->GetCopy()); });
|
||||
}
|
||||
Object::Object(const Node& other) {
|
||||
std::transform(other.AsObject().children.begin(), other.AsObject().children.end(), std::back_inserter(children),
|
||||
[](const NamedNodePtr& child) { return NamedNodePtr(child.first, child.second->GetCopy()); });
|
||||
}
|
||||
Object::~Object() {
|
||||
Clear();
|
||||
}
|
||||
|
||||
Node::Type Object::GetType() const {
|
||||
return T_OBJECT;
|
||||
}
|
||||
|
||||
void Object::Add(const std::string& name, Node& node) {
|
||||
children.emplace_back(name, node.GetCopy());
|
||||
}
|
||||
void Object::Add(const std::string& name, const Value& node) {
|
||||
children.emplace_back(name, new Value(node));
|
||||
}
|
||||
void Object::Remove(const std::string& name) {
|
||||
for (auto it = children.cbegin(); it != children.cend(); ++it) {
|
||||
if ((*it).first == name) {
|
||||
delete (*it).second;
|
||||
children.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Object::Clear() {
|
||||
for (auto&& child : children) {
|
||||
delete child.second;
|
||||
child.second = nullptr;
|
||||
}
|
||||
children.clear();
|
||||
}
|
||||
|
||||
Object::iterator Object::begin() {
|
||||
if (!children.empty())
|
||||
return {&children.front()};
|
||||
return {nullptr};
|
||||
}
|
||||
|
||||
Object::const_iterator Object::begin() const {
|
||||
if (!children.empty())
|
||||
return {&children.front()};
|
||||
return {nullptr};
|
||||
}
|
||||
|
||||
Object::iterator Object::end() {
|
||||
if (!children.empty())
|
||||
return {&children.back() + 1};
|
||||
return {nullptr};
|
||||
}
|
||||
Object::const_iterator Object::end() const {
|
||||
if (!children.empty())
|
||||
return {&children.back() + 1};
|
||||
return {nullptr};
|
||||
}
|
||||
|
||||
bool Object::Has(const std::string& name) const {
|
||||
return std::any_of(children.begin(), children.end(), [&](const NamedNodePtr& child) { return child.first == name; });
|
||||
}
|
||||
size_t Object::GetCount() const {
|
||||
return children.size();
|
||||
}
|
||||
Node& Object::Get(const std::string& name) const {
|
||||
for (auto&& child : children) {
|
||||
if (child.first == name) {
|
||||
return *child.second;
|
||||
}
|
||||
}
|
||||
|
||||
throw NotFoundException();
|
||||
}
|
||||
|
||||
Node* Object::GetCopy() const {
|
||||
return new Object(*this);
|
||||
}
|
||||
|
||||
Array::Array(const Array& other) {
|
||||
for (auto&& value : other.children) {
|
||||
children.push_back(value->GetCopy());
|
||||
}
|
||||
}
|
||||
|
||||
Array::Array(const Node& other) {
|
||||
const Array& array = other.AsArray();
|
||||
|
||||
for (auto&& value : array.children) {
|
||||
children.push_back(value->GetCopy());
|
||||
}
|
||||
}
|
||||
|
||||
Array::~Array() {
|
||||
Clear();
|
||||
}
|
||||
|
||||
Node::Type Array::GetType() const {
|
||||
return T_ARRAY;
|
||||
}
|
||||
|
||||
void Array::Add(Node& node) {
|
||||
children.push_back(node.GetCopy());
|
||||
}
|
||||
void Array::Add(const Value& node) {
|
||||
children.push_back(new Value(node));
|
||||
}
|
||||
void Array::Remove(size_t index) {
|
||||
if (index < children.size()) {
|
||||
auto it = children.begin() + index;
|
||||
delete (*it);
|
||||
children.erase(it);
|
||||
}
|
||||
}
|
||||
void Array::Clear() {
|
||||
for (auto&& child : children) {
|
||||
delete child;
|
||||
child = nullptr;
|
||||
}
|
||||
children.clear();
|
||||
}
|
||||
|
||||
Array::iterator Array::begin() {
|
||||
if (!children.empty())
|
||||
return {&children.front()};
|
||||
return {nullptr};
|
||||
}
|
||||
Array::const_iterator Array::begin() const {
|
||||
if (!children.empty())
|
||||
return {&children.front()};
|
||||
return {nullptr};
|
||||
}
|
||||
Array::iterator Array::end() {
|
||||
if (!children.empty())
|
||||
return {&children.back() + 1};
|
||||
return {nullptr};
|
||||
}
|
||||
Array::const_iterator Array::end() const {
|
||||
if (!children.empty())
|
||||
return {&children.back() + 1};
|
||||
return {nullptr};
|
||||
}
|
||||
|
||||
size_t Array::GetCount() const {
|
||||
return children.size();
|
||||
}
|
||||
Node& Array::Get(size_t index) const {
|
||||
if (index < children.size()) {
|
||||
return *children.at(index);
|
||||
}
|
||||
|
||||
throw NotFoundException();
|
||||
}
|
||||
|
||||
Node* Array::GetCopy() const {
|
||||
return new Array(*this);
|
||||
}
|
||||
|
||||
FileWriter::FileWriter(std::string filename) : filename(std::move(filename)) {
|
||||
}
|
||||
|
||||
void FileWriter::WriteFile(const std::string& filename, const Node& root, const Format& format) {
|
||||
FileWriter writer(filename);
|
||||
writer.Write(root, format);
|
||||
}
|
||||
|
||||
void FileWriter::Write(const Node& root, const Format& format) {
|
||||
Writer writer(root, format);
|
||||
writer.Write();
|
||||
|
||||
std::fstream file(filename.c_str(), std::ios::out | std::ios::trunc);
|
||||
file << writer.GetResult();
|
||||
file.close();
|
||||
}
|
||||
|
||||
FileReader::FileReader(const std::string& filename) {
|
||||
if (!loadFile(filename, json)) {
|
||||
error = "Failed to load file";
|
||||
}
|
||||
}
|
||||
|
||||
bool FileReader::ReadFile(const std::string& filename, Node& node) {
|
||||
FileReader reader(filename);
|
||||
return reader.Read(node);
|
||||
}
|
||||
|
||||
bool FileReader::Read(Node& node) {
|
||||
if (!error.empty())
|
||||
return false;
|
||||
|
||||
Parser parser(node, json);
|
||||
if (!parser.Parse()) {
|
||||
error = parser.GetError();
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
Node::Type FileReader::DetermineType() {
|
||||
return Node::DetermineType(json);
|
||||
}
|
||||
|
||||
const std::string& FileReader::GetError() const {
|
||||
return error;
|
||||
}
|
||||
|
||||
bool FileReader::loadFile(const std::string& filename, std::string& json) {
|
||||
std::fstream file(filename.c_str(), std::ios::in | std::ios::binary);
|
||||
|
||||
if (!file.is_open()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
file.seekg(0, std::ios::end);
|
||||
std::ios::pos_type size = file.tellg();
|
||||
file.seekg(0, std::ios::beg);
|
||||
|
||||
json.resize(static_cast<std::string::size_type>(size), '\0');
|
||||
file.read(&json[0], size);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Writer::Writer(const Node& root, const Format& format) : fi(new FormatInterpreter), root(root) {
|
||||
SetFormat(format);
|
||||
}
|
||||
Writer::~Writer() {
|
||||
delete fi;
|
||||
fi = nullptr;
|
||||
}
|
||||
|
||||
void Writer::SetFormat(const Format& format) {
|
||||
fi->SetFormat(format);
|
||||
}
|
||||
const std::string& Writer::Write() {
|
||||
result.clear();
|
||||
writeNode(root, 0);
|
||||
return result;
|
||||
}
|
||||
|
||||
const std::string& Writer::GetResult() const {
|
||||
return result;
|
||||
}
|
||||
|
||||
void Writer::writeNode(const Node& node, size_t level) {
|
||||
switch (node.GetType()) {
|
||||
case Node::T_OBJECT:
|
||||
writeObject(node.AsObject(), level);
|
||||
break;
|
||||
case Node::T_ARRAY:
|
||||
writeArray(node.AsArray(), level);
|
||||
break;
|
||||
case Node::T_VALUE:
|
||||
writeValue(node.AsValue());
|
||||
break;
|
||||
}
|
||||
}
|
||||
void Writer::writeObject(const Object& node, size_t level) {
|
||||
result += "{" + fi->GetNewline();
|
||||
|
||||
for (auto it = node.begin(); it != node.end(); ++it) {
|
||||
const std::string& name = (*it).first;
|
||||
// const Node &value = (*it).second;
|
||||
|
||||
if (it != node.begin())
|
||||
result += "," + fi->GetNewline();
|
||||
result += fi->GetIndentation(level + 1) + "\"" + name + "\"" + ":" + fi->GetSpacing();
|
||||
writeNode((*it).second, level + 1);
|
||||
}
|
||||
|
||||
result += fi->GetNewline() + fi->GetIndentation(level) + "}";
|
||||
}
|
||||
void Writer::writeArray(const Array& node, size_t level) {
|
||||
result += "[" + fi->GetNewline();
|
||||
|
||||
for (auto it = node.begin(); it != node.end(); ++it) {
|
||||
const Node& value = (*it);
|
||||
|
||||
if (it != node.begin())
|
||||
result += "," + fi->GetNewline();
|
||||
result += fi->GetIndentation(level + 1);
|
||||
writeNode(value, level + 1);
|
||||
}
|
||||
|
||||
result += fi->GetNewline() + fi->GetIndentation(level) + "]";
|
||||
}
|
||||
void Writer::writeValue(const Value& node) {
|
||||
if (node.IsString()) {
|
||||
result += "\"" + Value::EscapeString(node.ToString()) + "\"";
|
||||
} else {
|
||||
result += node.ToString();
|
||||
}
|
||||
}
|
||||
|
||||
Parser::Parser(Node& root) : root(root) {
|
||||
}
|
||||
Parser::Parser(Node& root, const std::string& json) : root(root) {
|
||||
SetJson(json);
|
||||
}
|
||||
|
||||
void Parser::SetJson(const std::string& json) {
|
||||
this->json = json;
|
||||
jsonSize = json.size();
|
||||
}
|
||||
bool Parser::Parse() {
|
||||
cursor = 0;
|
||||
|
||||
tokenize();
|
||||
bool success = assemble();
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
const std::string& Parser::GetError() const {
|
||||
return error;
|
||||
}
|
||||
|
||||
void Parser::tokenize() {
|
||||
Token token = T_UNKNOWN;
|
||||
std::string valueBuffer;
|
||||
bool saveBuffer;
|
||||
|
||||
for (; cursor < jsonSize; ++cursor) {
|
||||
char c = json.at(cursor);
|
||||
|
||||
if (IsWhitespace(c))
|
||||
continue;
|
||||
|
||||
saveBuffer = true;
|
||||
|
||||
switch (c) {
|
||||
case '{': {
|
||||
token = T_OBJ_BEGIN;
|
||||
break;
|
||||
}
|
||||
case '}': {
|
||||
token = T_OBJ_END;
|
||||
break;
|
||||
}
|
||||
case '[': {
|
||||
token = T_ARRAY_BEGIN;
|
||||
break;
|
||||
}
|
||||
case ']': {
|
||||
token = T_ARRAY_END;
|
||||
break;
|
||||
}
|
||||
case ',': {
|
||||
token = T_SEPARATOR_NODE;
|
||||
break;
|
||||
}
|
||||
case ':': {
|
||||
token = T_SEPARATOR_NAME;
|
||||
break;
|
||||
}
|
||||
case '"': {
|
||||
token = T_VALUE;
|
||||
readString();
|
||||
break;
|
||||
}
|
||||
case '/': {
|
||||
char p = peek();
|
||||
if (p == '*') {
|
||||
jumpToCommentEnd();
|
||||
} else if (p == '/') {
|
||||
jumpToNext('\n');
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
valueBuffer += c;
|
||||
saveBuffer = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ((saveBuffer || cursor == jsonSize - 1) && (!valueBuffer.empty())) // Always save buffer on the last character
|
||||
{
|
||||
if (interpretValue(valueBuffer)) {
|
||||
tokens.push(T_VALUE);
|
||||
} else {
|
||||
// Store the unknown token, so we can show it to the user
|
||||
data.emplace(Value::VT_STRING, valueBuffer);
|
||||
tokens.push(T_UNKNOWN);
|
||||
}
|
||||
|
||||
valueBuffer.clear();
|
||||
}
|
||||
|
||||
// Push the token last so that any
|
||||
// value token will get pushed first
|
||||
// from above.
|
||||
// If saveBuffer is false, it means that
|
||||
// we are in the middle of a value, so we
|
||||
// don't want to push any tokens now.
|
||||
if (saveBuffer) {
|
||||
tokens.push(token);
|
||||
}
|
||||
}
|
||||
}
|
||||
bool Parser::assemble() {
|
||||
std::stack<std::pair<std::string, Node*>> nodeStack;
|
||||
|
||||
std::string name;
|
||||
|
||||
Token token;
|
||||
while (!tokens.empty()) {
|
||||
token = tokens.front();
|
||||
tokens.pop();
|
||||
|
||||
switch (token) {
|
||||
case T_UNKNOWN: {
|
||||
const std::string& unknownToken = data.front().second;
|
||||
error = "Unknown token: " + unknownToken;
|
||||
data.pop();
|
||||
return false;
|
||||
}
|
||||
case T_OBJ_BEGIN: {
|
||||
Node* node = nullptr;
|
||||
if (nodeStack.empty()) {
|
||||
if (!root.IsObject()) {
|
||||
error = "The given root node is not an object";
|
||||
return false;
|
||||
}
|
||||
|
||||
node = &root;
|
||||
} else {
|
||||
node = new Object;
|
||||
}
|
||||
|
||||
nodeStack.emplace(name, node);
|
||||
name.clear();
|
||||
break;
|
||||
}
|
||||
case T_ARRAY_BEGIN: {
|
||||
Node* node = nullptr;
|
||||
if (nodeStack.empty()) {
|
||||
if (!root.IsArray()) {
|
||||
error = "The given root node is not an array";
|
||||
return false;
|
||||
}
|
||||
|
||||
node = &root;
|
||||
} else {
|
||||
node = new Array;
|
||||
}
|
||||
|
||||
nodeStack.emplace(name, node);
|
||||
name.clear();
|
||||
break;
|
||||
}
|
||||
case T_OBJ_END:
|
||||
case T_ARRAY_END: {
|
||||
if (nodeStack.empty()) {
|
||||
error = "Found end of object or array without beginning";
|
||||
return false;
|
||||
}
|
||||
if (token == T_OBJ_END && !nodeStack.top().second->IsObject()) {
|
||||
error = "Mismatched end and beginning of object";
|
||||
return false;
|
||||
}
|
||||
if (token == T_ARRAY_END && !nodeStack.top().second->IsArray()) {
|
||||
error = "Mismatched end and beginning of array";
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string name = nodeStack.top().first;
|
||||
Node* node = nodeStack.top().second;
|
||||
nodeStack.pop();
|
||||
|
||||
if (!nodeStack.empty()) {
|
||||
if (nodeStack.top().second->IsObject()) {
|
||||
nodeStack.top().second->AsObject().Add(name, *node);
|
||||
} else if (nodeStack.top().second->IsArray()) {
|
||||
nodeStack.top().second->AsArray().Add(*node);
|
||||
} else {
|
||||
error = "Can only add elements to objects and arrays";
|
||||
return false;
|
||||
}
|
||||
|
||||
delete node;
|
||||
node = nullptr;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case T_VALUE: {
|
||||
if (!tokens.empty() && tokens.front() == T_SEPARATOR_NAME) {
|
||||
tokens.pop();
|
||||
if (data.front().first != Value::VT_STRING) {
|
||||
error = "A name has to be a string";
|
||||
return false;
|
||||
}
|
||||
name = data.front().second;
|
||||
data.pop();
|
||||
} else {
|
||||
Node* node = nullptr;
|
||||
if (nodeStack.empty()) {
|
||||
if (!root.IsValue()) {
|
||||
error = "The given root node is not a value";
|
||||
return false;
|
||||
}
|
||||
|
||||
node = &root;
|
||||
} else {
|
||||
node = new Value;
|
||||
}
|
||||
|
||||
if (data.front().first == Value::VT_STRING) {
|
||||
dynamic_cast<Value*>(node)->Set(data.front().second); // This method calls UnescapeString()
|
||||
} else {
|
||||
dynamic_cast<Value*>(node)->Set(data.front().first, data.front().second);
|
||||
}
|
||||
data.pop();
|
||||
|
||||
if (!nodeStack.empty()) {
|
||||
if (nodeStack.top().second->IsObject())
|
||||
nodeStack.top().second->AsObject().Add(name, *node);
|
||||
else if (nodeStack.top().second->IsArray())
|
||||
nodeStack.top().second->AsArray().Add(*node);
|
||||
|
||||
delete node;
|
||||
node = nullptr;
|
||||
name.clear();
|
||||
} else {
|
||||
nodeStack.emplace(name, node);
|
||||
name.clear();
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case T_SEPARATOR_NAME:
|
||||
case T_SEPARATOR_NODE:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
char Parser::peek() {
|
||||
if (cursor < jsonSize - 1) {
|
||||
return json.at(cursor + 1);
|
||||
}
|
||||
return '\0';
|
||||
}
|
||||
void Parser::jumpToNext(char c) {
|
||||
++cursor;
|
||||
while (cursor < jsonSize && json.at(cursor) != c)
|
||||
++cursor;
|
||||
}
|
||||
void Parser::jumpToCommentEnd() {
|
||||
++cursor;
|
||||
char c1 = '\0';
|
||||
for (; cursor < jsonSize; ++cursor) {
|
||||
char c2 = json.at(cursor);
|
||||
|
||||
if (c1 == '*' && c2 == '/')
|
||||
break;
|
||||
|
||||
c1 = c2;
|
||||
}
|
||||
}
|
||||
|
||||
void Parser::readString() {
|
||||
if (json.at(cursor) != '"')
|
||||
return;
|
||||
|
||||
std::string str;
|
||||
|
||||
++cursor;
|
||||
|
||||
char c1 = '\0';
|
||||
for (; cursor < jsonSize; ++cursor) {
|
||||
char c2 = json.at(cursor);
|
||||
|
||||
if (c1 != '\\' && c2 == '"') {
|
||||
break;
|
||||
}
|
||||
|
||||
str += c2;
|
||||
|
||||
c1 = c2;
|
||||
}
|
||||
|
||||
data.emplace(Value::VT_STRING, str);
|
||||
}
|
||||
bool Parser::interpretValue(const std::string& value) {
|
||||
std::string upperValue;
|
||||
upperValue.reserve(value.size());
|
||||
std::transform(value.begin(), value.end(), upperValue.begin(), toupper);
|
||||
|
||||
if (upperValue == "NULL") {
|
||||
data.emplace(Value::VT_NULL, "");
|
||||
} else if (upperValue == "TRUE") {
|
||||
data.emplace(Value::VT_BOOL, "true");
|
||||
} else if (upperValue == "FALSE") {
|
||||
data.emplace(Value::VT_BOOL, "false");
|
||||
} else {
|
||||
bool number = std::all_of(value.begin(), value.end(), IsNumber);
|
||||
if (!number) {
|
||||
return false;
|
||||
}
|
||||
data.emplace(Value::VT_NUMBER, value);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
} // namespace Jzon
|
||||
@ -1,517 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2013 Johannes Häggqvist
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
#ifndef Jzon_h__
|
||||
#define Jzon_h__
|
||||
|
||||
#ifndef JzonAPI
|
||||
#ifdef _WINDLL
|
||||
#define JzonAPI __declspec(dllimport)
|
||||
#elif defined(__GNUC__) && (__GNUC__ >= 4)
|
||||
#define JzonAPI __attribute__((visibility("default")))
|
||||
#else
|
||||
#define JzonAPI
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <iterator>
|
||||
#include <queue>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace Jzon {
|
||||
class Node;
|
||||
class Value;
|
||||
class Object;
|
||||
class Array;
|
||||
using NamedNode = std::pair<std::string, Node&>;
|
||||
using NamedNodePtr = std::pair<std::string, Node*>;
|
||||
|
||||
class TypeException : public std::logic_error {
|
||||
public:
|
||||
TypeException() : std::logic_error("A Node was used as the wrong type") {
|
||||
}
|
||||
};
|
||||
class NotFoundException : public std::out_of_range {
|
||||
public:
|
||||
NotFoundException() : std::out_of_range("The node could not be found") {
|
||||
}
|
||||
};
|
||||
|
||||
struct Format {
|
||||
bool newline;
|
||||
bool spacing;
|
||||
bool useTabs;
|
||||
unsigned int indentSize;
|
||||
};
|
||||
static const Format StandardFormat = {true, true, true, 1};
|
||||
static const Format NoFormat = {false, false, false, 0};
|
||||
|
||||
class JzonAPI Node {
|
||||
friend class Object;
|
||||
friend class Array;
|
||||
|
||||
public:
|
||||
enum Type { T_OBJECT, T_ARRAY, T_VALUE };
|
||||
|
||||
Node() noexcept = default;
|
||||
virtual ~Node() noexcept = default;
|
||||
|
||||
virtual Type GetType() const = 0;
|
||||
|
||||
inline bool IsObject() const {
|
||||
return (GetType() == T_OBJECT);
|
||||
}
|
||||
inline bool IsArray() const {
|
||||
return (GetType() == T_ARRAY);
|
||||
}
|
||||
inline bool IsValue() const {
|
||||
return (GetType() == T_VALUE);
|
||||
}
|
||||
|
||||
Object& AsObject();
|
||||
const Object& AsObject() const;
|
||||
Array& AsArray();
|
||||
const Array& AsArray() const;
|
||||
Value& AsValue();
|
||||
const Value& AsValue() const;
|
||||
|
||||
virtual inline bool IsNull() const {
|
||||
return false;
|
||||
}
|
||||
virtual inline bool IsString() const {
|
||||
return false;
|
||||
}
|
||||
virtual inline bool IsNumber() const {
|
||||
return false;
|
||||
}
|
||||
virtual inline bool IsBool() const {
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual std::string ToString() const {
|
||||
throw TypeException();
|
||||
}
|
||||
virtual int ToInt() const {
|
||||
throw TypeException();
|
||||
}
|
||||
virtual float ToFloat() const {
|
||||
throw TypeException();
|
||||
}
|
||||
virtual double ToDouble() const {
|
||||
throw TypeException();
|
||||
}
|
||||
virtual bool ToBool() const {
|
||||
throw TypeException();
|
||||
}
|
||||
|
||||
virtual bool Has(const std::string& /*name*/) const {
|
||||
throw TypeException();
|
||||
}
|
||||
virtual size_t GetCount() const {
|
||||
return 0;
|
||||
}
|
||||
virtual Node& Get(const std::string& /*name*/) const {
|
||||
throw TypeException();
|
||||
}
|
||||
virtual Node& Get(size_t /*index*/) const {
|
||||
throw TypeException();
|
||||
}
|
||||
|
||||
static Type DetermineType(const std::string& json);
|
||||
|
||||
protected:
|
||||
virtual Node* GetCopy() const = 0;
|
||||
};
|
||||
|
||||
class JzonAPI Value : public Node {
|
||||
public:
|
||||
enum ValueType { VT_NULL, VT_STRING, VT_NUMBER, VT_BOOL };
|
||||
|
||||
Value();
|
||||
Value(const Value& rhs);
|
||||
Value(const Node& rhs);
|
||||
Value(ValueType type, const std::string& value);
|
||||
Value(const std::string& value);
|
||||
Value(const char* value);
|
||||
Value(const int value);
|
||||
Value(const float value);
|
||||
Value(const double value);
|
||||
Value(const bool value);
|
||||
~Value() override = default;
|
||||
|
||||
Type GetType() const override;
|
||||
ValueType GetValueType() const;
|
||||
|
||||
inline bool IsNull() const override {
|
||||
return (type == VT_NULL);
|
||||
}
|
||||
inline bool IsString() const override {
|
||||
return (type == VT_STRING);
|
||||
}
|
||||
inline bool IsNumber() const override {
|
||||
return (type == VT_NUMBER);
|
||||
}
|
||||
inline bool IsBool() const override {
|
||||
return (type == VT_BOOL);
|
||||
}
|
||||
|
||||
std::string ToString() const override;
|
||||
int ToInt() const override;
|
||||
float ToFloat() const override;
|
||||
double ToDouble() const override;
|
||||
bool ToBool() const override;
|
||||
|
||||
void SetNull();
|
||||
void Set(const Value& value);
|
||||
void Set(ValueType type, const std::string& value);
|
||||
void Set(const std::string& value);
|
||||
void Set(const char* value);
|
||||
void Set(const int value);
|
||||
void Set(const float value);
|
||||
void Set(const double value);
|
||||
void Set(const bool value);
|
||||
|
||||
Value& operator=(const Value& rhs);
|
||||
Value& operator=(const Node& rhs);
|
||||
Value& operator=(const std::string& rhs);
|
||||
Value& operator=(const char* rhs);
|
||||
Value& operator=(const int rhs);
|
||||
Value& operator=(const float rhs);
|
||||
Value& operator=(const double rhs);
|
||||
Value& operator=(const bool rhs);
|
||||
|
||||
bool operator==(const Value& other) const;
|
||||
bool operator!=(const Value& other) const;
|
||||
|
||||
static std::string EscapeString(const std::string& value);
|
||||
static std::string UnescapeString(const std::string& value);
|
||||
|
||||
protected:
|
||||
Node* GetCopy() const override;
|
||||
|
||||
private:
|
||||
std::string valueStr;
|
||||
ValueType type;
|
||||
};
|
||||
|
||||
static const Value null;
|
||||
|
||||
class JzonAPI Object : public Node {
|
||||
public:
|
||||
class iterator : public std::iterator<std::input_iterator_tag, NamedNode> {
|
||||
public:
|
||||
iterator(NamedNodePtr* o) : p(o) {
|
||||
}
|
||||
iterator(const iterator& it) : p(it.p) {
|
||||
}
|
||||
|
||||
iterator& operator++() {
|
||||
++p;
|
||||
return *this;
|
||||
}
|
||||
iterator operator++(int) {
|
||||
iterator tmp(*this);
|
||||
operator++();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
bool operator==(const iterator& rhs) {
|
||||
return p == rhs.p;
|
||||
}
|
||||
bool operator!=(const iterator& rhs) {
|
||||
return p != rhs.p;
|
||||
}
|
||||
|
||||
NamedNode operator*() {
|
||||
return NamedNode(p->first, *p->second);
|
||||
}
|
||||
|
||||
private:
|
||||
NamedNodePtr* p;
|
||||
};
|
||||
class const_iterator : public std::iterator<std::input_iterator_tag, const NamedNode> {
|
||||
public:
|
||||
const_iterator(const NamedNodePtr* o) : p(o) {
|
||||
}
|
||||
const_iterator(const const_iterator& it) : p(it.p) {
|
||||
}
|
||||
|
||||
const_iterator& operator++() {
|
||||
++p;
|
||||
return *this;
|
||||
}
|
||||
const_iterator operator++(int) {
|
||||
const_iterator tmp(*this);
|
||||
operator++();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
bool operator==(const const_iterator& rhs) {
|
||||
return p == rhs.p;
|
||||
}
|
||||
bool operator!=(const const_iterator& rhs) {
|
||||
return p != rhs.p;
|
||||
}
|
||||
|
||||
const NamedNode operator*() {
|
||||
return NamedNode(p->first, *p->second);
|
||||
}
|
||||
|
||||
private:
|
||||
const NamedNodePtr* p;
|
||||
};
|
||||
|
||||
Object() = default;
|
||||
Object(const Object& other);
|
||||
Object(const Node& other);
|
||||
~Object() override;
|
||||
|
||||
Type GetType() const override;
|
||||
|
||||
void Add(const std::string& name, Node& node);
|
||||
void Add(const std::string& name, const Value& node);
|
||||
void Remove(const std::string& name);
|
||||
void Clear();
|
||||
|
||||
iterator begin();
|
||||
const_iterator begin() const;
|
||||
iterator end();
|
||||
const_iterator end() const;
|
||||
|
||||
bool Has(const std::string& name) const override;
|
||||
size_t GetCount() const override;
|
||||
Node& Get(const std::string& name) const override;
|
||||
using Node::Get;
|
||||
|
||||
protected:
|
||||
Node* GetCopy() const override;
|
||||
|
||||
private:
|
||||
using ChildList = std::vector<NamedNodePtr>;
|
||||
ChildList children;
|
||||
};
|
||||
|
||||
class JzonAPI Array : public Node {
|
||||
public:
|
||||
class iterator : public std::iterator<std::input_iterator_tag, Node> {
|
||||
public:
|
||||
iterator(Node** o) : p(o) {
|
||||
}
|
||||
iterator(const iterator& it) : p(it.p) {
|
||||
}
|
||||
|
||||
iterator& operator++() {
|
||||
++p;
|
||||
return *this;
|
||||
}
|
||||
iterator operator++(int) {
|
||||
iterator tmp(*this);
|
||||
operator++();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
bool operator==(const iterator& rhs) {
|
||||
return p == rhs.p;
|
||||
}
|
||||
bool operator!=(const iterator& rhs) {
|
||||
return p != rhs.p;
|
||||
}
|
||||
|
||||
Node& operator*() {
|
||||
return **p;
|
||||
}
|
||||
|
||||
private:
|
||||
Node** p;
|
||||
};
|
||||
class const_iterator : public std::iterator<std::input_iterator_tag, const Node> {
|
||||
public:
|
||||
const_iterator(const Node* const* o) : p(o) {
|
||||
}
|
||||
const_iterator(const const_iterator& it) : p(it.p) {
|
||||
}
|
||||
|
||||
const_iterator& operator++() {
|
||||
++p;
|
||||
return *this;
|
||||
}
|
||||
const_iterator operator++(int) {
|
||||
const_iterator tmp(*this);
|
||||
operator++();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
bool operator==(const const_iterator& rhs) {
|
||||
return p == rhs.p;
|
||||
}
|
||||
bool operator!=(const const_iterator& rhs) {
|
||||
return p != rhs.p;
|
||||
}
|
||||
|
||||
const Node& operator*() {
|
||||
return **p;
|
||||
}
|
||||
|
||||
private:
|
||||
const Node* const* p;
|
||||
};
|
||||
|
||||
Array() = default;
|
||||
Array(const Array& other);
|
||||
Array(const Node& other);
|
||||
~Array() override;
|
||||
|
||||
Type GetType() const override;
|
||||
|
||||
void Add(Node& node);
|
||||
void Add(const Value& node);
|
||||
void Remove(size_t index);
|
||||
void Clear();
|
||||
|
||||
iterator begin();
|
||||
const_iterator begin() const;
|
||||
iterator end();
|
||||
const_iterator end() const;
|
||||
|
||||
size_t GetCount() const override;
|
||||
Node& Get(size_t index) const override;
|
||||
using Node::Get;
|
||||
|
||||
protected:
|
||||
Node* GetCopy() const override;
|
||||
|
||||
private:
|
||||
using ChildList = std::vector<Node*>;
|
||||
ChildList children;
|
||||
};
|
||||
|
||||
class JzonAPI FileWriter {
|
||||
public:
|
||||
FileWriter(std::string filename);
|
||||
~FileWriter() = default;
|
||||
|
||||
static void WriteFile(const std::string& filename, const Node& root, const Format& format = NoFormat);
|
||||
|
||||
void Write(const Node& root, const Format& format = NoFormat);
|
||||
|
||||
private:
|
||||
std::string filename;
|
||||
};
|
||||
|
||||
class JzonAPI FileReader {
|
||||
public:
|
||||
FileReader(const std::string& filename);
|
||||
~FileReader() = default;
|
||||
|
||||
static bool ReadFile(const std::string& filename, Node& node);
|
||||
|
||||
bool Read(Node& node);
|
||||
|
||||
Node::Type DetermineType();
|
||||
|
||||
const std::string& GetError() const;
|
||||
|
||||
private:
|
||||
static bool loadFile(const std::string& filename, std::string& json);
|
||||
std::string json;
|
||||
std::string error;
|
||||
};
|
||||
|
||||
class JzonAPI Writer {
|
||||
public:
|
||||
Writer(const Node& root, const Format& format = NoFormat);
|
||||
~Writer();
|
||||
|
||||
void SetFormat(const Format& format);
|
||||
const std::string& Write();
|
||||
|
||||
// Return result from last call to Write()
|
||||
const std::string& GetResult() const;
|
||||
|
||||
// Disable assignment operator
|
||||
Writer& operator=(const Writer&) = delete;
|
||||
|
||||
private:
|
||||
void writeNode(const Node& node, size_t level);
|
||||
void writeObject(const Object& node, size_t level);
|
||||
void writeArray(const Array& node, size_t level);
|
||||
void writeValue(const Value& node);
|
||||
|
||||
std::string result;
|
||||
|
||||
class FormatInterpreter* fi;
|
||||
|
||||
const Node& root;
|
||||
};
|
||||
|
||||
class JzonAPI Parser {
|
||||
public:
|
||||
Parser(Node& root);
|
||||
Parser(Node& root, const std::string& json);
|
||||
~Parser() = default;
|
||||
|
||||
void SetJson(const std::string& json);
|
||||
bool Parse();
|
||||
|
||||
const std::string& GetError() const;
|
||||
|
||||
// Disable assignment operator
|
||||
Parser& operator=(const Parser&) = delete;
|
||||
|
||||
private:
|
||||
enum Token {
|
||||
T_UNKNOWN,
|
||||
T_OBJ_BEGIN,
|
||||
T_OBJ_END,
|
||||
T_ARRAY_BEGIN,
|
||||
T_ARRAY_END,
|
||||
T_SEPARATOR_NODE,
|
||||
T_SEPARATOR_NAME,
|
||||
T_VALUE
|
||||
};
|
||||
|
||||
void tokenize();
|
||||
bool assemble();
|
||||
|
||||
char peek();
|
||||
void jumpToNext(char c);
|
||||
void jumpToCommentEnd();
|
||||
|
||||
void readString();
|
||||
bool interpretValue(const std::string& value);
|
||||
|
||||
std::string json;
|
||||
std::size_t jsonSize{0};
|
||||
|
||||
std::queue<Token> tokens;
|
||||
std::queue<std::pair<Value::ValueType, std::string>> data;
|
||||
|
||||
std::size_t cursor{0};
|
||||
|
||||
Node& root;
|
||||
|
||||
std::string error;
|
||||
};
|
||||
} // namespace Jzon
|
||||
|
||||
#endif // Jzon_h__
|
||||
@ -1,330 +0,0 @@
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
// Sample program to print metadata in JSON format
|
||||
|
||||
#include <exiv2/exiv2.hpp>
|
||||
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include <cstdlib>
|
||||
#include <filesystem>
|
||||
#include <iostream>
|
||||
|
||||
#include "Jzon.h"
|
||||
|
||||
#if defined(__MINGW32__) || defined(__MINGW64__)
|
||||
#ifndef __MINGW__
|
||||
#define __MINGW__
|
||||
#endif
|
||||
#endif
|
||||
|
||||
struct Token {
|
||||
std::string n; // the name eg "History"
|
||||
bool a; // name is an array eg History[]
|
||||
int i; // index (indexed from 1) eg History[1]/stEvt:action
|
||||
};
|
||||
using Tokens = std::vector<Token>;
|
||||
|
||||
// "XMP.xmp.MP.RegionInfo/MPRI:Regions[1]/MPReg:Rectangle"
|
||||
bool getToken(std::string& in, Token& token, std::set<std::string>* pNS = nullptr) {
|
||||
bool result = false;
|
||||
bool ns = false;
|
||||
|
||||
token.n = "";
|
||||
token.a = false;
|
||||
token.i = 0;
|
||||
|
||||
while (!result && in.length()) {
|
||||
std::string c = in.substr(0, 1);
|
||||
char C = c.at(0);
|
||||
in = in.substr(1, std::string::npos);
|
||||
if (in.length() == 0 && C != ']')
|
||||
token.n += c;
|
||||
if (C == '/' || C == '[' || C == ':' || C == '.' || C == ']' || in.length() == 0) {
|
||||
ns |= C == '/';
|
||||
token.a = C == '[';
|
||||
if (C == ']')
|
||||
token.i = std::atoi(token.n.c_str()); // encoded string first index == 1
|
||||
result = token.n.length() > 0;
|
||||
} else {
|
||||
token.n += c;
|
||||
}
|
||||
}
|
||||
if (ns && pNS)
|
||||
pNS->insert(token.n);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
Jzon::Node& addToTree(Jzon::Node& r1, const Token& token) {
|
||||
Jzon::Object object;
|
||||
Jzon::Array array;
|
||||
|
||||
std::string key = token.n;
|
||||
size_t index = token.i - 1; // array Eg: "History[1]" indexed from 1. Jzon expects 0 based index.
|
||||
auto& empty = token.a ? static_cast<Jzon::Node&>(array) : static_cast<Jzon::Node&>(object);
|
||||
|
||||
if (r1.IsObject()) {
|
||||
Jzon::Object& o1 = r1.AsObject();
|
||||
if (!o1.Has(key))
|
||||
o1.Add(key, empty);
|
||||
return o1.Get(key);
|
||||
}
|
||||
if (r1.IsArray()) {
|
||||
Jzon::Array& a1 = r1.AsArray();
|
||||
while (a1.GetCount() <= index)
|
||||
a1.Add(empty);
|
||||
return a1.Get(index);
|
||||
}
|
||||
return r1;
|
||||
}
|
||||
|
||||
Jzon::Node& recursivelyBuildTree(Jzon::Node& root, Tokens& tokens, size_t k) {
|
||||
return addToTree(k == 0 ? root : recursivelyBuildTree(root, tokens, k - 1), tokens.at(k));
|
||||
}
|
||||
|
||||
// build the json tree for this key. return location and discover the name
|
||||
Jzon::Node& objectForKey(const std::string& Key, Jzon::Object& root, std::string& name,
|
||||
std::set<std::string>* pNS = nullptr) {
|
||||
// Parse the key
|
||||
Tokens tokens;
|
||||
Token token;
|
||||
std::string input = Key; // Example: "XMP.xmp.MP.RegionInfo/MPRI:Regions[1]/MPReg:Rectangle"
|
||||
while (getToken(input, token, pNS))
|
||||
tokens.push_back(token);
|
||||
size_t l = tokens.size() - 1; // leave leaf name to push()
|
||||
name = tokens.at(l).n;
|
||||
|
||||
// The second token. For example: XMP.dc is a namespace
|
||||
if (pNS && tokens.size() > 1)
|
||||
pNS->insert(tokens[1].n);
|
||||
return recursivelyBuildTree(root, tokens, l - 1);
|
||||
|
||||
#if 0
|
||||
// recursivelyBuildTree:
|
||||
// Go to the root. Climb out adding objects or arrays to create the tree
|
||||
// The leaf is pushed on the top by the caller of objectForKey()
|
||||
// The recursion could be expressed by these if statements:
|
||||
if ( l == 1 ) return addToTree(root,tokens[0]);
|
||||
if ( l == 2 ) return addToTree(addToTree(root,tokens[0]),tokens[1]);
|
||||
if ( l == 3 ) return addToTree(addToTree(addToTree(root,tokens[0]),tokens[1]),tokens[2]);
|
||||
if ( l == 4 ) return addToTree(addToTree(addToTree(addToTree(root,tokens[0]),tokens[1]),tokens[2]),tokens[3]);
|
||||
...
|
||||
#endif
|
||||
}
|
||||
|
||||
bool isObject(std::string& value) {
|
||||
return value == std::string("type=\"Struct\"");
|
||||
}
|
||||
|
||||
bool isArray(std::string& value) {
|
||||
return value == "type=\"Seq\"" || value == "type=\"Bag\"" || value == "type=\"Alt\"";
|
||||
}
|
||||
|
||||
#define STORE(node, key, value) \
|
||||
if (node.IsObject()) \
|
||||
node.AsObject().Add(key, value); \
|
||||
else \
|
||||
node.AsArray().Add(value)
|
||||
|
||||
template <class T>
|
||||
void push(Jzon::Node& node, const std::string& key, T i) {
|
||||
#define ABORT_IF_I_EMPTY \
|
||||
if (i->value().size() == 0) { \
|
||||
return; \
|
||||
}
|
||||
|
||||
std::string value = i->value().toString();
|
||||
|
||||
switch (i->typeId()) {
|
||||
case Exiv2::xmpText:
|
||||
if (::isObject(value)) {
|
||||
Jzon::Object v;
|
||||
STORE(node, key, v);
|
||||
} else if (::isArray(value)) {
|
||||
Jzon::Array v;
|
||||
STORE(node, key, v);
|
||||
} else {
|
||||
STORE(node, key, value);
|
||||
}
|
||||
break;
|
||||
|
||||
case Exiv2::unsignedByte:
|
||||
case Exiv2::unsignedShort:
|
||||
case Exiv2::unsignedLong:
|
||||
case Exiv2::signedByte:
|
||||
case Exiv2::signedShort:
|
||||
case Exiv2::signedLong:
|
||||
STORE(node, key, std::atoi(value.c_str()));
|
||||
break;
|
||||
|
||||
case Exiv2::tiffFloat:
|
||||
case Exiv2::tiffDouble:
|
||||
STORE(node, key, std::atof(value.c_str()));
|
||||
break;
|
||||
|
||||
case Exiv2::unsignedRational:
|
||||
case Exiv2::signedRational: {
|
||||
ABORT_IF_I_EMPTY
|
||||
Jzon::Array arr;
|
||||
Exiv2::Rational rat = i->value().toRational();
|
||||
arr.Add(rat.first);
|
||||
arr.Add(rat.second);
|
||||
STORE(node, key, arr);
|
||||
} break;
|
||||
|
||||
case Exiv2::langAlt: {
|
||||
ABORT_IF_I_EMPTY
|
||||
Jzon::Object l;
|
||||
const auto& langs = dynamic_cast<const Exiv2::LangAltValue&>(i->value());
|
||||
for (auto&& lang : langs.value_) {
|
||||
l.Add(lang.first, lang.second);
|
||||
}
|
||||
Jzon::Object o;
|
||||
o.Add("lang", l);
|
||||
STORE(node, key, o);
|
||||
} break;
|
||||
|
||||
default:
|
||||
case Exiv2::date:
|
||||
case Exiv2::time:
|
||||
case Exiv2::asciiString:
|
||||
case Exiv2::string:
|
||||
case Exiv2::comment:
|
||||
case Exiv2::undefined:
|
||||
case Exiv2::tiffIfd:
|
||||
case Exiv2::directory:
|
||||
case Exiv2::xmpAlt:
|
||||
case Exiv2::xmpBag:
|
||||
case Exiv2::xmpSeq:
|
||||
// http://dev.exiv2.org/boards/3/topics/1367#message-1373
|
||||
if (key == "UserComment") {
|
||||
size_t pos = value.find('\0');
|
||||
if (pos != std::string::npos)
|
||||
value = value.substr(0, pos);
|
||||
}
|
||||
if (key == "MakerNote")
|
||||
return;
|
||||
STORE(node, key, value);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void fileSystemPush(const char* path, Jzon::Node& nfs) {
|
||||
auto& fs = dynamic_cast<Jzon::Object&>(nfs);
|
||||
fs.Add("path", path);
|
||||
fs.Add("realpath", std::filesystem::absolute(std::filesystem::path(path)).string());
|
||||
|
||||
struct stat buf = {};
|
||||
stat(path, &buf);
|
||||
|
||||
fs.Add("st_dev", static_cast<int>(buf.st_dev)); /* ID of device containing file */
|
||||
fs.Add("st_ino", static_cast<int>(buf.st_ino)); /* inode number */
|
||||
fs.Add("st_mode", static_cast<int>(buf.st_mode)); /* protection */
|
||||
fs.Add("st_nlink", static_cast<int>(buf.st_nlink)); /* number of hard links */
|
||||
fs.Add("st_uid", static_cast<int>(buf.st_uid)); /* user ID of owner */
|
||||
fs.Add("st_gid", static_cast<int>(buf.st_gid)); /* group ID of owner */
|
||||
fs.Add("st_rdev", static_cast<int>(buf.st_rdev)); /* device ID (if special file) */
|
||||
fs.Add("st_size", static_cast<int>(buf.st_size)); /* total size, in bytes */
|
||||
fs.Add("st_atime", static_cast<int>(buf.st_atime)); /* time of last access */
|
||||
fs.Add("st_mtime", static_cast<int>(buf.st_mtime)); /* time of last modification */
|
||||
fs.Add("st_ctime", static_cast<int>(buf.st_ctime)); /* time of last status change */
|
||||
|
||||
#if defined(_MSC_VER) || defined(__MINGW__)
|
||||
size_t blksize = 1024;
|
||||
size_t blocks = (buf.st_size + blksize - 1) / blksize;
|
||||
#else
|
||||
size_t blksize = buf.st_blksize;
|
||||
size_t blocks = buf.st_blocks;
|
||||
#endif
|
||||
fs.Add("st_blksize", static_cast<int>(blksize)); /* blocksize for file system I/O */
|
||||
fs.Add("st_blocks", static_cast<int>(blocks)); /* number of 512B blocks allocated */
|
||||
}
|
||||
|
||||
int main(int argc, char* const argv[]) {
|
||||
Exiv2::XmpParser::initialize();
|
||||
::atexit(Exiv2::XmpParser::terminate);
|
||||
#ifdef EXV_ENABLE_BMFF
|
||||
Exiv2::enableBMFF();
|
||||
#endif
|
||||
|
||||
try {
|
||||
if (argc < 2 || argc > 3) {
|
||||
std::cout << "Usage: " << argv[0] << " [-option] file" << std::endl;
|
||||
std::cout << "Option: all | exif | iptc | xmp | filesystem" << std::endl;
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
const char* path = argv[argc - 1];
|
||||
const char* opt = argc == 3 ? argv[1] : "-all";
|
||||
while (opt[0] == '-')
|
||||
opt++; // skip past leading -'s
|
||||
char option = opt[0];
|
||||
|
||||
Exiv2::Image::UniquePtr image = Exiv2::ImageFactory::open(path);
|
||||
image->readMetadata();
|
||||
|
||||
Jzon::Object root;
|
||||
|
||||
if (option == 'f') { // only report filesystem when requested
|
||||
const char* Fs = "FS";
|
||||
Jzon::Object fs;
|
||||
root.Add(Fs, fs);
|
||||
fileSystemPush(path, root.Get(Fs));
|
||||
}
|
||||
|
||||
if (option == 'a' || option == 'e') {
|
||||
Exiv2::ExifData& exifData = image->exifData();
|
||||
for (auto i = exifData.begin(); i != exifData.end(); ++i) {
|
||||
std::string name;
|
||||
Jzon::Node& object = objectForKey(i->key(), root, name);
|
||||
push(object, name, i);
|
||||
}
|
||||
}
|
||||
|
||||
if (option == 'a' || option == 'i') {
|
||||
Exiv2::IptcData& iptcData = image->iptcData();
|
||||
for (auto i = iptcData.begin(); i != iptcData.end(); ++i) {
|
||||
std::string name;
|
||||
Jzon::Node& object = objectForKey(i->key(), root, name);
|
||||
push(object, name, i);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef EXV_HAVE_XMP_TOOLKIT
|
||||
if (option == 'a' || option == 'x') {
|
||||
Exiv2::XmpData& xmpData = image->xmpData();
|
||||
if (!xmpData.empty()) {
|
||||
// get the xmpData and recursively parse into a Jzon Object
|
||||
std::set<std::string> namespaces;
|
||||
for (auto i = xmpData.begin(); i != xmpData.end(); ++i) {
|
||||
std::string name;
|
||||
Jzon::Node& object = objectForKey(i->key(), root, name, &namespaces);
|
||||
push(object, name, i);
|
||||
}
|
||||
|
||||
// get the namespace dictionary from XMP
|
||||
Exiv2::Dictionary nsDict;
|
||||
Exiv2::XmpProperties::registeredNamespaces(nsDict);
|
||||
|
||||
// create and populate a Jzon::Object for the namespaces
|
||||
Jzon::Object xmlns;
|
||||
for (auto&& ns : namespaces) {
|
||||
xmlns.Add(ns, nsDict[ns]);
|
||||
}
|
||||
|
||||
// add xmlns as Xmp.xmlns
|
||||
root.Get("Xmp").AsObject().Add("xmlns", xmlns);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
Jzon::Writer writer(root, Jzon::StandardFormat);
|
||||
writer.Write();
|
||||
std::cout << writer.GetResult() << std::endl;
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
catch (Exiv2::Error& e) {
|
||||
std::cout << "Caught Exiv2 exception '" << e.what() << "'\n";
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
import system_tests
|
||||
|
||||
|
||||
class XMPMetaDeleteNamespace(
|
||||
metaclass=system_tests.CaseMeta):
|
||||
"""
|
||||
Regression test for the bug described in:
|
||||
https://github.com/Exiv2/exiv2/issues/984
|
||||
"""
|
||||
url = "https://github.com/Exiv2/exiv2/issues/984"
|
||||
|
||||
filename = system_tests.path(
|
||||
"$data_path/issue_94_poc3.pgf"
|
||||
)
|
||||
commands = ["$exiv2json $filename"]
|
||||
stdout = ["""Caught Exiv2 exception 'XMP Toolkit error 9: Fatal namespace map problem'
|
||||
"""]
|
||||
stderr = ["""Warning: Removing 54 characters from the beginning of the XMP packet
|
||||
"""]
|
||||
retval = [1]
|
||||
Loading…
Reference in New Issue