486 lines
11 KiB
C++
486 lines
11 KiB
C++
#include "dl_json_config.h"
|
|
|
|
namespace dl
|
|
{
|
|
std::string JsonConfig::GenerateCode(const GenerateParam& param)
|
|
{
|
|
std::string str;
|
|
std::size_t tab_num = 0;// 当前tab数
|
|
|
|
// 读写数据
|
|
struct RwData
|
|
{
|
|
std::string _type;
|
|
std::vector<std::string> _vec;
|
|
};
|
|
// 类型定义变量 ->
|
|
std::unordered_map<std::string, RwData> rw_data;
|
|
std::string rw_data_root;// 根类型
|
|
|
|
// 写入换行
|
|
auto endl = [&]() {
|
|
str.push_back('\n');
|
|
};
|
|
// 写入tab
|
|
auto tab = [&]() {
|
|
for (std::size_t i = 0; i < tab_num; ++i)
|
|
str += '\t';
|
|
};
|
|
|
|
// 生成读json代码
|
|
auto fn_read = [&]() {
|
|
tab(); str += "bool Load(json& j_root)"; endl();
|
|
tab(); str += "{"; endl();
|
|
++tab_num;
|
|
|
|
for (auto& iter : rw_data)
|
|
{
|
|
std::string var_name = iter.first;
|
|
RwData& rw = iter.second;
|
|
|
|
tab(); str += "{"; endl();
|
|
++tab_num;
|
|
|
|
tab(); str += fmt::format("json j;", var_name); endl();
|
|
tab(); str += fmt::format("JsonAuto::Get(j_root, \"{}\", j);", var_name); endl();
|
|
for (auto& iter1 : rw._vec)
|
|
{
|
|
tab(); str += fmt::format("JsonAuto::Get(j, \"{1}\", {0}.{1});", var_name, iter1); endl();
|
|
}
|
|
|
|
--tab_num;
|
|
tab(); str += "}"; endl();
|
|
}
|
|
|
|
tab(); str += "return true;"; endl();
|
|
--tab_num;
|
|
tab(); str += "}"; endl();
|
|
};
|
|
// 生成写json代码
|
|
auto fn_write = [&]() {
|
|
tab(); str += "json Save()"; endl();
|
|
tab(); str += "{"; endl();
|
|
++tab_num;
|
|
|
|
tab(); str += "json j;"; endl();
|
|
for (auto& iter : rw_data)
|
|
{
|
|
std::string var_name = iter.first;
|
|
RwData& rw = iter.second;
|
|
|
|
tab(); str += "{"; endl();
|
|
++tab_num;
|
|
|
|
tab(); str += fmt::format("json& j_{} = j[{}];", var_name, String::AddQuotes(var_name)); endl();
|
|
|
|
for (auto& iter1 : rw._vec)
|
|
{
|
|
tab(); str += fmt::format("j_{0}[\"{1}\"] = {0}.{1};", var_name, iter1); endl();
|
|
}
|
|
|
|
|
|
--tab_num;
|
|
tab(); str += "}"; endl();
|
|
}
|
|
|
|
tab(); str += "return j;"; endl();
|
|
--tab_num;
|
|
tab(); str += "}"; endl();
|
|
};
|
|
// 生成lua绑定代码
|
|
auto fn_register_lua = [&]() {
|
|
tab(); str += fmt::format("void RegisterLua(lua_State* L, const std::string& lua_name)", rw_data_root); endl();
|
|
tab(); str += "{"; endl();
|
|
++tab_num;
|
|
|
|
for (auto& iter : rw_data)
|
|
{
|
|
std::string var_name = iter.first;
|
|
RwData& rw = iter.second;
|
|
|
|
tab(); str += "luabridge::getGlobalNamespace(L)"; endl();
|
|
++tab_num;
|
|
tab(); str += fmt::format(".beginClass<{}>({})", rw._type, String::AddQuotes(var_name)); endl();
|
|
tab(); str += ".addConstructor<void(*)()>()"; endl();
|
|
|
|
for (auto& iter1 : rw._vec)
|
|
{
|
|
tab(); str += fmt::format(".addProperty({}, &{}::{})", String::AddQuotes(iter1), rw._type, iter1); endl();
|
|
}
|
|
tab(); str += ".endClass();"; endl();
|
|
tab(); str += ""; endl();
|
|
|
|
--tab_num;
|
|
}
|
|
// 根类
|
|
tab(); str += "luabridge::getGlobalNamespace(L)"; endl();
|
|
++tab_num;
|
|
tab(); str += fmt::format(".beginClass<{}>(lua_name.c_str())", rw_data_root); endl();
|
|
tab(); str += ".addConstructor<void(*)()>()"; endl();
|
|
for (auto& iter : rw_data)
|
|
{
|
|
std::string var_name = iter.first;
|
|
RwData& rw = iter.second;
|
|
tab(); str += fmt::format(".addProperty({}, &{}::{})", String::AddQuotes(var_name), rw_data_root, var_name); endl();
|
|
}
|
|
tab(); str += ".endClass();"; endl();
|
|
tab(); str += ""; endl();
|
|
--tab_num;
|
|
tab(); str += "auto result = luabridge::push(L, this);"; endl();
|
|
tab(); str += "lua_setglobal(L, lua_name.c_str());"; endl();
|
|
--tab_num;
|
|
tab(); str += "}"; endl();
|
|
};
|
|
|
|
auto fn_struct = [&](auto&& fn_value, Value& v, RwData& rw)->void {
|
|
ValueStruct s = v.ToStruct();
|
|
for (auto& iter : s.GetMemberAll())
|
|
{
|
|
fn_value(fn_value, iter.second, rw);
|
|
}
|
|
};
|
|
|
|
auto fn_value = [&](auto&& fn_value, Value& v, RwData& rw)->void {
|
|
if (v.GetType() == ValueType::NONE)
|
|
return;
|
|
if (v.GetType() == ValueType::STRUCT)
|
|
{
|
|
ValueStruct s = v.ToStruct();
|
|
std::string type = s.GetMember("type").ToString();
|
|
ValueType v_type = String2ValueType(type);
|
|
std::string str_name = s["name"].ToString();
|
|
std::string str_desc = s["desc"].ToString();
|
|
std::string str_div = str_desc.empty() ? "" : " -> ";
|
|
|
|
if (v_type == ValueType::NONE)
|
|
{
|
|
return;
|
|
}
|
|
else if (v_type == ValueType::STRUCT)
|
|
{
|
|
tab(); str += fmt::format("//! {}{}{}", str_name, str_div, str_desc); endl();
|
|
tab(); str += fmt::format("struct {}", type); endl();
|
|
tab(); str += "{"; endl();
|
|
++tab_num;
|
|
|
|
// 生成rw
|
|
RwData& rw = rw_data[s.GetName()];
|
|
rw._type = type;
|
|
|
|
fn_struct(fn_value, s["value"], rw);
|
|
|
|
if (tab_num == 1)
|
|
{
|
|
// 结束代码
|
|
rw_data_root = rw_data["__root"]._type;
|
|
rw_data.erase("__root");
|
|
fn_read();
|
|
fn_write();
|
|
if (param._bRegisterLua)
|
|
fn_register_lua();
|
|
}
|
|
|
|
--tab_num;
|
|
if (tab_num != 0)
|
|
{
|
|
tab(); str += fmt::format("}}{};", s.GetName()); endl();
|
|
}
|
|
else
|
|
{
|
|
tab(); str += "};"; endl();
|
|
}
|
|
}
|
|
else if(v_type == ValueType::VECTOR
|
|
|| v_type == ValueType::ARRAY)
|
|
{
|
|
ValueTypeInfo type_info = String2ValueTypeEx(type);
|
|
tab(); str += fmt::format("{} {} = {};//! {}{}{}",
|
|
Type2CppTypeEx(v_type, type_info._type1, type_info._length), s.GetName(), s["value"].GetString(),
|
|
str_name, str_div, str_desc); endl();
|
|
|
|
rw._vec.push_back(s.GetName());
|
|
}
|
|
else
|
|
{
|
|
tab(); str += fmt::format("{} {} = {};//! {}{}{}",
|
|
Type2CppType(v_type), s.GetName(), s["value"].GetString(),
|
|
str_name, str_div, str_desc); endl();
|
|
|
|
rw._vec.push_back(s.GetName());
|
|
}
|
|
}
|
|
};
|
|
|
|
// 标头
|
|
str += fmt::format(R"(/**
|
|
* @file {0}
|
|
* @brief {1}
|
|
*
|
|
*
|
|
* @version {1}
|
|
* @author {2}
|
|
* @date {3}
|
|
*
|
|
* @note {4}
|
|
*/
|
|
#pragma once
|
|
|
|
#include <array>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <map>
|
|
|
|
#include <json.hpp>
|
|
using json = nlohmann::json;
|
|
)", param._filename, param._brief, param._version, param._author, param._date, param._note);
|
|
|
|
// lua头
|
|
if (param._bRegisterLua)
|
|
{
|
|
str += fmt::format(R"(
|
|
#define LUA_USE_APICHECK
|
|
#include <lua.hpp>
|
|
#include <LuaBridge/LuaBridge.h>
|
|
)");
|
|
}
|
|
// json get函数
|
|
str += fmt::format(R"(
|
|
namespace JsonAuto
|
|
{{
|
|
/**
|
|
* @brief 从json返回值,不存在则返回false
|
|
*/
|
|
template<typename T>
|
|
bool Get(const json& j, const std::string& name, T& t)
|
|
{{
|
|
auto iter = j.find(name);
|
|
if (iter == j.end())
|
|
{{
|
|
{0}(std::string("未加载到配置:") + name);
|
|
return false;
|
|
}}
|
|
try
|
|
{{
|
|
json v = *iter;
|
|
if (v.find("value") != v.end())
|
|
t = (v["value"]).get<T>();
|
|
else
|
|
t = v.get<T>();
|
|
return true;
|
|
}}
|
|
catch (nlohmann::detail::exception& e)
|
|
{{
|
|
{0}(std::string("配置取值失败:") + name + " " + e.what());
|
|
}}
|
|
return false;
|
|
}}
|
|
}}
|
|
|
|
)", param._logFunction);
|
|
|
|
if (!param._namespace.empty())
|
|
{
|
|
str += "namespace ";
|
|
str += param._namespace;
|
|
str += "\n{\n";
|
|
}
|
|
|
|
fn_value(fn_value, _root, rw_data["__root"]);
|
|
|
|
if (!param._namespace.empty())
|
|
{
|
|
str += "\n}";
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
std::string JsonConfig::GenerateConfigUser(const std::unordered_map<std::string, std::string>& map_type)
|
|
{
|
|
json j;
|
|
auto fn_struct = [&](auto&& fn_value, json& j_this, Value& v)->void {
|
|
ValueStruct s = v.ToStruct();
|
|
for (auto& iter : s.GetMemberAll())
|
|
{
|
|
fn_value(fn_value, j_this, iter.second);
|
|
}
|
|
};
|
|
|
|
auto fn_value = [&](auto&& fn_value, json& j_parent, Value& v)->void {
|
|
if (v.GetType() == ValueType::NONE)
|
|
return;
|
|
if (v.GetType() == ValueType::STRUCT)
|
|
{
|
|
ValueStruct s = v.ToStruct();
|
|
std::string type = s.GetMember("type").ToString();
|
|
|
|
ValueType v_type = String2ValueType(type);
|
|
if (v_type == ValueType::NONE)
|
|
{
|
|
return;
|
|
}
|
|
else if (v_type == ValueType::STRUCT)
|
|
{
|
|
std::string str_name = s["name"].ToString();
|
|
std::string str_desc = s["desc"].ToString();
|
|
|
|
json& j_this = j_parent[s.GetName()];
|
|
//log_msg("构造 {}", s.GetName());
|
|
j_this["__name"] = str_name;
|
|
j_this["__desc"] = str_desc;
|
|
|
|
fn_struct(fn_value, j_this, s["value"]);
|
|
}
|
|
else
|
|
{
|
|
std::string str_name = s["name"].ToString();
|
|
std::string str_desc = s["desc"].ToString();
|
|
|
|
json& j_this = j_parent[s.GetName()];
|
|
//log_msg("构造 {}", s.GetName());
|
|
j_this["__name"] = str_name;
|
|
j_this["__desc"] = str_desc;
|
|
|
|
|
|
// 类型替换
|
|
std::string out_type;
|
|
auto iter_type = map_type.find(type);
|
|
if (iter_type == map_type.end())
|
|
out_type = type;
|
|
else
|
|
out_type = iter_type->second;
|
|
|
|
j_this["type"] = out_type;// Type2CppType(v_type);
|
|
j_this["value"] = s["value"].GetJson();
|
|
}
|
|
}
|
|
};
|
|
|
|
fn_value(fn_value, j, _root);
|
|
return j["__root"].dump(4);
|
|
}
|
|
|
|
dl::Value JsonConfig::_parse_node(json& j, std::string_view var)
|
|
{
|
|
Node node;
|
|
node._var = var;
|
|
|
|
Json::DisableLog l;
|
|
Json::Get(j, "name", node._name);
|
|
Json::Get(j, "desc", node._desc);
|
|
|
|
std::string type;
|
|
Json::Get(j, "type", type);
|
|
|
|
json j_value;
|
|
Json::Get(j, "value", j_value);
|
|
node._value = _parse_value(j_value, type);
|
|
|
|
ValueStruct s{ var };
|
|
s["type"] = type;
|
|
s["name"] = node._name;
|
|
s["desc"] = node._desc;
|
|
s["value"] = node._value;
|
|
|
|
return s;
|
|
}
|
|
|
|
dl::Value JsonConfig::_parse_value(json& j, std::string_view type)
|
|
{
|
|
ValueType value_type = String2ValueType(type);
|
|
try
|
|
{
|
|
switch (value_type)
|
|
{
|
|
case dl::ValueType::BOOL:
|
|
return j.get<bool>();
|
|
case dl::ValueType::CHAR:
|
|
return j.get<char>();
|
|
case dl::ValueType::UCHAR:
|
|
return j.get<unsigned char>();
|
|
case dl::ValueType::SHORT:
|
|
return j.get<short>();
|
|
case dl::ValueType::USHORT:
|
|
return j.get<unsigned short>();
|
|
case dl::ValueType::INT:
|
|
return j.get<int>();
|
|
case dl::ValueType::UINT:
|
|
return j.get<unsigned int>();
|
|
case dl::ValueType::INT64:
|
|
return j.get<int64_t>();
|
|
case dl::ValueType::UINT64:
|
|
return j.get<uint64_t>();
|
|
case dl::ValueType::FLOAT:
|
|
return j.get<float>();
|
|
case dl::ValueType::DOUBLE:
|
|
return j.get<double>();
|
|
case dl::ValueType::STRUCT:
|
|
{
|
|
g_value->RegisterStruct(type);
|
|
ValueStruct s{ type };
|
|
std::string str = j.dump(4);
|
|
for (auto& iter : j.items())
|
|
{
|
|
if(String::IsBegin(iter.key(), "//"))
|
|
continue;
|
|
Value v = _parse_node(iter.value(), iter.key());
|
|
s[iter.key()] = v;
|
|
}
|
|
return s;
|
|
}
|
|
break;
|
|
case dl::ValueType::STRING:
|
|
return j.get<std::string>();
|
|
case dl::ValueType::ARRAY:
|
|
{
|
|
ValueTypeInfo type_info = String2ValueTypeEx(type);
|
|
ValueVector vec{ type_info._type1 };
|
|
|
|
size_t i = 0;
|
|
for (auto& iter : j.items())
|
|
{
|
|
Value v = _parse_value(iter.value(), type_info._strType1);
|
|
vec.PushBack(v);
|
|
++i;
|
|
if (i >= type_info._length)
|
|
break;
|
|
}
|
|
for (; i < type_info._length; ++i)
|
|
{
|
|
Value v{ type_info._type1};
|
|
vec.PushBack(v);
|
|
}
|
|
|
|
return vec;
|
|
}
|
|
case dl::ValueType::VECTOR:
|
|
{
|
|
ValueTypeInfo type_info = String2ValueTypeEx(type);
|
|
ValueVector vec{ type_info._type1 };
|
|
for (auto& iter : j.items())
|
|
{
|
|
Value v = _parse_value(iter.value(), type_info._strType1);
|
|
vec.PushBack(v);
|
|
}
|
|
return vec;
|
|
}
|
|
case dl::ValueType::MAP:
|
|
break;
|
|
case dl::ValueType::NONE:
|
|
default:
|
|
assert(0);
|
|
break;
|
|
}
|
|
}
|
|
catch (nlohmann::detail::exception& e)
|
|
{
|
|
log_err("json类型转换失败,请检查配置:({})\n"
|
|
"{}\n"
|
|
"{}", type, j.dump(4), e.what());
|
|
}
|
|
|
|
|
|
return {};
|
|
}
|
|
|
|
} |