games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-10-31 00:07:39 +02:00
Code Issues Releases Activity

Change JsonType to enum class (#393)

Browse Source 
Change enum JsonType to enum class JsonType
This commit is contained in:
Michał Kalinowski
2017-11-26 22:18:18 +01:00
committed by Alexander Shishkin
parent 6df536bb31
commit 26a222ac62
31 changed files with 200 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
AI/VCAI/VCAI.cpp
View File

@@ -2851,7 +2851,7 @@ void VCAI::requestSent(const CPackForServer *pack, int requestID)
std::string VCAI::getBattleAIName() const
{
if(settings["server"]["enemyAI"].getType() == JsonNode::DATA_STRING)
if(settings["server"]["enemyAI"].getType() == JsonNode::JsonType::DATA_STRING)
return settings["server"]["enemyAI"].String();
else
return "BattleAI";

2
CCallback.cpp
View File

@@ -45,7 +45,7 @@ bool CCallback::moveHero(const CGHeroInstance *h, int3 dst, bool transit)
int CCallback::selectionMade(int selection, QueryID queryID)
{
JsonNode reply(JsonNode::DATA_INTEGER);
JsonNode reply(JsonNode::JsonType::DATA_INTEGER);
reply.Integer() = selection;
return sendQueryReply(reply, queryID);
}

4
client/CMT.cpp
View File

@@ -692,11 +692,11 @@ void processCommand(const std::string &message)
auto extractVector = [=](const std::vector<std::string> & source, const std::string & name)
{
JsonNode data(JsonNode::DATA_VECTOR);
JsonNode data(JsonNode::JsonType::DATA_VECTOR);
size_t index = 0;
for(auto & line : source)
{
JsonNode lineNode(JsonNode::DATA_STRUCT);
JsonNode lineNode(JsonNode::JsonType::DATA_STRUCT);
lineNode["text"].String() = line;
lineNode["index"].Integer() = index++;
data.Vector().push_back(lineNode);

4
client/CPlayerInterface.cpp
View File

@@ -1207,14 +1207,14 @@ void CPlayerInterface::showMapObjectSelectDialog(QueryID askID, const Component
auto selectCallback = [=](int selection)
{
JsonNode reply(JsonNode::DATA_INTEGER);
JsonNode reply(JsonNode::JsonType::DATA_INTEGER);
reply.Integer() = selection;
cb->sendQueryReply(reply, askID);
};
auto cancelCallback = [=]()
{
JsonNode reply(JsonNode::DATA_NULL);
JsonNode reply(JsonNode::JsonType::DATA_NULL);
cb->sendQueryReply(reply, askID);
};

10
client/gui/CAnimation.cpp
View File

@@ -1356,7 +1356,7 @@ bool CAnimation::loadFrame(size_t frame, size_t group)
}
//try to get image from def
if(source[group][frame].getType() == JsonNode::DATA_NULL)
if(source[group][frame].getType() == JsonNode::JsonType::DATA_NULL)
{
if(defFile)
{
@@ -1411,7 +1411,7 @@ void CAnimation::initFromJson(const JsonNode & config)
std::string basepath;
basepath = config["basepath"].String();
JsonNode base(JsonNode::DATA_STRUCT);
JsonNode base(JsonNode::JsonType::DATA_STRUCT);
base["margins"] = config["margins"];
base["width"] = config["width"];
base["height"] = config["height"];
@@ -1423,7 +1423,7 @@ void CAnimation::initFromJson(const JsonNode & config)
for(const JsonNode & frame : group["frames"].Vector())
{
JsonNode toAdd(JsonNode::DATA_STRUCT);
JsonNode toAdd(JsonNode::JsonType::DATA_STRUCT);
JsonUtils::inherit(toAdd, base);
toAdd["file"].String() = basepath + frame.String();
source[groupID].push_back(toAdd);
@@ -1438,7 +1438,7 @@ void CAnimation::initFromJson(const JsonNode & config)
if (source[group].size() <= frame)
source[group].resize(frame+1);
JsonNode toAdd(JsonNode::DATA_STRUCT);
JsonNode toAdd(JsonNode::JsonType::DATA_STRUCT);
JsonUtils::inherit(toAdd, base);
toAdd["file"].String() = basepath + node["file"].String();
source[group][frame] = toAdd;
@@ -1564,7 +1564,7 @@ void CAnimation::duplicateImage(const size_t sourceGroup, const size_t sourceFra
//todo: clone actual loaded Image object
JsonNode clone(source[sourceGroup][sourceFrame]);
if(clone.getType() == JsonNode::DATA_NULL)
if(clone.getType() == JsonNode::JsonType::DATA_NULL)
{
std::string temp = name+":"+boost::lexical_cast<std::string>(sourceGroup)+":"+boost::lexical_cast<std::string>(sourceFrame);
clone["file"].String() = temp;

12
launcher/jsonutils.cpp
View File

@@ -58,12 +58,12 @@ QVariant toVariant(const JsonNode & node)
{
switch (node.getType())
{
break; case JsonNode::DATA_NULL: return QVariant();
break; case JsonNode::DATA_BOOL: return QVariant(node.Bool());
break; case JsonNode::DATA_FLOAT: return QVariant(node.Float());
break; case JsonNode::DATA_STRING: return QVariant(QString::fromUtf8(node.String().c_str()));
break; case JsonNode::DATA_VECTOR: return JsonToList(node.Vector());
break; case JsonNode::DATA_STRUCT: return JsonToMap(node.Struct());
break; case JsonNode::JsonType::DATA_NULL: return QVariant();
break; case JsonNode::JsonType::DATA_BOOL: return QVariant(node.Bool());
break; case JsonNode::JsonType::DATA_FLOAT: return QVariant(node.Float());
break; case JsonNode::JsonType::DATA_STRING: return QVariant(QString::fromUtf8(node.String().c_str()));
break; case JsonNode::JsonType::DATA_VECTOR: return JsonToList(node.Vector());
break; case JsonNode::JsonType::DATA_STRUCT: return JsonToMap(node.Struct());
}
return QVariant();
}

4
lib/CArtHandler.cpp
View File

@@ -337,7 +337,7 @@ CArtifact * CArtHandler::loadFromJson(const JsonNode & node, const std::string &
}
const JsonNode & warMachine = node["warMachine"];
if(warMachine.getType() == JsonNode::DATA_STRING && warMachine.String() != "")
if(warMachine.getType() == JsonNode::JsonType::DATA_STRING && warMachine.String() != "")
{
VLC->modh->identifiers.requestIdentifier("creature", warMachine, [=](si32 id)
{
@@ -396,7 +396,7 @@ void CArtHandler::loadSlots(CArtifact * art, const JsonNode & node)
{
if (!node["slot"].isNull()) //we assume non-hero slots are irrelevant?
{
if (node["slot"].getType() == JsonNode::DATA_STRING)
if (node["slot"].getType() == JsonNode::JsonType::DATA_STRING)
addSlot(art, node["slot"].String());
else
{

4
lib/CCreatureHandler.cpp
View File

@@ -735,7 +735,7 @@ void CCreatureHandler::loadCreatureJson(CCreature * creature, const JsonNode & c
creature->animDefName = config["graphics"]["animation"].String();
//FIXME: MOD COMPATIBILITY
if (config["abilities"].getType() == JsonNode::DATA_STRUCT)
if (config["abilities"].getType() == JsonNode::JsonType::DATA_STRUCT)
{
for(auto &ability : config["abilities"].Struct())
{
@@ -752,7 +752,7 @@ void CCreatureHandler::loadCreatureJson(CCreature * creature, const JsonNode & c
{
for(const JsonNode &ability : config["abilities"].Vector())
{
if (ability.getType() == JsonNode::DATA_VECTOR)
if (ability.getType() == JsonNode::JsonType::DATA_VECTOR)
{
assert(0); // should be unused now
AddAbility(creature, ability.Vector()); // used only for H3 creatures

2
lib/CCreatureSet.cpp
View File

@@ -501,7 +501,7 @@ void CCreatureSet::serializeJson(JsonSerializeFormat & handler, const std::strin
if(fixedSize)
vstd::amax(sz, fixedSize.get());
a.resize(sz, JsonNode::DATA_STRUCT);
a.resize(sz, JsonNode::JsonType::DATA_STRUCT);
for(const auto & p : stacks)
{

4
lib/CModHandler.cpp
View File

@@ -583,11 +583,11 @@ void CModInfo::loadLocalData(const JsonNode & data)
bool validated = false;
enabled = true;
checksum = 0;
if (data.getType() == JsonNode::DATA_BOOL)
if (data.getType() == JsonNode::JsonType::DATA_BOOL)
{
enabled = data.Bool();
}
if (data.getType() == JsonNode::DATA_STRUCT)
if (data.getType() == JsonNode::JsonType::DATA_STRUCT)
{
enabled = data["active"].Bool();
validated = data["validated"].Bool();

2
lib/CSkillHandler.cpp
View File

@@ -128,7 +128,7 @@ std::vector<JsonNode> CSkillHandler::loadLegacyData(size_t dataSize)
std::vector<JsonNode> legacyData;
for(int id = 0; id < GameConstants::SKILL_QUANTITY; id++)
{
JsonNode skillNode(JsonNode::DATA_STRUCT);
JsonNode skillNode(JsonNode::JsonType::DATA_STRUCT);
skillNode["name"].String() = skillNames[id];
for(int level = 1; level < NSecondarySkill::levels.size(); level++)
{

4
lib/CTownHandler.cpp
View File

@@ -354,7 +354,7 @@ void CTownHandler::loadBuilding(CTown * town, const std::string & stringID, cons
ret->mode = CBuilding::BUILD_NORMAL;
{
if(source["mode"].getType() == JsonNode::DATA_STRING)
if(source["mode"].getType() == JsonNode::JsonType::DATA_STRING)
{
auto rawMode = vstd::find_pos(MODES, source["mode"].String());
if(rawMode > 0)
@@ -563,7 +563,7 @@ void CTownHandler::loadSiegeScreen(CTown &town, const JsonNode & source)
static void readIcon(JsonNode source, std::string & small, std::string & large)
{
if (source.getType() == JsonNode::DATA_STRUCT) // don't crash on old format
if (source.getType() == JsonNode::JsonType::DATA_STRUCT) // don't crash on old format
{
small = source["small"].String();
large = source["large"].String();

62
lib/JsonDetail.cpp
View File

@@ -96,31 +96,31 @@ void JsonWriter::writeNode(const JsonNode &node)
{
switch(node.getType())
{
break; case JsonNode::DATA_NULL:
break; case JsonNode::JsonType::DATA_NULL:
out << "null";
break; case JsonNode::DATA_BOOL:
break; case JsonNode::JsonType::DATA_BOOL:
if (node.Bool())
out << "true";
else
out << "false";
break; case JsonNode::DATA_FLOAT:
break; case JsonNode::JsonType::DATA_FLOAT:
out << node.Float();
break; case JsonNode::DATA_STRING:
break; case JsonNode::JsonType::DATA_STRING:
writeString(node.String());
break; case JsonNode::DATA_VECTOR:
break; case JsonNode::JsonType::DATA_VECTOR:
out << "[" << "\n";
writeContainer(node.Vector().begin(), node.Vector().end());
out << prefix << "]";
break; case JsonNode::DATA_STRUCT:
break; case JsonNode::JsonType::DATA_STRUCT:
out << "{" << "\n";
writeContainer(node.Struct().begin(), node.Struct().end());
out << prefix << "}";
break; case JsonNode::DATA_INTEGER:
break; case JsonNode::JsonType::DATA_INTEGER:
out << node.Integer();
}
}
@@ -306,7 +306,7 @@ bool JsonParser::extractString(JsonNode &node)
if (!extractString(str))
return false;
node.setType(JsonNode::DATA_STRING);
node.setType(JsonNode::JsonType::DATA_STRING);
node.String() = str;
return true;
}
@@ -354,7 +354,7 @@ bool JsonParser::extractFalse(JsonNode &node)
bool JsonParser::extractStruct(JsonNode &node)
{
node.setType(JsonNode::DATA_STRUCT);
node.setType(JsonNode::JsonType::DATA_STRUCT);
pos++;
if (!extractWhitespace())
@@ -396,7 +396,7 @@ bool JsonParser::extractStruct(JsonNode &node)
bool JsonParser::extractArray(JsonNode &node)
{
pos++;
node.setType(JsonNode::DATA_VECTOR);
node.setType(JsonNode::JsonType::DATA_VECTOR);
if (!extractWhitespace())
return false;
@@ -536,7 +536,7 @@ bool JsonParser::extractFloat(JsonNode &node)
if(negative)
result = -result;
node.setType(JsonNode::DATA_FLOAT);
node.setType(JsonNode::JsonType::DATA_FLOAT);
node.Float() = result;
}
else
@@ -544,7 +544,7 @@ bool JsonParser::extractFloat(JsonNode &node)
if(negative)
integerPart = -integerPart;
node.setType(JsonNode::DATA_INTEGER);
node.setType(JsonNode::JsonType::DATA_INTEGER);
node.Integer() = integerPart;
}
@@ -569,12 +569,12 @@ bool JsonParser::error(const std::string &message, bool warning)
static const std::unordered_map<std::string, JsonNode::JsonType> stringToType =
{
{"null", JsonNode::DATA_NULL},
{"boolean", JsonNode::DATA_BOOL},
{"number", JsonNode::DATA_FLOAT},
{"string", JsonNode::DATA_STRING},
{"array", JsonNode::DATA_VECTOR},
{"object", JsonNode::DATA_STRUCT}
{"null", JsonNode::JsonType::DATA_NULL},
{"boolean", JsonNode::JsonType::DATA_BOOL},
{"number", JsonNode::JsonType::DATA_FLOAT},
{"string", JsonNode::JsonType::DATA_STRING},
{"array", JsonNode::JsonType::DATA_VECTOR},
{"object", JsonNode::JsonType::DATA_STRUCT}
};
namespace
@@ -670,10 +670,10 @@ namespace
JsonNode::JsonType type = it->second;
//FIXME: hack for integer values
if(data.isNumber() && type == JsonNode::DATA_FLOAT)
if(data.isNumber() && type == JsonNode::JsonType::DATA_FLOAT)
return "";
if(type != data.getType() && data.getType() != JsonNode::DATA_NULL)
if(type != data.getType() && data.getType() != JsonNode::JsonType::DATA_NULL)
return validator.makeErrorMessage("Type mismatch! Expected " + schema.String());
return "";
}
@@ -785,7 +785,7 @@ namespace
std::string errors;
for (size_t i=0; i<data.Vector().size(); i++)
{
if (schema.getType() == JsonNode::DATA_VECTOR)
if (schema.getType() == JsonNode::JsonType::DATA_VECTOR)
{
if (schema.Vector().size() > i)
errors += itemEntryCheck(validator, data.Vector(), schema.Vector()[i], i);
@@ -803,12 +803,12 @@ namespace
std::string errors;
// "items" is struct or empty (defaults to empty struct) - validation always successful
const JsonNode & items = baseSchema["items"];
if (items.getType() != JsonNode::DATA_VECTOR)
if (items.getType() != JsonNode::JsonType::DATA_VECTOR)
return "";
for (size_t i=items.Vector().size(); i<data.Vector().size(); i++)
{
if (schema.getType() == JsonNode::DATA_STRUCT)
if (schema.getType() == JsonNode::JsonType::DATA_STRUCT)
errors += itemEntryCheck(validator, data.Vector(), schema, i);
else if (!schema.isNull() && schema.Bool() == false)
errors += validator.makeErrorMessage("Unknown entry found");
@@ -896,7 +896,7 @@ namespace
{
if (!data[deps.first].isNull())
{
if (deps.second.getType() == JsonNode::DATA_VECTOR)
if (deps.second.getType() == JsonNode::JsonType::DATA_VECTOR)
{
JsonVector depList = deps.second.Vector();
for(auto & depEntry : depList)
@@ -947,7 +947,7 @@ namespace
if (baseSchema["properties"].Struct().count(entry.first) == 0)
{
// try generic additionalItems schema
if (schema.getType() == JsonNode::DATA_STRUCT)
if (schema.getType() == JsonNode::JsonType::DATA_STRUCT)
errors += propertyEntryCheck(validator, entry.second, schema, entry.first);
// or, additionalItems field can be bool which indicates if such items are allowed
@@ -1134,7 +1134,7 @@ namespace Validation
for(const JsonNode &path : currentPath)
{
errors += "/";
if (path.getType() == JsonNode::DATA_STRING)
if (path.getType() == JsonNode::JsonType::DATA_STRING)
errors += path.String();
else
errors += boost::lexical_cast<std::string>(static_cast<unsigned>(path.Float()));
@@ -1187,12 +1187,12 @@ namespace Validation
switch (type)
{
case JsonNode::DATA_FLOAT:
case JsonNode::DATA_INTEGER:
case JsonNode::JsonType::DATA_FLOAT:
case JsonNode::JsonType::DATA_INTEGER:
return numberFields;
case JsonNode::DATA_STRING: return stringFields;
case JsonNode::DATA_VECTOR: return vectorFields;
case JsonNode::DATA_STRUCT: return structFields;
case JsonNode::JsonType::DATA_STRING: return stringFields;
case JsonNode::JsonType::DATA_VECTOR: return vectorFields;
case JsonNode::JsonType::DATA_STRUCT: return structFields;
default: return commonFields;
}
}

158
lib/JsonNode.cpp
View File

@@ -28,20 +28,20 @@ class CModHandler;
static const JsonNode nullNode;
JsonNode::JsonNode(JsonType Type):
type(DATA_NULL)
type(JsonType::DATA_NULL)
{
setType(Type);
}
JsonNode::JsonNode(const char *data, size_t datasize):
type(DATA_NULL)
type(JsonType::DATA_NULL)
{
JsonParser parser(data, datasize);
*this = parser.parse("<unknown>");
}
JsonNode::JsonNode(ResourceID && fileURI):
type(DATA_NULL)
type(JsonType::DATA_NULL)
{
auto file = CResourceHandler::get()->load(fileURI)->readAll();
@@ -50,7 +50,7 @@ JsonNode::JsonNode(ResourceID && fileURI):
}
JsonNode::JsonNode(const ResourceID & fileURI):
type(DATA_NULL)
type(JsonType::DATA_NULL)
{
auto file = CResourceHandler::get()->load(fileURI)->readAll();
@@ -59,7 +59,7 @@ JsonNode::JsonNode(const ResourceID & fileURI):
}
JsonNode::JsonNode(ResourceID && fileURI, bool &isValidSyntax):
type(DATA_NULL)
type(JsonType::DATA_NULL)
{
auto file = CResourceHandler::get()->load(fileURI)->readAll();
@@ -69,25 +69,25 @@ JsonNode::JsonNode(ResourceID && fileURI, bool &isValidSyntax):
}
JsonNode::JsonNode(const JsonNode &copy):
type(DATA_NULL),
type(JsonType::DATA_NULL),
meta(copy.meta)
{
setType(copy.getType());
switch(type)
{
break; case DATA_NULL:
break; case DATA_BOOL: Bool() = copy.Bool();
break; case DATA_FLOAT: Float() = copy.Float();
break; case DATA_STRING: String() = copy.String();
break; case DATA_VECTOR: Vector() = copy.Vector();
break; case DATA_STRUCT: Struct() = copy.Struct();
break; case DATA_INTEGER:Integer() = copy.Integer();
break; case JsonType::DATA_NULL:
break; case JsonType::DATA_BOOL: Bool() = copy.Bool();
break; case JsonType::DATA_FLOAT: Float() = copy.Float();
break; case JsonType::DATA_STRING: String() = copy.String();
break; case JsonType::DATA_VECTOR: Vector() = copy.Vector();
break; case JsonType::DATA_STRUCT: Struct() = copy.Struct();
break; case JsonType::DATA_INTEGER:Integer() = copy.Integer();
}
}
JsonNode::~JsonNode()
{
setType(DATA_NULL);
setType(JsonType::DATA_NULL);
}
void JsonNode::swap(JsonNode &b)
@@ -110,13 +110,13 @@ bool JsonNode::operator == (const JsonNode &other) const
{
switch(type)
{
case DATA_NULL: return true;
case DATA_BOOL: return Bool() == other.Bool();
case DATA_FLOAT: return Float() == other.Float();
case DATA_STRING: return String() == other.String();
case DATA_VECTOR: return Vector() == other.Vector();
case DATA_STRUCT: return Struct() == other.Struct();
case DATA_INTEGER:return Integer()== other.Integer();
case JsonType::DATA_NULL: return true;
case JsonType::DATA_BOOL: return Bool() == other.Bool();
case JsonType::DATA_FLOAT: return Float() == other.Float();
case JsonType::DATA_STRING: return String() == other.String();
case JsonType::DATA_VECTOR: return Vector() == other.Vector();
case JsonType::DATA_STRUCT: return Struct() == other.Struct();
case JsonType::DATA_INTEGER:return Integer()== other.Integer();
}
}
return false;
@@ -139,14 +139,14 @@ void JsonNode::setMeta(std::string metadata, bool recursive)
{
switch (type)
{
break; case DATA_VECTOR:
break; case JsonType::DATA_VECTOR:
{
for(auto & node : Vector())
{
node.setMeta(metadata);
}
}
break; case DATA_STRUCT:
break; case JsonType::DATA_STRUCT:
{
for(auto & node : Struct())
{
@@ -163,14 +163,14 @@ void JsonNode::setType(JsonType Type)
return;
//float<->int conversion
if(type == DATA_FLOAT && Type == DATA_INTEGER)
if(type == JsonType::DATA_FLOAT && Type == JsonType::DATA_INTEGER)
{
si64 converted = data.Float;
type = Type;
data.Integer = converted;
return;
}
else if(type == DATA_INTEGER && Type == DATA_FLOAT)
else if(type == JsonType::DATA_INTEGER && Type == JsonType::DATA_FLOAT)
{
double converted = data.Integer;
type = Type;
@@ -179,14 +179,14 @@ void JsonNode::setType(JsonType Type)
}
//Reset node to nullptr
if (Type != DATA_NULL)
setType(DATA_NULL);
if (Type != JsonType::DATA_NULL)
setType(JsonType::DATA_NULL);
switch (type)
{
break; case DATA_STRING: delete data.String;
break; case DATA_VECTOR: delete data.Vector;
break; case DATA_STRUCT: delete data.Struct;
break; case JsonType::DATA_STRING: delete data.String;
break; case JsonType::DATA_VECTOR: delete data.Vector;
break; case JsonType::DATA_STRUCT: delete data.Struct;
break; default:
break;
}
@@ -194,124 +194,124 @@ void JsonNode::setType(JsonType Type)
type = Type;
switch(type)
{
break; case DATA_NULL:
break; case DATA_BOOL: data.Bool = false;
break; case DATA_FLOAT: data.Float = 0;
break; case DATA_STRING: data.String = new std::string();
break; case DATA_VECTOR: data.Vector = new JsonVector();
break; case DATA_STRUCT: data.Struct = new JsonMap();
break; case DATA_INTEGER: data.Integer = 0;
break; case JsonType::DATA_NULL:
break; case JsonType::DATA_BOOL: data.Bool = false;
break; case JsonType::DATA_FLOAT: data.Float = 0;
break; case JsonType::DATA_STRING: data.String = new std::string();
break; case JsonType::DATA_VECTOR: data.Vector = new JsonVector();
break; case JsonType::DATA_STRUCT: data.Struct = new JsonMap();
break; case JsonType::DATA_INTEGER: data.Integer = 0;
}
}
bool JsonNode::isNull() const
{
return type == DATA_NULL;
return type == JsonType::DATA_NULL;
}
bool JsonNode::isNumber() const
{
return type == DATA_INTEGER || type == DATA_FLOAT;
return type == JsonType::DATA_INTEGER || type == JsonType::DATA_FLOAT;
}
void JsonNode::clear()
{
setType(DATA_NULL);
setType(JsonType::DATA_NULL);
}
bool & JsonNode::Bool()
{
setType(DATA_BOOL);
setType(JsonType::DATA_BOOL);
return data.Bool;
}
double & JsonNode::Float()
{
setType(DATA_FLOAT);
setType(JsonType::DATA_FLOAT);
return data.Float;
}
si64 & JsonNode::Integer()
{
setType(DATA_INTEGER);
setType(JsonType::DATA_INTEGER);
return data.Integer;
}
std::string & JsonNode::String()
{
setType(DATA_STRING);
setType(JsonType::DATA_STRING);
return *data.String;
}
JsonVector & JsonNode::Vector()
{
setType(DATA_VECTOR);
setType(JsonType::DATA_VECTOR);
return *data.Vector;
}
JsonMap & JsonNode::Struct()
{
setType(DATA_STRUCT);
setType(JsonType::DATA_STRUCT);
return *data.Struct;
}
const bool boolDefault = false;
bool JsonNode::Bool() const
{
if (type == DATA_NULL)
if (type == JsonType::DATA_NULL)
return boolDefault;
assert(type == DATA_BOOL);
assert(type == JsonType::DATA_BOOL);
return data.Bool;
}
const double floatDefault = 0;
double JsonNode::Float() const
{
if(type == DATA_NULL)
if(type == JsonType::DATA_NULL)
return floatDefault;
else if(type == DATA_INTEGER)
else if(type == JsonType::DATA_INTEGER)
return data.Integer;
assert(type == DATA_FLOAT);
assert(type == JsonType::DATA_FLOAT);
return data.Float;
}
const si64 integetDefault = 0;
si64 JsonNode::Integer() const
{
if(type == DATA_NULL)
if(type == JsonType::DATA_NULL)
return integetDefault;
else if(type == DATA_FLOAT)
else if(type == JsonType::DATA_FLOAT)
return data.Float;
assert(type == DATA_INTEGER);
assert(type == JsonType::DATA_INTEGER);
return data.Integer;
}
const std::string stringDefault = std::string();
const std::string & JsonNode::String() const
{
if (type == DATA_NULL)
if (type == JsonType::DATA_NULL)
return stringDefault;
assert(type == DATA_STRING);
assert(type == JsonType::DATA_STRING);
return *data.String;
}
const JsonVector vectorDefault = JsonVector();
const JsonVector & JsonNode::Vector() const
{
if (type == DATA_NULL)
if (type == JsonType::DATA_NULL)
return vectorDefault;
assert(type == DATA_VECTOR);
assert(type == JsonType::DATA_VECTOR);
return *data.Vector;
}
const JsonMap mapDefault = JsonMap();
const JsonMap & JsonNode::Struct() const
{
if (type == DATA_NULL)
if (type == JsonType::DATA_NULL)
return mapDefault;
assert(type == DATA_STRUCT);
assert(type == JsonType::DATA_STRUCT);
return *data.Struct;
}
@@ -341,7 +341,7 @@ Node & resolvePointer(Node & in, const std::string & pointer)
std::string entry = pointer.substr(1, splitPos -1);
std::string remainer = splitPos == std::string::npos ? "" : pointer.substr(splitPos);
if (in.getType() == JsonNode::DATA_VECTOR)
if (in.getType() == JsonNode::JsonType::DATA_VECTOR)
{
if (entry.find_first_not_of("0123456789") != std::string::npos) // non-numbers in string
throw std::runtime_error("Invalid Json pointer");
@@ -432,13 +432,13 @@ void JsonUtils::resolveIdentifier(si32 &var, const JsonNode &node, std::string n
{
switch (value.getType())
{
case JsonNode::DATA_INTEGER:
case JsonNode::JsonType::DATA_INTEGER:
var = value.Integer();
break;
case JsonNode::DATA_FLOAT:
case JsonNode::JsonType::DATA_FLOAT:
var = value.Float();
break;
case JsonNode::DATA_STRING:
case JsonNode::JsonType::DATA_STRING:
VLC->modh->identifiers.requestIdentifier(value, [&](si32 identifier)
{
var = identifier;
@@ -454,13 +454,13 @@ void JsonUtils::resolveIdentifier(const JsonNode &node, si32 &var)
{
switch (node.getType())
{
case JsonNode::DATA_INTEGER:
case JsonNode::JsonType::DATA_INTEGER:
var = node.Integer();
break;
case JsonNode::DATA_FLOAT:
case JsonNode::JsonType::DATA_FLOAT:
var = node.Float();
break;
case JsonNode::DATA_STRING:
case JsonNode::JsonType::DATA_STRING:
VLC->modh->identifiers.requestIdentifier(node, [&](si32 identifier)
{
var = identifier;
@@ -519,10 +519,10 @@ bool JsonUtils::parseBonus(const JsonNode &ability, Bonus *b)
{
switch (value->getType())
{
case JsonNode::DATA_STRING:
case JsonNode::JsonType::DATA_STRING:
b->duration = parseByMap(bonusDurationMap, value, "duration type ");
break;
case JsonNode::DATA_VECTOR:
case JsonNode::JsonType::DATA_VECTOR:
{
ui16 dur = 0;
for (const JsonNode & d : value->Vector())
@@ -548,10 +548,10 @@ bool JsonUtils::parseBonus(const JsonNode &ability, Bonus *b)
{
switch (limiter.getType())
{
case JsonNode::DATA_STRING: //pre-defined limiters
case JsonNode::JsonType::DATA_STRING: //pre-defined limiters
b->limiter = parseByMap(bonusLimiterMap, &limiter, "limiter type ");
break;
case JsonNode::DATA_STRUCT: //customizable limiters
case JsonNode::JsonType::DATA_STRUCT: //customizable limiters
{
std::shared_ptr<ILimiter> l;
if (limiter["type"].String() == "CREATURE_TYPE_LIMITER")
@@ -778,7 +778,7 @@ const JsonNode & JsonUtils::getSchema(std::string URI)
void JsonUtils::merge(JsonNode & dest, JsonNode & source)
{
if (dest.getType() == JsonNode::DATA_NULL)
if (dest.getType() == JsonNode::JsonType::DATA_NULL)
{
std::swap(dest, source);
return;
@@ -786,21 +786,21 @@ void JsonUtils::merge(JsonNode & dest, JsonNode & source)
switch (source.getType())
{
case JsonNode::DATA_NULL:
case JsonNode::JsonType::DATA_NULL:
{
dest.clear();
break;
}
case JsonNode::DATA_BOOL:
case JsonNode::DATA_FLOAT:
case JsonNode::DATA_INTEGER:
case JsonNode::DATA_STRING:
case JsonNode::DATA_VECTOR:
case JsonNode::JsonType::DATA_BOOL:
case JsonNode::JsonType::DATA_FLOAT:
case JsonNode::JsonType::DATA_INTEGER:
case JsonNode::JsonType::DATA_STRING:
case JsonNode::JsonType::DATA_VECTOR:
{
std::swap(dest, source);
break;
}
case JsonNode::DATA_STRUCT:
case JsonNode::JsonType::DATA_STRUCT:
{
//recursively merge all entries from struct
for(auto & node : source.Struct())

18
lib/JsonNode.h
View File

@@ -19,7 +19,7 @@ class ResourceID;
class DLL_LINKAGE JsonNode
{
public:
enum JsonType
enum class JsonType
{
DATA_NULL,
DATA_BOOL,
@@ -49,7 +49,7 @@ public:
std::string meta;
//Create empty node
JsonNode(JsonType Type = DATA_NULL);
JsonNode(JsonType Type = JsonType::DATA_NULL);
//Create tree from Json-formatted input
explicit JsonNode(const char * data, size_t datasize);
//Create tree from JSON file
@@ -117,16 +117,16 @@ public:
h & meta;
h & type;
switch (type) {
break; case DATA_NULL:
break; case DATA_BOOL: h & data.Bool;
break; case DATA_FLOAT: h & data.Float;
break; case DATA_STRING: h & data.String;
break; case DATA_VECTOR: h & data.Vector;
break; case DATA_STRUCT: h & data.Struct;
break; case JsonType::DATA_NULL:
break; case JsonType::DATA_BOOL: h & data.Bool;
break; case JsonType::DATA_FLOAT: h & data.Float;
break; case JsonType::DATA_STRING: h & data.String;
break; case JsonType::DATA_VECTOR: h & data.Vector;
break; case JsonType::DATA_STRUCT: h & data.Struct;
}
if(version >= 770)
{
if(type == DATA_INTEGER)
if(type == JsonType::DATA_INTEGER)
h & data.Integer;
}
}

6
lib/mapObjects/CGHeroInstance.cpp
View File

@@ -1546,7 +1546,7 @@ void CGHeroInstance::serializeCommonOptions(JsonSerializeFormat & handler)
{
const JsonNode & portraitNode = handler.getCurrent()["portrait"];
if(portraitNode.getType() == JsonNode::DATA_STRING)
if(portraitNode.getType() == JsonNode::JsonType::DATA_STRING)
handler.serializeId("portrait", portrait, -1, &VLC->heroh->decodeHero, &VLC->heroh->encodeHero);
else
handler.serializeInt("portrait", portrait, -1);
@@ -1574,7 +1574,7 @@ void CGHeroInstance::serializeCommonOptions(JsonSerializeFormat & handler)
{
auto primarySkills = handler.enterStruct("primarySkills");
if(primarySkills.get().getType() == JsonNode::DATA_STRUCT)
if(primarySkills.get().getType() == JsonNode::JsonType::DATA_STRUCT)
{
for(int i = 0; i < GameConstants::PRIMARY_SKILLS; ++i)
{
@@ -1625,7 +1625,7 @@ void CGHeroInstance::serializeCommonOptions(JsonSerializeFormat & handler)
const JsonNode & skillMap = handler.getCurrent();
secSkills.clear();
if(skillMap.getType() == JsonNode::DATA_NULL)
if(skillMap.getType() == JsonNode::JsonType::DATA_NULL)
{
secSkills.push_back(std::pair<SecondarySkill,ui8>(SecondarySkill::DEFAULT, -1));
}

6
lib/mapObjects/CObjectClassesHandler.cpp
View File

@@ -221,7 +221,7 @@ void CObjectClassesHandler::loadObject(std::string scope, std::string name, cons
void CObjectClassesHandler::loadSubObject(const std::string & identifier, JsonNode config, si32 ID, boost::optional<si32> subID)
{
config.setType(JsonNode::DATA_STRUCT); // ensure that input is not NULL
config.setType(JsonNode::JsonType::DATA_STRUCT); // ensure that input is not NULL
assert(objects.count(ID));
if (subID)
{
@@ -398,7 +398,7 @@ void AObjectTypeHandler::init(const JsonNode & input, boost::optional<std::strin
for (auto entry : input["templates"].Struct())
{
entry.second.setType(JsonNode::DATA_STRUCT);
entry.second.setType(JsonNode::JsonType::DATA_STRUCT);
JsonUtils::inherit(entry.second, base);
ObjectTemplate tmpl;
@@ -449,7 +449,7 @@ void AObjectTypeHandler::addTemplate(const ObjectTemplate & templ)
void AObjectTypeHandler::addTemplate(JsonNode config)
{
config.setType(JsonNode::DATA_STRUCT); // ensure that input is not null
config.setType(JsonNode::JsonType::DATA_STRUCT); // ensure that input is not null
JsonUtils::inherit(config, base);
ObjectTemplate tmpl;
tmpl.id = Obj(type);

4
lib/mapObjects/CommonConstructors.cpp
View File

@@ -198,14 +198,14 @@ void CDwellingInstanceConstructor::configureObject(CGObjectInstance * object, CR
bool guarded = false; //TODO: serialize for sanity
if (guards.getType() == JsonNode::DATA_BOOL) //simple switch
if (guards.getType() == JsonNode::JsonType::DATA_BOOL) //simple switch
{
if (guards.Bool())
{
guarded = true;
}
}
else if (guards.getType() == JsonNode::DATA_VECTOR) //custom guards (eg. Elemental Conflux)
else if (guards.getType() == JsonNode::JsonType::DATA_VECTOR) //custom guards (eg. Elemental Conflux)
{
for (auto & stack : JsonRandom::loadCreatures(guards, rng))
{

10
lib/mapObjects/JsonRandom.cpp
View File

@@ -69,7 +69,7 @@ namespace JsonRandom
ArtifactID loadArtifact(const JsonNode & value, CRandomGenerator & rng)
{
if (value.getType() == JsonNode::DATA_STRING)
if (value.getType() == JsonNode::JsonType::DATA_STRING)
return ArtifactID(VLC->modh->identifiers.getIdentifier("artifact", value).get());
std::set<CArtifact::EartClass> allowedClasses;
@@ -77,13 +77,13 @@ namespace JsonRandom
ui32 minValue = 0;
ui32 maxValue = std::numeric_limits<ui32>::max();
if (value["class"].getType() == JsonNode::DATA_STRING)
if (value["class"].getType() == JsonNode::JsonType::DATA_STRING)
allowedClasses.insert(VLC->arth->stringToClass(value["class"].String()));
else
for (auto & entry : value["class"].Vector())
allowedClasses.insert(VLC->arth->stringToClass(entry.String()));
if (value["slot"].getType() == JsonNode::DATA_STRING)
if (value["slot"].getType() == JsonNode::JsonType::DATA_STRING)
allowedPositions.insert(VLC->arth->stringToSlot(value["class"].String()));
else
for (auto & entry : value["slot"].Vector())
@@ -127,9 +127,9 @@ namespace JsonRandom
SpellID loadSpell(const JsonNode & value, CRandomGenerator & rng, std::vector<SpellID> spells)
{
if (value.getType() == JsonNode::DATA_STRING)
if (value.getType() == JsonNode::JsonType::DATA_STRING)
return SpellID(VLC->modh->identifiers.getIdentifier("spell", value).get());
if (value["type"].getType() == JsonNode::DATA_STRING)
if (value["type"].getType() == JsonNode::JsonType::DATA_STRING)
return SpellID(VLC->modh->identifiers.getIdentifier("spell", value["type"]).get());
vstd::erase_if(spells, [=](SpellID spell)

2
lib/mapObjects/MiscObjects.cpp
View File

@@ -788,7 +788,7 @@ void CGMine::serializeJsonOptions(JsonSerializeFormat & handler)
for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
if(tempOwner.getNum() & 1<<i)
{
JsonNode one(JsonNode::DATA_STRING);
JsonNode one(JsonNode::JsonType::DATA_STRING);
one.String() = GameConstants::RESOURCE_NAMES[i];
node.Vector().push_back(one);
}

4
lib/mapObjects/ObjectTemplate.cpp
View File

@@ -336,7 +336,7 @@ void ObjectTemplate::writeJson(JsonNode & node, const bool withTerrain) const
for(auto type : allowedTerrains)
{
JsonNode value(JsonNode::DATA_STRING);
JsonNode value(JsonNode::JsonType::DATA_STRING);
value.String() = GameConstants::TERRAIN_NAMES[type.num];
data.push_back(value);
}
@@ -379,7 +379,7 @@ void ObjectTemplate::writeJson(JsonNode & node, const bool withTerrain) const
for(size_t i=0; i < height; i++)
{
JsonNode lineNode(JsonNode::DATA_STRING);
JsonNode lineNode(JsonNode::JsonType::DATA_STRING);
std::string & line = lineNode.String();
line.resize(width);

18
lib/mapping/MapFormatJson.cpp
View File

@@ -232,7 +232,7 @@ namespace TriggeredEventsDetail
default:
{
//old format
if (data["type"].getType() == JsonNode::DATA_STRING)
if (data["type"].getType() == JsonNode::JsonType::DATA_STRING)
{
auto identifier = VLC->modh->identifiers.getIdentifier(data["type"]);
if(identifier)
@@ -567,10 +567,10 @@ void CMapFormatJson::readTeams(JsonDeserializer & handler)
auto teams = handler.enterArray("teams");
const JsonNode & src = teams.get();
if(src.getType() != JsonNode::DATA_VECTOR)
if(src.getType() != JsonNode::JsonType::DATA_VECTOR)
{
// No alliances
if(src.getType() != JsonNode::DATA_NULL)
if(src.getType() != JsonNode::JsonType::DATA_NULL)
logGlobal->error("Invalid teams field type");
mapHeader->howManyTeams = 0;
@@ -625,14 +625,14 @@ void CMapFormatJson::writeTeams(JsonSerializer & handler)
JsonNode & dest = teams.get();
//construct output
dest.setType(JsonNode::DATA_VECTOR);
dest.setType(JsonNode::JsonType::DATA_VECTOR);
for(const std::set<PlayerColor> & teamData : teamsData)
{
JsonNode team(JsonNode::DATA_VECTOR);
JsonNode team(JsonNode::JsonType::DATA_VECTOR);
for(const PlayerColor & player : teamData)
{
JsonNode member(JsonNode::DATA_STRING);
JsonNode member(JsonNode::JsonType::DATA_STRING);
member.String() = GameConstants::PLAYER_COLOR_NAMES[player.getNum()];
team.Vector().push_back(std::move(member));
}
@@ -747,7 +747,7 @@ void CMapFormatJson::writeDisposedHeroes(JsonSerializeFormat & handler)
for(int playerNum = 0; playerNum < PlayerColor::PLAYER_LIMIT_I; playerNum++)
if((1 << playerNum) & hero.players)
{
JsonNode player(JsonNode::DATA_STRING);
JsonNode player(JsonNode::JsonType::DATA_STRING);
player.String() = GameConstants::PLAYER_COLOR_NAMES[playerNum];
players.push_back(player);
}
@@ -1347,7 +1347,7 @@ void CMapSaverJson::writeTerrain()
void CMapSaverJson::writeObjects()
{
logGlobal->trace("Saving objects");
JsonNode data(JsonNode::DATA_STRUCT);
JsonNode data(JsonNode::JsonType::DATA_STRUCT);
JsonSerializer handler(mapObjectResolver.get(), data);
@@ -1361,7 +1361,7 @@ void CMapSaverJson::writeObjects()
if(map->grailPos.valid())
{
JsonNode grail(JsonNode::DATA_STRUCT);
JsonNode grail(JsonNode::JsonType::DATA_STRUCT);
grail["type"].String() = "grail";
grail["x"].Float() = map->grailPos.x;

4
lib/rmg/CRmgTemplateStorage.cpp
View File

@@ -137,7 +137,7 @@ void CRmgTemplateStorage::loadObject(std::string scope, std::string name, const
if (!zoneNode["treasure"].isNull())
{
//TODO: parse vector of different treasure settings
if (zoneNode["treasure"].getType() == JsonNode::DATA_STRUCT)
if (zoneNode["treasure"].getType() == JsonNode::JsonType::DATA_STRUCT)
{
auto treasureInfo = zoneNode["treasure"].Struct();
{
@@ -148,7 +148,7 @@ void CRmgTemplateStorage::loadObject(std::string scope, std::string name, const
zone->addTreasureInfo(ti);
}
}
else if (zoneNode["treasure"].getType() == JsonNode::DATA_VECTOR)
else if (zoneNode["treasure"].getType() == JsonNode::JsonType::DATA_VECTOR)
{
for (auto treasureInfo : zoneNode["treasure"].Vector())
{

2
lib/serializer/JsonDeserializer.cpp
View File

@@ -21,7 +21,7 @@ JsonDeserializer::JsonDeserializer(const IInstanceResolver * instanceResolver_,
void JsonDeserializer::serializeInternal(const std::string & fieldName, boost::logic::tribool & value)
{
const JsonNode & data = current->operator[](fieldName);
if(data.getType() != JsonNode::DATA_BOOL)
if(data.getType() != JsonNode::JsonType::DATA_BOOL)
value = boost::logic::indeterminate;
else
value = data.Bool();

8
lib/serializer/JsonSerializeFormat.cpp
View File

@@ -79,7 +79,7 @@ JsonStructSerializer::JsonStructSerializer(JsonSerializeFormat & owner_, const s
optional(false)
{
if(owner.saving)
thisNode->setType(JsonNode::DATA_STRUCT);
thisNode->setType(JsonNode::JsonType::DATA_STRUCT);
}
JsonStructSerializer::JsonStructSerializer(JsonSerializeHelper & parent, const std::string & fieldName):
@@ -87,7 +87,7 @@ JsonStructSerializer::JsonStructSerializer(JsonSerializeHelper & parent, const s
optional(false)
{
if(owner.saving)
thisNode->setType(JsonNode::DATA_STRUCT);
thisNode->setType(JsonNode::JsonType::DATA_STRUCT);
}
JsonStructSerializer::JsonStructSerializer(JsonSerializeFormat & owner_, JsonNode * thisNode_):
@@ -95,7 +95,7 @@ JsonStructSerializer::JsonStructSerializer(JsonSerializeFormat & owner_, JsonNod
optional(false)
{
if(owner.saving)
thisNode->setType(JsonNode::DATA_STRUCT);
thisNode->setType(JsonNode::JsonType::DATA_STRUCT);
}
JsonStructSerializer::~JsonStructSerializer()
@@ -141,7 +141,7 @@ void JsonArraySerializer::resize(const size_t newSize, JsonNode::JsonType type)
resize(newSize);
for(JsonNode & n : thisNode->Vector())
if(n.getType() == JsonNode::DATA_NULL)
if(n.getType() == JsonNode::JsonType::DATA_NULL)
n.setType(type);
}

4
lib/serializer/JsonSerializeFormat.h
View File

@@ -75,13 +75,13 @@ public:
JsonStructSerializer enterStruct(const size_t index);
template <typename Container>
void syncSize(Container & c, JsonNode::JsonType type = JsonNode::DATA_NULL);
void syncSize(Container & c, JsonNode::JsonType type = JsonNode::JsonType::DATA_NULL);
///vector of serializable <-> Json vector of structs
template <typename Element>
void serializeStruct(std::vector<Element> & value)
{
syncSize(value, JsonNode::DATA_STRUCT);
syncSize(value, JsonNode::JsonType::DATA_STRUCT);
for(size_t idx = 0; idx < size(); idx++)
{

4
lib/serializer/JsonSerializer.cpp
View File

@@ -61,7 +61,7 @@ void JsonSerializer::serializeInternal(const std::string & fieldName, std::vecto
for(const si32 rawId : value)
{
JsonNode jsonElement(JsonNode::DATA_STRING);
JsonNode jsonElement(JsonNode::JsonType::DATA_STRING);
jsonElement.String() = encoder(rawId);
data.push_back(std::move(jsonElement));
}
@@ -133,7 +133,7 @@ void JsonSerializer::writeLICPartBuffer(const std::string & fieldName, const std
for(auto & s : buffer)
{
JsonNode val(JsonNode::DATA_STRING);
JsonNode val(JsonNode::JsonType::DATA_STRING);
std::swap(val.String(), s);
target.push_back(std::move(val));
}

2
lib/spells/AdventureSpellMechanics.cpp
View File

@@ -443,7 +443,7 @@ ESpellCastResult TownPortalMechanics::beginCast(const SpellCastEnvironment * env
{
auto queryCallback = [=](const JsonNode & reply) -> void
{
if(reply.getType() == JsonNode::DATA_INTEGER)
if(reply.getType() == JsonNode::JsonType::DATA_INTEGER)
{
ObjectInstanceID townId(reply.Integer());

6
lib/spells/CSpellHandler.cpp
View File

@@ -708,7 +708,7 @@ std::vector<JsonNode> CSpellHandler::loadLegacyData(size_t dataSize)
{
do
{
JsonNode lineNode(JsonNode::DATA_STRUCT);
JsonNode lineNode(JsonNode::JsonType::DATA_STRUCT);
const si32 id = legacyData.size();
@@ -951,9 +951,9 @@ CSpell * CSpellHandler::loadFromJson(const JsonNode & json, const std::string &
{
CSpell::TAnimation newItem;
if(item.getType() == JsonNode::DATA_STRING)
if(item.getType() == JsonNode::JsonType::DATA_STRING)
newItem.resourceName = item.String();
else if(item.getType() == JsonNode::DATA_STRUCT)
else if(item.getType() == JsonNode::JsonType::DATA_STRUCT)
{
newItem.resourceName = item["defName"].String();

2
server/CQuery.cpp
View File

@@ -426,7 +426,7 @@ bool CDialogQuery::blocksPack(const CPack * pack) const
void CDialogQuery::setReply(const JsonNode & reply)
{
if(reply.getType() == JsonNode::DATA_INTEGER)
if(reply.getType() == JsonNode::JsonType::DATA_INTEGER)
answer = reply.Integer();
}

26
test/map/MapComparer.cpp
View File

@@ -305,17 +305,17 @@ bool JsonMapComparer::isEmpty(const JsonNode & value)
{
switch (value.getType())
{
case JsonNode::DATA_NULL:
case JsonNode::JsonType::DATA_NULL:
return true;
case JsonNode::DATA_BOOL:
case JsonNode::JsonType::DATA_BOOL:
return !value.Bool();
case JsonNode::DATA_FLOAT:
case JsonNode::JsonType::DATA_FLOAT:
return value.Float() == 0;
case JsonNode::DATA_STRING:
case JsonNode::JsonType::DATA_STRING:
return value.String() == "";
case JsonNode::DATA_VECTOR:
case JsonNode::JsonType::DATA_VECTOR:
return value.Vector().empty();
case JsonNode::DATA_STRUCT:
case JsonNode::JsonType::DATA_STRUCT:
return value.Struct().empty();
break;
default:
@@ -392,24 +392,24 @@ void JsonMapComparer::checkEqualJson(const JsonNode & actual, const JsonNode & e
{
switch (actual.getType())
{
case JsonNode::DATA_NULL:
case JsonNode::JsonType::DATA_NULL:
break; //do nothing
case JsonNode::DATA_BOOL:
case JsonNode::JsonType::DATA_BOOL:
check(actual.Bool() == expected.Bool(), "mismatch");
break;
case JsonNode::DATA_FLOAT:
case JsonNode::JsonType::DATA_FLOAT:
checkEqualFloat(actual.Float(),expected.Float());
break;
case JsonNode::DATA_STRING:
case JsonNode::JsonType::DATA_STRING:
checkEqualString(actual.String(),expected.String());
break;
case JsonNode::DATA_VECTOR:
case JsonNode::JsonType::DATA_VECTOR:
checkEqualJson(actual.Vector(), expected.Vector());
break;
case JsonNode::DATA_STRUCT:
case JsonNode::JsonType::DATA_STRUCT:
checkEqualJson(actual.Struct(), expected.Struct());
break;
case JsonNode::DATA_INTEGER:
case JsonNode::JsonType::DATA_INTEGER:
checkEqualInteger(actual.Integer(), expected.Integer());
break;
default: