mirror of
https://github.com/CoolProp/CoolProp.git
synced 2026-01-13 07:58:04 -05:00
05c8cf503b
* Add initial clang tidy / clang format config files * Clang format the entire codebase ``` find ./src -regextype posix-extended -regex '.*\.(cpp|hpp|c|h|cxx|hxx)$' | xargs clang-format-12 -style=file -i -fallback-style=none find ./include -regextype posix-extended -regex '.*\.(cpp|hpp|c|h|cxx|hxx)$' | xargs clang-format-12 -style=file -i -fallback-style=none find ./Web -regextype posix-extended -regex '.*\.(cpp|hpp|c|h|cxx|hxx)$' | xargs clang-format-12 -style=file -i -fallback-style=none find ./dev -regextype posix-extended -regex '.*\.(cpp|hpp|c|h|cxx|hxx)$' | xargs clang-format-12 -style=file -i -fallback-style=none find ./wrappers -regextype posix-extended -regex '.*\.(cpp|hpp|c|h|cxx|hxx)$' | xargs clang-format-12 -style=file -i -fallback-style=none ``` * Add a .cmake-format file and reformat CmakeLists.txt with it https://github.com/cheshirekow/cmake_format * Add a clang-format workflow only runs on PRs, only on touched files
341 lines
13 KiB
C++
341 lines
13 KiB
C++
#ifndef RAPIDJSON_COOLPROP_H
|
|
#define RAPIDJSON_COOLPROP_H
|
|
|
|
// On PowerPC, we are going to use the stdint.h integer types and not let rapidjson use its own
|
|
#if defined(__powerpc__)
|
|
typedef unsigned int UINT32;
|
|
# include "stdint.h"
|
|
# define RAPIDJSON_NO_INT64DEFINE
|
|
#endif
|
|
|
|
#include "Exceptions.h"
|
|
#include "CoolPropTools.h"
|
|
|
|
#include "externals/rapidjson/include/rapidjson/rapidjson.h"
|
|
#include "externals/rapidjson/include/rapidjson/document.h"
|
|
#include "externals/rapidjson/include/rapidjson/filewritestream.h" // wrapper of C stream for prettywriter as output
|
|
#include "externals/rapidjson/include/rapidjson/prettywriter.h" // for stringify JSON
|
|
#include "externals/rapidjson/include/rapidjson/stringbuffer.h" // for string buffer
|
|
#include "externals/rapidjson/include/rapidjson/schema.h"
|
|
|
|
#include <cassert>
|
|
|
|
namespace cpjson {
|
|
|
|
/// Convert a JSON-formatted string to a rapidjson::Document object
|
|
inline void JSON_string_to_rapidjson(const std::string& JSON_string, rapidjson::Document& doc) {
|
|
doc.Parse<0>(JSON_string.c_str());
|
|
if (doc.HasParseError()) {
|
|
throw CoolProp::ValueError("Unable to load JSON string");
|
|
}
|
|
}
|
|
|
|
struct value_information
|
|
{
|
|
bool isnull, isfalse, istrue, isbool, isobject, isarray, isnumber, isint, isint64, isuint, isuint64, isdouble, isstring;
|
|
};
|
|
inline value_information get_information(rapidjson::Value& v) {
|
|
value_information i;
|
|
i.isnull = v.IsNull();
|
|
i.isfalse = v.IsFalse();
|
|
i.istrue = v.IsTrue();
|
|
i.isbool = v.IsBool();
|
|
i.isobject = v.IsObject();
|
|
i.isarray = v.IsArray();
|
|
i.isnumber = v.IsNumber();
|
|
i.isint = v.IsInt();
|
|
i.isuint = v.IsUint();
|
|
i.isint64 = v.IsInt64();
|
|
i.isuint64 = v.IsUint64();
|
|
i.isdouble = v.IsDouble();
|
|
i.isstring = v.IsString();
|
|
return i;
|
|
};
|
|
|
|
inline std::string json2string(const rapidjson::Value& v) {
|
|
rapidjson::StringBuffer buffer;
|
|
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
|
|
|
|
v.Accept(writer);
|
|
return buffer.GetString();
|
|
}
|
|
/// A convenience function to get a double from a JSON value, including error checking
|
|
inline int get_integer(const rapidjson::Value& v, std::string m) {
|
|
if (!v.HasMember(m.c_str())) {
|
|
throw CoolProp::ValueError(format("Does not have member [%s]", m.c_str()));
|
|
}
|
|
const rapidjson::Value& el = v[m.c_str()];
|
|
if (!el.IsInt()) {
|
|
throw CoolProp::ValueError(format("Member [%s] is not an integer", m.c_str()));
|
|
} else {
|
|
return el.GetInt();
|
|
}
|
|
};
|
|
/// A convenience function to get a double from a JSON value, including error checking
|
|
inline double get_double(const rapidjson::Value& v, std::string m) {
|
|
if (!v.HasMember(m.c_str())) {
|
|
throw CoolProp::ValueError(format("Does not have member [%s]", m.c_str()));
|
|
}
|
|
const rapidjson::Value& el = v[m.c_str()];
|
|
if (!el.IsNumber()) {
|
|
throw CoolProp::ValueError(format("Member [%s] is not a number", m.c_str()));
|
|
} else {
|
|
return el.GetDouble();
|
|
}
|
|
};
|
|
/// A convenience function to get a bool from a JSON value, including error checking
|
|
inline bool get_bool(const rapidjson::Value& v, std::string m) {
|
|
if (!v.HasMember(m.c_str())) {
|
|
throw CoolProp::ValueError(format("Does not have member [%s]", m.c_str()));
|
|
}
|
|
const rapidjson::Value& el = v[m.c_str()];
|
|
if (!el.IsBool()) {
|
|
throw CoolProp::ValueError(format("Member [%s] is not a boolean", m.c_str()));
|
|
} else {
|
|
return el.GetBool();
|
|
}
|
|
};
|
|
/// A convenience function to get a string from a JSON value, including error checking
|
|
inline std::string get_string(const rapidjson::Value& v, std::string m) {
|
|
if (!v.HasMember(m.c_str())) {
|
|
throw CoolProp::ValueError(format("Does not have member [%s]", m.c_str()));
|
|
}
|
|
const rapidjson::Value& el = v[m.c_str()];
|
|
if (!el.IsString()) {
|
|
throw CoolProp::ValueError(format("Member [%s] is not a string", m.c_str()));
|
|
} else {
|
|
return el.GetString();
|
|
}
|
|
};
|
|
|
|
/// A convenience function to get a double array compactly
|
|
inline std::vector<double> get_double_array(const rapidjson::Value& v) {
|
|
std::vector<double> out;
|
|
if (!v.IsArray()) {
|
|
throw CoolProp::ValueError("input is not an array");
|
|
}
|
|
for (rapidjson::Value::ConstValueIterator itr = v.Begin(); itr != v.End(); ++itr) {
|
|
if (!itr->IsNumber()) {
|
|
throw CoolProp::ValueError("input is not a number");
|
|
}
|
|
out.push_back(itr->GetDouble());
|
|
}
|
|
return out;
|
|
};
|
|
|
|
/// A convenience function to get a double array compactly
|
|
inline std::vector<double> get_double_array(const rapidjson::Value& v, std::string m) {
|
|
if (!v.HasMember(m.c_str())) {
|
|
throw CoolProp::ValueError(format("Does not have member [%s]", m.c_str()));
|
|
} else {
|
|
return get_double_array(v[m.c_str()]);
|
|
}
|
|
};
|
|
|
|
/// A convenience function to get a long double array compactly
|
|
inline std::vector<CoolPropDbl> get_long_double_array(const rapidjson::Value& v) {
|
|
std::vector<CoolPropDbl> out;
|
|
if (!v.IsArray()) {
|
|
throw CoolProp::ValueError("input is not an array");
|
|
}
|
|
for (rapidjson::Value::ConstValueIterator itr = v.Begin(); itr != v.End(); ++itr) {
|
|
if (!itr->IsNumber()) {
|
|
throw CoolProp::ValueError("input is not a number");
|
|
}
|
|
out.push_back(itr->GetDouble());
|
|
}
|
|
return out;
|
|
};
|
|
|
|
/// A convenience function to get a 2D double array compactly
|
|
inline std::vector<std::vector<double>> get_double_array2D(const rapidjson::Value& v) {
|
|
std::vector<std::vector<double>> out;
|
|
std::vector<double> tmp;
|
|
if (!v.IsArray()) {
|
|
throw CoolProp::ValueError("input is not an array");
|
|
}
|
|
for (rapidjson::Value::ConstValueIterator itr = v.Begin(); itr != v.End(); ++itr) {
|
|
// This is here for debugging purposes
|
|
// cpjson::value_information vi = cpjson::get_information((*itr));
|
|
if (!(itr->IsArray())) {
|
|
throw CoolProp::ValueError(format("input \"%s\" is not a 2D array", cpjson::json2string(v).c_str()));
|
|
}
|
|
tmp.clear();
|
|
for (rapidjson::Value::ConstValueIterator i = itr->Begin(); i != itr->End(); ++i) {
|
|
if (!i->IsNumber()) {
|
|
throw CoolProp::ValueError("input is not a number");
|
|
}
|
|
tmp.push_back(i->GetDouble());
|
|
}
|
|
out.push_back(tmp);
|
|
}
|
|
return out;
|
|
};
|
|
|
|
/// A convenience function to get a 2D long double array compactly
|
|
inline std::vector<std::vector<CoolPropDbl>> get_long_double_array2D(const rapidjson::Value& v) {
|
|
std::vector<std::vector<CoolPropDbl>> out;
|
|
std::vector<CoolPropDbl> tmp;
|
|
if (!v.IsArray()) {
|
|
throw CoolProp::ValueError("input is not an array");
|
|
}
|
|
for (rapidjson::Value::ConstValueIterator itr = v.Begin(); itr != v.End(); ++itr) {
|
|
if (!itr->IsArray()) {
|
|
throw CoolProp::ValueError("input is not a 2D array");
|
|
}
|
|
tmp.clear();
|
|
for (rapidjson::Value::ConstValueIterator i = itr->Begin(); i != itr->End(); ++i) {
|
|
if (!i->IsNumber()) {
|
|
throw CoolProp::ValueError("input is not a number");
|
|
}
|
|
tmp.push_back(i->GetDouble());
|
|
}
|
|
out.push_back(tmp);
|
|
}
|
|
return out;
|
|
};
|
|
|
|
/// A convenience function to get a long double array compactly
|
|
inline std::vector<CoolPropDbl> get_long_double_array(const rapidjson::Value& v, std::string name) {
|
|
std::vector<CoolPropDbl> out;
|
|
if (!v.HasMember(name.c_str())) {
|
|
throw CoolProp::ValueError(format("Does not have member [%s]", name.c_str()));
|
|
}
|
|
if (!v[name.c_str()].IsArray()) {
|
|
throw CoolProp::ValueError("input is not an array");
|
|
}
|
|
for (rapidjson::Value::ConstValueIterator itr = v[name.c_str()].Begin(); itr != v[name.c_str()].End(); ++itr) {
|
|
if (!itr->IsNumber()) {
|
|
throw CoolProp::ValueError("input is not a number");
|
|
}
|
|
out.push_back(itr->GetDouble());
|
|
}
|
|
return out;
|
|
};
|
|
|
|
/// A convenience function to get a string array compactly
|
|
inline std::vector<std::string> get_string_array(const rapidjson::Value& v) {
|
|
std::vector<std::string> out;
|
|
if (!v.IsArray()) {
|
|
throw CoolProp::ValueError("input is not an array");
|
|
}
|
|
for (rapidjson::Value::ConstValueIterator itr = v.Begin(); itr != v.End(); ++itr) {
|
|
out.push_back(itr->GetString());
|
|
}
|
|
return out;
|
|
};
|
|
|
|
/// A convenience function to get a string array compactly
|
|
inline std::vector<std::string> get_string_array(const rapidjson::Value& v, std::string m) {
|
|
if (!v.HasMember(m.c_str())) {
|
|
throw CoolProp::ValueError(format("Does not have member [%s]", m.c_str()));
|
|
} else {
|
|
return get_string_array(v[m.c_str()]);
|
|
}
|
|
};
|
|
|
|
/// A convenience function to get a std::string from a JSON value
|
|
template <typename T>
|
|
inline std::string to_string(const T& v) {
|
|
rapidjson::StringBuffer buffer;
|
|
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
|
|
v.Accept(writer);
|
|
return buffer.GetString();
|
|
};
|
|
|
|
/// A convenience function to set a 2D array of double compactly
|
|
inline void set_double_array2D(const char* key, const std::vector<std::vector<double>>& vec, rapidjson::Value& value, rapidjson::Document& doc) {
|
|
rapidjson::Value _i(rapidjson::kArrayType);
|
|
for (unsigned int i = 0; i < vec.size(); ++i) {
|
|
rapidjson::Value _j(rapidjson::kArrayType);
|
|
for (unsigned int j = 0; j < vec[i].size(); ++j) {
|
|
rapidjson::Value v(rapidjson::kNumberType);
|
|
v.SetDouble(vec[i][j]);
|
|
_j.PushBack(v, doc.GetAllocator());
|
|
}
|
|
_i.PushBack(_j, doc.GetAllocator());
|
|
}
|
|
value.AddMember(rapidjson::Value(key, doc.GetAllocator()).Move(), _i, doc.GetAllocator());
|
|
};
|
|
|
|
/// A convenience function to set a string compactly
|
|
inline void set_string(const std::string& key, const std::string& s, rapidjson::Value& value, rapidjson::Document& doc) {
|
|
value.AddMember(rapidjson::Value(key.c_str(), doc.GetAllocator()).Move(), rapidjson::Value(s.c_str(), doc.GetAllocator()).Move(),
|
|
doc.GetAllocator());
|
|
};
|
|
|
|
/// A convenience function to set a string array compactly
|
|
inline void set_string_array(const char* key, const std::vector<std::string>& vec, rapidjson::Value& value, rapidjson::Document& doc) {
|
|
rapidjson::Value _v(rapidjson::kArrayType);
|
|
for (unsigned int i = 0; i < vec.size(); ++i) {
|
|
_v.PushBack(rapidjson::Value(vec[i].c_str(), doc.GetAllocator()).Move(), doc.GetAllocator());
|
|
}
|
|
value.AddMember(rapidjson::Value(key, doc.GetAllocator()).Move(), _v, doc.GetAllocator());
|
|
};
|
|
|
|
/// A convenience function to set an integer array compactly
|
|
inline void set_int_array(const char* key, const std::vector<int>& vec, rapidjson::Value& value, rapidjson::Document& doc) {
|
|
rapidjson::Value _v(rapidjson::kArrayType);
|
|
for (unsigned int i = 0; i < vec.size(); ++i) {
|
|
_v.PushBack(vec[i], doc.GetAllocator());
|
|
}
|
|
value.AddMember(rapidjson::Value(key, doc.GetAllocator()).Move(), _v, doc.GetAllocator());
|
|
};
|
|
|
|
/// A convenience function to set a double array compactly
|
|
inline void set_double_array(const char* key, const std::vector<double>& vec, rapidjson::Value& value, rapidjson::Document& doc) {
|
|
rapidjson::Value _v(rapidjson::kArrayType);
|
|
for (unsigned int i = 0; i < vec.size(); ++i) {
|
|
_v.PushBack(vec[i], doc.GetAllocator());
|
|
}
|
|
value.AddMember(rapidjson::Value(key, doc.GetAllocator()).Move(), _v, doc.GetAllocator());
|
|
};
|
|
|
|
/// A convenience function to set a double array compactly
|
|
inline void set_long_double_array(const char* const key, const std::vector<CoolPropDbl>& vec, rapidjson::Value& value, rapidjson::Document& doc) {
|
|
rapidjson::Value _v(rapidjson::kArrayType);
|
|
for (unsigned int i = 0; i < vec.size(); ++i) {
|
|
_v.PushBack(static_cast<double>(vec[i]), doc.GetAllocator());
|
|
}
|
|
value.AddMember(rapidjson::Value(key, doc.GetAllocator()).Move(), _v, doc.GetAllocator());
|
|
};
|
|
|
|
enum schema_validation_code
|
|
{
|
|
SCHEMA_VALIDATION_OK = 0,
|
|
SCHEMA_INVALID_JSON,
|
|
INPUT_INVALID_JSON,
|
|
SCHEMA_NOT_VALIDATED
|
|
};
|
|
/**
|
|
* Validate a JSON-formatted string against a JSON-formatted schema string
|
|
*/
|
|
inline schema_validation_code validate_schema(const std::string& schemaJson, const std::string& inputJson, std::string& errstr) {
|
|
rapidjson::Document sd;
|
|
sd.Parse(schemaJson.c_str());
|
|
if (sd.HasParseError()) {
|
|
errstr = format("Invalid schema: %s\n", schemaJson.c_str());
|
|
return SCHEMA_INVALID_JSON;
|
|
}
|
|
rapidjson::SchemaDocument schema(sd); // Compile a Document to SchemaDocument
|
|
|
|
rapidjson::Document d;
|
|
d.Parse(inputJson.c_str());
|
|
if (d.HasParseError()) {
|
|
errstr = format("Invalid input json: %s\n", inputJson.c_str());
|
|
return INPUT_INVALID_JSON;
|
|
}
|
|
|
|
rapidjson::SchemaValidator validator(schema);
|
|
if (!d.Accept(validator)) {
|
|
// Input JSON is invalid according to the schema
|
|
// Output diagnostic information
|
|
errstr = to_string(validator.GetError());
|
|
return SCHEMA_NOT_VALIDATED;
|
|
}
|
|
return SCHEMA_VALIDATION_OK;
|
|
}
|
|
|
|
} // namespace cpjson
|
|
#endif
|