mirror of
https://github.com/vcmi/vcmi.git
synced 2024-12-24 22:14:36 +02:00
410 lines
12 KiB
C++
410 lines
12 KiB
C++
/*
|
|
* JsonNode.h, part of VCMI engine
|
|
*
|
|
* Authors: listed in file AUTHORS in main folder
|
|
*
|
|
* License: GNU General Public License v2.0 or later
|
|
* Full text of license available in license.txt file, in main folder
|
|
*
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
class JsonNode;
|
|
typedef std::map <std::string, JsonNode> JsonMap;
|
|
typedef std::vector <JsonNode> JsonVector;
|
|
|
|
DLL_LINKAGE std::ostream & operator<<(std::ostream &out, const JsonNode &node);
|
|
|
|
struct Bonus;
|
|
class ResourceID;
|
|
|
|
class DLL_LINKAGE JsonNode
|
|
{
|
|
public:
|
|
enum JsonType
|
|
{
|
|
DATA_NULL,
|
|
DATA_BOOL,
|
|
DATA_FLOAT,
|
|
DATA_STRING,
|
|
DATA_VECTOR,
|
|
DATA_STRUCT
|
|
};
|
|
|
|
private:
|
|
union JsonData
|
|
{
|
|
bool Bool;
|
|
double Float;
|
|
std::string* String;
|
|
JsonVector* Vector;
|
|
JsonMap* Struct;
|
|
};
|
|
|
|
JsonType type;
|
|
JsonData data;
|
|
|
|
public:
|
|
//Create empty node
|
|
JsonNode(JsonType Type = DATA_NULL);
|
|
//Create tree from Json-formatted input
|
|
explicit JsonNode(const char * data, size_t datasize);
|
|
//Create tree from JSON file
|
|
explicit JsonNode(ResourceID && fileURI);
|
|
//Copy c-tor
|
|
JsonNode(const JsonNode ©);
|
|
|
|
~JsonNode();
|
|
|
|
void swap(JsonNode &b);
|
|
JsonNode& operator =(JsonNode node);
|
|
|
|
bool operator == (const JsonNode &other) const;
|
|
bool operator != (const JsonNode &other) const;
|
|
|
|
/// Convert node to another type. Converting to NULL will clear all data
|
|
void setType(JsonType Type);
|
|
JsonType getType() const;
|
|
|
|
bool isNull() const;
|
|
/// removes all data from node and sets type to null
|
|
void clear();
|
|
|
|
/// non-const accessors, node will change type on type mismatch
|
|
bool & Bool();
|
|
double & Float();
|
|
std::string & String();
|
|
JsonVector & Vector();
|
|
JsonMap & Struct();
|
|
|
|
/// const accessors, will cause assertion failure on type mismatch
|
|
const bool & Bool() const;
|
|
const double & Float() const;
|
|
const std::string & String() const;
|
|
const JsonVector & Vector() const;
|
|
const JsonMap & Struct() const;
|
|
|
|
/// returns resolved "json pointer" (string in format "/path/to/node")
|
|
const JsonNode & resolvePointer(const std::string & jsonPointer) const;
|
|
JsonNode & resolvePointer(const std::string & jsonPointer);
|
|
|
|
/// convert json tree into specified type. Json tree must have same type as Type
|
|
/// Valid types: bool, string, any numeric, map and vector
|
|
/// example: convertTo< std::map< std::vector<int> > >();
|
|
template<typename Type>
|
|
Type convertTo() const;
|
|
|
|
//operator [], for structs only - get child node by name
|
|
JsonNode & operator[](std::string child);
|
|
const JsonNode & operator[](std::string child) const;
|
|
|
|
template <typename Handler> void serialize(Handler &h, const int version)
|
|
{
|
|
// simple saving - save json in its string interpretation
|
|
if (h.saving)
|
|
{
|
|
std::ostringstream stream;
|
|
stream << *this;
|
|
std::string str = stream.str();
|
|
h & str;
|
|
}
|
|
else
|
|
{
|
|
std::string str;
|
|
h & str;
|
|
JsonNode(str.c_str(), str.size()).swap(*this);
|
|
}
|
|
}
|
|
};
|
|
|
|
namespace JsonUtils
|
|
{
|
|
/**
|
|
* @brief parse short bonus format, excluding type
|
|
* @note sets duration to Permament
|
|
*/
|
|
DLL_LINKAGE void parseTypedBonusShort(const JsonVector &source, Bonus *dest);
|
|
|
|
///
|
|
DLL_LINKAGE Bonus * parseBonus (const JsonVector &ability_vec);
|
|
DLL_LINKAGE Bonus * parseBonus (const JsonNode &bonus);
|
|
DLL_LINKAGE void unparseBonus (JsonNode &node, const Bonus * bonus);
|
|
DLL_LINKAGE void resolveIdentifier (si32 &var, const JsonNode &node, std::string name);
|
|
DLL_LINKAGE void resolveIdentifier (const JsonNode &node, si32 &var);
|
|
|
|
/**
|
|
* @brief recursivly merges source into dest, replacing identical fields
|
|
* struct : recursively calls this function
|
|
* arrays : each entry will be merged recursively
|
|
* values : value in source will replace value in dest
|
|
* null : if value in source is present but set to null it will delete entry in dest
|
|
* @note this function will destroy data in source
|
|
*/
|
|
DLL_LINKAGE void merge(JsonNode & dest, JsonNode & source);
|
|
|
|
/**
|
|
* @brief recursivly merges source into dest, replacing identical fields
|
|
* struct : recursively calls this function
|
|
* arrays : each entry will be merged recursively
|
|
* values : value in source will replace value in dest
|
|
* null : if value in source is present but set to null it will delete entry in dest
|
|
* @note this function will preserve data stored in source by creating copy
|
|
*/
|
|
DLL_LINKAGE void mergeCopy(JsonNode & dest, JsonNode source);
|
|
|
|
/**
|
|
* @brief generate one Json structure from multiple files
|
|
* @param files - list of filenames with parts of json structure
|
|
*/
|
|
DLL_LINKAGE JsonNode assembleFromFiles(std::vector<std::string> files);
|
|
|
|
/**
|
|
* @brief removes all nodes that are identical to default entry in schema
|
|
* @param node - JsonNode to minimize
|
|
* @param schemaName - name of schema to use
|
|
* @note for minimizing data must be valid against given schema
|
|
*/
|
|
DLL_LINKAGE void minimize(JsonNode & node, std::string schemaName);
|
|
/// opposed to minimize, adds all missing, required entries that have default value
|
|
DLL_LINKAGE void maximize(JsonNode & node, std::string schemaName);
|
|
|
|
/**
|
|
* @brief validate node against specified schema
|
|
* @param node - JsonNode to check
|
|
* @param schemaName - name of schema to use
|
|
* @param dataName - some way to identify data (printed in console in case of errors)
|
|
* @returns true if data in node fully compilant with schema
|
|
*/
|
|
DLL_LINKAGE bool validate(const JsonNode & node, std::string schemaName, std::string dataName);
|
|
|
|
/// get schema by json URI: vcmi:<name of file in schemas directory>#<entry in file, optional>
|
|
/// example: schema "vcmi:settings" is used to check user settings
|
|
DLL_LINKAGE const JsonNode & getSchema(std::string URI);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// End of public section of the file. Anything below should be only used internally in JsonNode.cpp //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace JsonDetail
|
|
{
|
|
// convertion helpers for JsonNode::convertTo (partial template function instantiation is illegal in c++)
|
|
|
|
template <typename T, int arithm>
|
|
struct JsonConvImpl;
|
|
|
|
template <typename T>
|
|
struct JsonConvImpl<T, 1>
|
|
{
|
|
static T convertImpl(const JsonNode & node)
|
|
{
|
|
return T((int)node.Float());
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct JsonConvImpl<T, 0>
|
|
{
|
|
static T convertImpl(const JsonNode & node)
|
|
{
|
|
return node.Float();
|
|
}
|
|
};
|
|
|
|
template<typename Type>
|
|
struct JsonConverter
|
|
{
|
|
static Type convert(const JsonNode & node)
|
|
{
|
|
///this should be triggered only for numeric types and enums
|
|
static_assert(boost::mpl::or_<std::is_arithmetic<Type>, std::is_enum<Type>, boost::is_class<Type> >::value, "Unsupported type for JsonNode::convertTo()!");
|
|
return JsonConvImpl<Type, boost::mpl::or_<std::is_enum<Type>, boost::is_class<Type> >::value >::convertImpl(node);
|
|
|
|
}
|
|
};
|
|
|
|
template<typename Type>
|
|
struct JsonConverter<std::map<std::string, Type> >
|
|
{
|
|
static std::map<std::string, Type> convert(const JsonNode & node)
|
|
{
|
|
std::map<std::string, Type> ret;
|
|
BOOST_FOREACH(auto entry, node.Struct())
|
|
{
|
|
ret.insert(entry.first, entry.second.convertTo<Type>());
|
|
}
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
template<typename Type>
|
|
struct JsonConverter<std::set<Type> >
|
|
{
|
|
static std::set<Type> convert(const JsonNode & node)
|
|
{
|
|
std::set<Type> ret;
|
|
BOOST_FOREACH(auto entry, node.Vector())
|
|
{
|
|
ret.insert(entry.convertTo<Type>());
|
|
}
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
template<typename Type>
|
|
struct JsonConverter<std::vector<Type> >
|
|
{
|
|
static std::vector<Type> convert(const JsonNode & node)
|
|
{
|
|
std::vector<Type> ret;
|
|
BOOST_FOREACH(auto entry, node.Vector())
|
|
{
|
|
ret.push_back(entry.convertTo<Type>());
|
|
}
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct JsonConverter<std::string>
|
|
{
|
|
static std::string convert(const JsonNode & node)
|
|
{
|
|
return node.String();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct JsonConverter<bool>
|
|
{
|
|
static bool convert(const JsonNode & node)
|
|
{
|
|
return node.Bool();
|
|
}
|
|
};
|
|
|
|
class JsonWriter
|
|
{
|
|
//prefix for each line (tabulation)
|
|
std::string prefix;
|
|
std::ostream &out;
|
|
public:
|
|
template<typename Iterator>
|
|
void writeContainer(Iterator begin, Iterator end);
|
|
void writeEntry(JsonMap::const_iterator entry);
|
|
void writeEntry(JsonVector::const_iterator entry);
|
|
void writeString(const std::string &string);
|
|
void writeNode(const JsonNode &node);
|
|
JsonWriter(std::ostream &output, const JsonNode &node);
|
|
};
|
|
|
|
//Tiny string class that uses const char* as data for speed, members are private
|
|
//for ease of debugging and some compatibility with std::string
|
|
class constString
|
|
{
|
|
const char *data;
|
|
const size_t datasize;
|
|
|
|
public:
|
|
constString(const char * inputString, size_t stringSize):
|
|
data(inputString),
|
|
datasize(stringSize)
|
|
{
|
|
}
|
|
|
|
inline size_t size() const
|
|
{
|
|
return datasize;
|
|
};
|
|
|
|
inline const char& operator[] (size_t position)
|
|
{
|
|
assert (position < datasize);
|
|
return data[position];
|
|
}
|
|
};
|
|
|
|
//Internal class for string -> JsonNode conversion
|
|
class JsonParser
|
|
{
|
|
std::string errors; // Contains description of all encountered errors
|
|
constString input; // Input data
|
|
ui32 lineCount; // Currently parsed line, starting from 1
|
|
size_t lineStart; // Position of current line start
|
|
size_t pos; // Current position of parser
|
|
|
|
//Helpers
|
|
bool extractEscaping(std::string &str);
|
|
bool extractLiteral(const std::string &literal);
|
|
bool extractString(std::string &string);
|
|
bool extractWhitespace(bool verbose = true);
|
|
bool extractSeparator();
|
|
bool extractElement(JsonNode &node, char terminator);
|
|
|
|
//Methods for extracting JSON data
|
|
bool extractArray(JsonNode &node);
|
|
bool extractFalse(JsonNode &node);
|
|
bool extractFloat(JsonNode &node);
|
|
bool extractNull(JsonNode &node);
|
|
bool extractString(JsonNode &node);
|
|
bool extractStruct(JsonNode &node);
|
|
bool extractTrue(JsonNode &node);
|
|
bool extractValue(JsonNode &node);
|
|
|
|
//Add error\warning message to list
|
|
bool error(const std::string &message, bool warning=false);
|
|
|
|
public:
|
|
JsonParser(const char * inputString, size_t stringSize);
|
|
|
|
/// do actual parsing. filename is name of file that will printed to console if any errors were found
|
|
JsonNode parse(std::string fileName);
|
|
};
|
|
|
|
//Internal class for Json validation. Mostly compilant with json-schema v4 draft
|
|
class JsonValidator
|
|
{
|
|
// path from root node to current one.
|
|
// JsonNode is used as variant - either string (name of node) or as float (index in list)
|
|
std::vector<JsonNode> currentPath;
|
|
// Stack of used schemas. Last schema is the one used currently.
|
|
// May contain multiple items in case if remote references were found
|
|
std::vector<std::string> usedSchemas;
|
|
|
|
/// helpers for other validation methods
|
|
std::string validateVectorItem(const JsonVector items, const JsonNode & schema, const JsonNode & additional, size_t index);
|
|
std::string validateStructItem(const JsonNode &node, const JsonNode &schema, const JsonNode & additional, std::string nodeName);
|
|
|
|
std::string validateEnum(const JsonNode &node, const JsonVector &enumeration);
|
|
std::string validateNodeType(const JsonNode &node, const JsonNode &schema);
|
|
std::string validatesSchemaList(const JsonNode &node, const JsonNode &schemas, std::string errorMsg, std::function<bool(size_t)> isValid);
|
|
|
|
/// contains all type-independent checks
|
|
std::string validateNode(const JsonNode &node, const JsonNode &schema);
|
|
|
|
/// type-specific checks
|
|
std::string validateVector(const JsonNode &node, const JsonNode &schema);
|
|
std::string validateStruct(const JsonNode &node, const JsonNode &schema);
|
|
std::string validateString(const JsonNode &node, const JsonNode &schema);
|
|
std::string validateNumber(const JsonNode &node, const JsonNode &schema);
|
|
|
|
/// validation of root node of both schema and input data
|
|
std::string validateRoot(const JsonNode &node, std::string schemaName);
|
|
|
|
/// add error message to list and return false
|
|
std::string fail(const std::string &message);
|
|
public:
|
|
|
|
/// returns true if parsed data is fully compilant with schema
|
|
bool validate(const JsonNode &root, std::string schemaName, std::string name);
|
|
};
|
|
|
|
} // namespace JsonDetail
|
|
|
|
template<typename Type>
|
|
Type JsonNode::convertTo() const
|
|
{
|
|
return JsonDetail::JsonConverter<Type>::convert(*this);
|
|
}
|