void ItemLocation::FromItemJson(const rapidjson::Value &root) {
if (root.HasMember("_type")) {
type_ = static_cast<ItemLocationType>(root["_type"].GetInt());
if (type_ == ItemLocationType::STASH) {
tab_label_ = root["_tab_label"].GetString();
tab_id_ = root["_tab"].GetInt();
} else {
character_ = root["_character"].GetString();
}
socketed_ = false;
if (root.HasMember("_socketed"))
socketed_ = root["_socketed"].GetBool();
// socketed items have x/y pointing to parent
if (socketed_) {
x_ = root["_x"].GetInt();
y_ = root["_y"].GetInt();
}
}
if (root.HasMember("x") && root.HasMember("y")) {
x_ = root["x"].GetInt();
y_ = root["y"].GetInt();
}
w_ = root["w"].GetInt();
h_ = root["h"].GetInt();
if (root.HasMember("inventoryId"))
inventory_id_ = root["inventoryId"].GetString();
}
Post processRawPost(const rapidjson::Value& raw_post) {
const char* ITEM_ID = "id";
const char* ITEM_USER_ID = "userId";
const char* ITEM_TITLE = "title";
const char* ITEM_BODY = "body";
Post post;
if (raw_post.IsObject()) { // could also be an Array
assert("No item: id" && raw_post.HasMember(ITEM_ID));
assert("Not an integer: id" && raw_post[ITEM_ID].IsInt());
post.id = raw_post[ITEM_ID].GetInt();
assert("No item: user_id" && raw_post.HasMember(ITEM_USER_ID));
assert("Not an integer: user_id" && raw_post[ITEM_USER_ID].IsInt());
post.user_id = raw_post[ITEM_USER_ID].GetInt();
assert("No item: title" && raw_post.HasMember(ITEM_TITLE));
assert("Not a string: title" && raw_post[ITEM_TITLE].IsString());
post.title = std::string(raw_post[ITEM_TITLE].GetString());
assert("No item: body" && raw_post.HasMember(ITEM_BODY));
assert("Not a string: body" && raw_post[ITEM_BODY].IsString());
post.body = std::string(raw_post[ITEM_BODY].GetString());
} else {
ERR("Invalid json object");
}
return post;
}
bool
Element::loadFromJsonValue(rapidjson::Value& json_value)
{
if (!json_value.IsObject()) {
return false;
}
// parse the data and set the Elements
if (json_value.HasMember("id")) {
const rapidjson::Value& idVal = json_value["id"];
id_.fromStr(idVal.GetString());
}
tag_ids_.clear();
if (json_value.HasMember("tag_ids")) {
const rapidjson::Value& tag_ids = json_value["tag_ids"];
if (!tag_ids.IsArray()) {
LOG_ERROR("tag_ids field is not an array, wrong format?");
return false;
}
for (unsigned int i = 0; i < tag_ids.Size(); ++i) {
if (!tag_ids[i].IsString()) {
LOG_ERROR("Wrong format, expected string but it is not");
return false;
}
tag_ids_.insert(core::UID(tag_ids[i].GetString()));
}
}
return true;
}
void Item::CalculateHash(const rapidjson::Value &json) {
std::string unique_old(name_ + "~" + typeLine_ + "~");
std::string unique_new(std::string(json["name"].GetString()) + "~" + json["typeLine"].GetString() + "~");
std::string unique_common;
if (json.HasMember("explicitMods"))
for (auto &mod : json["explicitMods"])
unique_common += std::string(mod.GetString()) + "~";
if (json.HasMember("implicitMods"))
for (auto &mod : json["implicitMods"])
unique_common += std::string(mod.GetString()) + "~";
unique_common += item_unique_properties(json, "properties") + "~";
unique_common += item_unique_properties(json, "additionalProperties") + "~";
if (json.HasMember("sockets"))
for (auto &socket : json["sockets"])
unique_common += std::to_string(socket["group"].GetInt()) + "~" + socket["attr"].GetString() + "~";
unique_old += unique_common;
unique_new += unique_common;
old_hash_ = Util::Md5(unique_old);
unique_new += "~" + location_.GetUniqueHash();
hash_ = Util::Md5(unique_new);
}
void JSONDataParser::_parseEventData(const rapidjson::Value& rawData, std::vector<EventData*>& events, BoneData * bone, SlotData * slot) const
{
if (rawData.HasMember(SOUND))
{
const auto eventData = BaseObject::borrowObject<EventData>();
eventData->type = EventType::Sound;
eventData->name = rawData[SOUND].GetString();
eventData->bone = bone;
eventData->slot = slot;
events.push_back(eventData);
}
if (rawData.HasMember(EVENT))
{
const auto eventData = BaseObject::borrowObject<EventData>();
eventData->type = EventType::Frame;
eventData->name = rawData[EVENT].GetString();
eventData->bone = bone;
eventData->slot = slot;
if (rawData.HasMember(DATA))
{
// eventData->data = rawData[DATA]; // TODO
}
events.push_back(eventData);
}
}
void Screen::fromJson(rapidjson::Value& value) {
auto visibleSize = cocos2d::Director::getInstance()->getVisibleSize();
if (value.HasMember("positioning")) {
std::string _positioning = toLowerCase(value["positioning"].GetString());
if (_positioning == "block") {
this->positioning = Screen::PositionTypes::BLOCK;
}
else if (_positioning == "overlay") {
this->positioning = Screen::PositionTypes::OVERLAY;
}
else if (_positioning == "fixed") {
this->positioning = Screen::PositionTypes::FIXED;
}
}
if (value.HasMember("position")) {
assert(value["position"].IsArray());
this->position.x = visibleSize.width * value["position"][0].GetInt();
this->position.y = visibleSize.height - visibleSize.height * value["position"][1].GetInt();
}
if (value.HasMember("size")) {
assert(value["size"].IsArray());
//Optimize This: Not really needed but this is gross
this->size.width = visibleSize.width * value["size"][0].GetDouble();
this->size.height = visibleSize.height * value["size"][1].GetDouble();
}
}
std::string PersonManager::handleDressFigure(const rapidjson::Value& json)
{
std::string operation = json["OPERATION"].GetString();
if (json.HasMember("WHO") == false || json.HasMember("FIGURES") == false)
{
return "missing WHO or FIGURES";
}
std::string who = json["WHO"].GetString();
const rapidjson::Value& figures = json["FIGURES"];
assert(figures.IsArray());
if (who != "me" && who != "spouse")
{
return "invalid value of WHO";
}
Person* person = (who == "me" ? mMe : mSpouse);
for (rapidjson::SizeType i = 0; i < figures.Size(); ++i)
{
const rapidjson::Value& item = figures[i];
assert(item.HasMember("TYPE"));
assert(item.HasMember("NAME"));
std::string type = item["TYPE"].GetString();
std::string id = item["NAME"].GetString();
FigureKey figureKey(person->isMale(), type, id);
FigureManager::getInstance()->dressItem(figureKey);
}
return SUCC;
}
Manifest::Asset Manifest::parseAsset(const std::string &path, const rapidjson::Value &json)
{
Asset asset;
asset.path = path;
if ( json.HasMember(KEY_MD5) && json[KEY_MD5].IsString() )
{
asset.md5 = json[KEY_MD5].GetString();
}
else asset.md5 = "";
if ( json.HasMember(KEY_PATH) && json[KEY_PATH].IsString() )
{
asset.path = json[KEY_PATH].GetString();
}
if ( json.HasMember(KEY_COMPRESSED) && json[KEY_COMPRESSED].IsBool() )
{
asset.compressed = json[KEY_COMPRESSED].GetBool();
}
else asset.compressed = false;
if ( json.HasMember(KEY_DOWNLOAD_STATE) && json[KEY_DOWNLOAD_STATE].IsInt() )
{
asset.downloadState = (DownloadState)(json[KEY_DOWNLOAD_STATE].GetInt());
}
else asset.downloadState = DownloadState::UNSTARTED;
return asset;
}
RenderOptions RenderOptions::Load(const rapidjson::Value& value) {
RenderOptions options;
if (value.HasMember("maxThreadsCount")) {
options.maxThreadsCount = value["maxThreadsCount"].GetInt();
}
if (value.HasMember("antialiasingSampling")) {
options.antialiasingSampling = SamplingConfig::Load(value["antialiasingSampling"]);
}
if (value.HasMember("maxRayDepth")) {
options.maxRayDepth = value["maxRayDepth"].GetInt();
}
if (value.HasMember("surfaceIntegrator")) {
options.surfaceIntegrator = SurfaceIntegrator::Load(value["surfaceIntegrator"]);
if (!options.surfaceIntegrator) {
std::cerr << "RenderOptions error: error while loading surface integrator" << std::endl;
}
} else {
std::cerr << "RenderOptions error: no surface integrator given" << std::endl;
}
if (value.HasMember("volumeIntegrator")) {
options.volumeIntegrator = VolumeIntegrator::Load(value["volumeIntegrator"]);
if (!options.volumeIntegrator) {
std::cerr << "RenderOptions error: error while loading volume integrator" << std::endl;
}
} else {
std::cerr << "RenderOptions error: no volume integrator given" << std::endl;
}
return options;
}
EffectData::EffectData(EffectType t, const rapidjson::Value &json)
: type{t},
anim{},
animFrames{},
sound{},
dur{Duration::INSTANT},
text{}
{
if (json.HasMember("anim")) {
anim = sdlLoadImage(json["anim"].GetString());
}
if (json.HasMember("anim-frames")) {
animFrames = jsonListUnsigned(json["anim-frames"]);
}
if (json.HasMember("sound")) {
sound = sdlLoadSound(json["sound"].GetString());
}
if (json.HasMember("duration")) {
const auto &durType = json["duration"].GetString();
auto iter = allDurations.find(to_upper(durType));
if (iter != std::end(allDurations)) {
dur = iter->second;
}
else {
std::cerr << "Warning: unrecognized duration type for effect " <<
" type " << static_cast<int>(type) << '\n';
}
}
if (json.HasMember("text")) {
text = json["text"].GetString();
}
}
void BQ::RigidBodyPattern::parse(const rapidjson::Value & json)
{
mass = json.HasMember("mass") ? json["mass"].GetFloat() : 1;
restitution = json.HasMember("restitution") ? json["restitution"].GetFloat() : 1;
friction = json.HasMember("friction") ? json["friction"].GetFloat() : 0;
momentum.x = json.HasMember("momentum_x") ? json["momentum_x"].GetFloat() : 0;
momentum.y = json.HasMember("momentum_y") ? json["momentum_y"].GetFloat() : 0;
}
bool is_as_msg(const rapidjson::Value & val)
{
RAPIDJSON_ASSERT(val.HasMember("category"));
RAPIDJSON_ASSERT(val.HasMember("msgid"));
RAPIDJSON_ASSERT(val.FindMember("msgid")->value.IsArray());
if (val.FindMember("msgid")->value.Size() > 0) {
return true;
}
return false;
}
std::string ChatOnBedRoom::handlePlatformMessage(const rapidjson::Value& content)
{
std::string operation = content[minius::Protocol::OPERATION.c_str()].GetString();
if (operation == "loadModule")
{
std::string result = SUCC;
if (content.HasMember("INIT_DATA"))
{
const rapidjson::Value& initData = content["INIT_DATA"];
for (rapidjson::SizeType i = 0; i < initData.Size(); ++i)
{
std::string resultTemp = this->handlePlatformMessage(initData[i]);
//assert(resultTemp == SUCC);
/*
if (resultTemp != SUCC)
result = resultTemp;*/
}
}
return result;
}
else if (operation == "setComponentAttrs")
{
if (content.HasMember("COMPONENT") == false || content.HasMember("ATTRS") == false)
{
return "missing COMPONENT or ATTRS";
}
std::string componentName = content["COMPONENT"].GetString();
minius::Component* pComponent = dynamic_cast<minius::Component*>(this->getChildByName(componentName));
if (pComponent == nullptr)
{
return std::string("invalid COMPONENT: ") + componentName;
}
bool status = pComponent->setAttrs(content["ATTRS"]);
return SUCC;
}
else if (operation == "chatAction")
{
std::string type = content["TYPE"].GetString();
std::string sponsor = content["WHO"].GetString();
if (sponsor == "me") {
this->playActionWithIsMeSponsor(true, type);
}
else {
this->playActionWithIsMeSponsor(false, type);
}
return SUCC;
}
else
{
return std::string("invalid OPERATION: ") + operation;
}
}
bool Client::parseJob(const rapidjson::Value ¶ms, int *code)
{
if (!params.IsObject()) {
*code = 2;
return false;
}
# ifdef XMRIG_PROXY_PROJECT
Job job(m_id, m_url.variant());
job.setClientId(m_rpcId);
job.setCoin(m_url.coin());
# else
Job job(m_id, m_nicehash, m_url.algo(), m_url.variant());
# endif
if (!job.setId(params["job_id"].GetString())) {
*code = 3;
return false;
}
if (!job.setBlob(params["blob"].GetString())) {
*code = 4;
return false;
}
if (!job.setTarget(params["target"].GetString())) {
*code = 5;
return false;
}
if (params.HasMember("coin")) {
job.setCoin(params["coin"].GetString());
}
if (params.HasMember("variant")) {
job.setVariant(params["variant"].GetInt());
}
if (m_job != job) {
m_jobs++;
m_job = std::move(job);
return true;
}
if (m_jobs == 0) { // https://github.com/xmrig/xmrig/issues/459
return false;
}
if (!m_quiet) {
LOG_WARN("[%s:%u] duplicate job received, reconnect", m_url.host(), m_url.port());
}
close();
return false;
}
void
SkillInfo::from_json_value(const rapidjson::Value& d)
{
if (d.HasMember("kind") && d["kind"].IsString()) {
kind_ = d["kind"].GetString();
}
if (d.HasMember("apiVersion") && d["apiVersion"].IsString()) {
apiVersion_ = d["apiVersion"].GetString();
}
if (d.HasMember("name") && d["name"].IsString()) {
name_ = d["name"].GetString();
}
}
void
BlackboardGraph::from_json_value(const rapidjson::Value& d)
{
if (d.HasMember("kind") && d["kind"].IsString()) {
kind_ = d["kind"].GetString();
}
if (d.HasMember("apiVersion") && d["apiVersion"].IsString()) {
apiVersion_ = d["apiVersion"].GetString();
}
if (d.HasMember("dotgraph") && d["dotgraph"].IsString()) {
dotgraph_ = d["dotgraph"].GetString();
}
}
static bool is_enum_flag(const rapidjson::Value & val)
{
RAPIDJSON_ASSERT(val.HasMember("category"));
RAPIDJSON_ASSERT(val.FindMember("category")->value.IsString());
RAPIDJSON_ASSERT(val.FindMember("category")->value == "enum");
RAPIDJSON_ASSERT(val.HasMember("attr"));
const rapidjson::Value & attrs = val.FindMember("attr")->value;
for (const auto & itr : attrs.GetArray()) {
if (itr == "flag") {
return true;
}
}
return false;
}
bool webserver::initialize(const rapidjson::Value &config)
{
if (!config.HasMember("remotes"))
return false;
if (!config.HasMember("groups"))
return false;
std::vector<std::string> remotes;
std::vector<int> groups;
std::string logfile = "/dev/stderr";
int loglevel = DNET_LOG_INFO;
if (config.HasMember("logfile"))
logfile = config["logfile"].GetString();
if (config.HasMember("loglevel"))
loglevel = config["loglevel"].GetInt();
auto &remotesArray = config["remotes"];
std::transform(remotesArray.Begin(), remotesArray.End(),
std::back_inserter(remotes),
std::bind(&rapidjson::Value::GetString, std::placeholders::_1));
auto &groupsArray = config["groups"];
std::transform(groupsArray.Begin(), groupsArray.End(),
std::back_inserter(groups),
std::bind(&rapidjson::Value::GetInt, std::placeholders::_1));
uint32_t min_writes = groups.size();
if (config.HasMember("min_writes"))
min_writes = config["min_writes"].GetInt();
provider_ = std::make_shared<provider>(remotes,
groups ,
min_writes,
logfile,
loglevel);
on<on_root>("/");
on<on_add_log>("/add_log");
on<on_add_activity>("/add_activity");
on<on_add_log_with_activity>("/add_log_with_activity");
on<on_get_active_users>("/get_active_users");
on<on_get_user_logs>("/get_user_logs");
return true;
}
bool dto_complex::parse( const rapidjson::Value& json )
{
if( json.IsObject() && json.HasMember( key() ) && json[key()].IsObject() )
{
for( auto& child : get_children() )
{
child->set_client( client() );
if( !child->parse( json[key()] ) && !optional() )
{
return false;
}
}
return true;
}
else if( json.IsObject() )
{
for( auto& child : get_children() )
{
child->set_client( client() );
if( !child->parse( json ) && !optional() )
{
return false;
}
}
return true;
}
set_present( false );
return optional();
}
static void convert_struct(rapidjson::Document & doc, rapidjson::Value & val, const std::size_t lvl)
{
RAPIDJSON_ASSERT(val.HasMember("name"));
const char * ename = val.FindMember("name")->value.GetString();
convert_nested_struct(doc, val, std::string(ename), lvl);
convert_struct_by_name(doc, val, std::string("struct ") + std::string(ename), lvl);
}
std::string PersonManager::handleUpdateSpouseScene(const rapidjson::Value& json)
{
std::string operation = json["OPERATION"].GetString();
if (json.HasMember("SCENE") == false)
{
return "missing SCENE";
}
std::string scene = json["SCENE"].GetString();
if (scene == mSpouseScene.getValue())
return SUCC;
//if spouse's scene is in conflict with spouse's action, change spouse's action to STAND
if (scene == SCENE_LIVINGROOM)
{
if (mSpouseAction.getAction() == Person::Action::SLEEP)
mSpouseAction.setAction(Person::Action::STAND);
}
else if (scene == SCENE_BEDROOM)
{
if (mSpouseAction.getAction() == Person::Action::EAT
|| mSpouseAction.getAction() == Person::Action::READ)
mSpouseAction.setAction(Person::Action::STAND);
}
mSpouseScene.setValue(scene);
mSpouseScene.notify();
return SUCC;
}
std::string PersonManager::handleExpandPersonMenu(const rapidjson::Value& json)
{
std::string operation = json["OPERATION"].GetString();
if (json.HasMember("WHO") == false)
{
return "missing WHO";
}
std::string who = json["WHO"].GetString();
if (who != "me" && who != "spouse")
{
return "invalid value of WHO";
}
if (who == "me")
{
mExpandMeMenu.notify();
}
else
{
mExpandSpouseMenu.notify();
}
return SUCC;
}
BBOX rapidjson_get_bbox(const rapidjson::Value& v, std::string field,
BBOX default_value)
{
const char* f = field.c_str();
BBOX ret = default_value;
if ( v.HasMember(f) && v[f].IsArray() )
{
int index = 0;
int* p[4] = {&ret.first.first, &ret.first.second,
&ret.second.first, &ret.second.second};
for (rapidjson::SizeType i = 0; i < v[f].Size(); i++){
const rapidjson::Value& v_json = v[f][i];
for (rapidjson::SizeType j = 0; j < v_json.Size(); j++){
const rapidjson::Value& vv_json = v_json[j];
if ( vv_json.IsInt() ){
*p[index] = vv_json.GetInt();
}
index++;
}
}
}
return ret;
}
void load(glm::uvec2 &value, rapidjson::Value &json, rapidjson::Document &document)
{
if (!json.HasMember("uvec2"))
return;
value.x = json["uvec2"][(rapidjson::SizeType)(0)].GetUint();
value.y = json["uvec2"][(rapidjson::SizeType)(1)].GetUint();
}
NS_CC_BEGIN
void getChildMap(std::map<int, std::vector<int> >& map, SkinData* skinData, const rapidjson::Value& val)
{
if (!skinData)
return;
if (!val.HasMember("children"))
return;
std::string parent_name = val["id"].GetString();
int parent_name_index = skinData->getBoneNameIndex(parent_name);
const rapidjson::Value& children = val["children"];
for (rapidjson::SizeType i = 0; i < children.Size(); i++)
{
const rapidjson::Value& child = children[i];
std::string child_name = child["id"].GetString();
int child_name_index = skinData->getBoneNameIndex(child_name);
if (child_name_index >= 0)
{
map[parent_name_index].push_back(child_name_index);
getChildMap(map, skinData, child);
}
}
}
std::shared_ptr<VolumeIntegrator> VolumeIntegrator::Load(const rapidjson::Value& value) {
std::shared_ptr<VolumeIntegrator> integrator;
std::string type;
if (value.IsString()) {
type = value.GetString();
} else if (value.IsObject() && value.HasMember("type")) {
type = value["type"].GetString();
} else {
std::cerr << "VolumeIntegrator error: no type given" << std::endl;
return integrator;
}
std::transform(type.begin(), type.end(), type.begin(), ::tolower);
if (type == "singlescattering") {
integrator = SingleScatteringIntegrator::Load(value);
} else {
std::cerr << "VolumeIntegrator error: unknown type \"" << type << "\"" << std::endl;
return integrator;
}
return integrator;
}
std::string PersonManager::handlePerformAction(const rapidjson::Value& json)
{
std::string operation = json["OPERATION"].GetString();
if (json.HasMember("WHO") == false || json.HasMember("ACTION") == false)
{
return "missing WHO or ACTION";
}
std::string who = json["WHO"].GetString();
std::string actionName = json["ACTION"].GetString();
if (who != "me" && who != "spouse")
{
return "invalid value of WHO";
}
Person::Action action = Person::parseProtocolNameToAction(actionName);
if (action == Person::Action::INVALID_ACTION)
{
return "invalid value of ACTION";
}
if (Person::isCoupleAction(action))
{
mCoupleAction.addAction((who == "me"), action);
mCoupleAction.notify();
return SUCC;
}
if (who == "me")
{
if (action == mMeAction.getAction())
return SUCC;
mMeAction.setAction(action);
mMeAction.notify();
}
else
{
if (action == mSpouseAction.getAction())
return SUCC;
mSpouseAction.setAction(action);
mSpouseAction.notify();
}
return SUCC;
}
void GX::AnimationCom::initWithMap(rapidjson::Value& value)
{
if (value.HasMember("filename")&& value.HasMember("animations")&&value["animations"].Size()) {
filename=value["filename"].GetString();
int count=value["animations"].Size();
for (int i=0; i<count; i++) {
rapidjson::Value& entity=value["animations"][i];
if (entity.HasMember("name")) {
AnimationDefinition definition;
definition.name=entity["name"].GetString();
if (entity.HasMember("position")) {
definition.position=cocos2d::PointFromString(entity["position"].GetString());
}
if(entity.HasMember("anchorPoint")){
definition.anchorPoint=cocos2d::PointFromString(entity["anchorPoint"].GetString());
}
if(entity.HasMember("scale")){
definition.scale=cocos2d::PointFromString(entity["scale"].GetString());
}
if(entity.HasMember("localZOrder")){
definition.localZOrder=entity["localZOrder"].GetInt();
}
if(entity.HasMember("loops")){
definition.loops=entity["loops"].GetInt();
}
if(entity.HasMember("autoPlay")){
definition.autoPlay=entity["autoPlay"].GetBool();
}
if(entity.HasMember("delayPerUnit")){
definition.delayPerUnit=(float)entity["delayPerUnit"].GetDouble();
}
animations.insert(std::make_pair(definition.name, definition));
}
}
}
}
void JsonValidator::validateMetaData(rapidjson::Value& metaDocument, QString path) {
QMap<QString, int>::iterator i;
QMap<QString, int> map = JsonValidator::NON_TEMPORAL_TAGS;
for (i = map.begin(); i != map.end(); ++i) {
if (!metaDocument.HasMember(i.key().toStdString().c_str())) {
throw JsonReaderParseException(
path,
QString("Error in the meta header: The tag \"%1\" does not exist.").arg(i.key())
);
}
if (JsonValidator::getType(metaDocument[i.key().toStdString().c_str()]) != i.value()) {
throw JsonReaderParseException(
path,
QString("Error in the meta header: The tag \"%1\" should be of type %2 but is "
"of type %3.").arg(i.key(), JsonValidator::TYPE_NAMES.value(i.value()),
JsonValidator::TYPE_NAMES.value(
JsonValidator::getType(metaDocument[i.key().toStdString().c_str()])
))
);
}
}
// This check can only be done this late since we only know by now that the temporal tag exists
if (metaDocument["temporal"].GetBool()) {
if (!metaDocument.HasMember("timeResolution")) {
throw JsonReaderParseException(
path,
QString("Error in the meta header: The tag \"timeResolution\" does not exist "
"but is mandatory for temporal data.")
);
}
if (JsonValidator::getType(metaDocument["timeResolution"]) != kJsonTypeInteger) {
throw JsonReaderParseException(
path,
QString("Error in the meta header: The tag \"timeResolution\" should be of type "
"Integer but is of type %1.")
.arg(JsonValidator::TYPE_NAMES.value(
JsonValidator::getType(metaDocument[i.key().toStdString().c_str()])
))
);
}
}
}
bool contains_valid_tag(const rapidjson::Value& node, const JsonTag & tag)
{
if (!node.HasMember(tag.name) ||
node[tag.name].GetType() != tag.type)
return false;
return true;
}
