CsGeneratorBase::CsGeneratorBase(std::shared_ptr<Document> doc)
: Generator(doc) {
- type_map_ = {{"char", "byte"}, {"int", "int"}, {"short", "short"},
- {"long", "long"}, {"string", "string"}, {"bool", "bool"},
- {"list", "LinkedList"}, {"array", "List"}, {"float", "float"},
- {"double", "double"}, {"bundle", "Bundle"}, {"void", "void"},
- {"file", "string"} , {"set", "HashSet"}, {"map", "Dictionary"}};
+ type_map_ = {
+ {"char", "byte"}, {"int", "int"}, {"short", "short"},
+ {"long", "long"}, {"string", "string"}, {"bool", "bool"},
+ {"list", "LinkedList"}, {"array", "List"}, {"float", "float"},
+ {"double", "double"}, {"bundle", "Bundle"}, {"void", "void"},
+ {"file", "string"}, {"set", "HashSet"}, {"map", "Dictionary"}};
parcel_type_map_ = {{"char", "Byte"}, {"int", "Int"},
{"short", "Short"}, {"long", "Long"},
std::string str;
for (const auto& e : block.GetEnums()) {
str += Tab(tab_size) + "public enum " + e->GetID() + " {" + NLine(1);
- for (auto& f : e->GetFields()) {
- if (f->GetValue().empty()) {
+ for (auto& f : e->GetFields()) {
+ if (f->GetValue().empty()) {
str += Tab(tab_size + 1) + f->GetID() + "," + NLine(1);
- } else {
- str += Tab(tab_size + 1) + f->GetID() + " = " +
- f->GetValue() + "," + NLine(1);
- }
+ } else {
+ str += Tab(tab_size + 1) + f->GetID() + " = " + f->GetValue() + "," +
+ NLine(1);
+ }
}
str += Tab(tab_size) + "}" + NLine(1);
}
}
void CsGeneratorBase::GenEnum(std::ofstream& stream, const Block& block,
- int tab_size) {
+ int tab_size) {
stream << GenEnum(block, tab_size);
}
i->GetType().ToString() == "map" ||
i->GetType().ToString() == "set") {
v.push_back(i->GetID() + " = " + "new " +
- ConvertTypeToString(i->GetType()) + "()");
+ ConvertTypeToString(i->GetType()) + "()");
}
}
}
std::string CsGeneratorBase::GetSerializer(const Structure& st) {
-
std::string str(ReplaceAll(CB_SERIALIZER)
.Change("<TYPE>", st.GetID())
.Change("<BODY>", [&]() {
type_str = GetTypeString(t);
ret += Tab(4) + "map.Write(\"" + i->GetID() +
- "\", \"" + type_str + "\"" +
- ", param." + i->GetID() + ");" + NLine(1);
+ "\", \"" + type_str + "\"" + ", param." +
+ i->GetID() + ");" + NLine(1);
}
return ret;
}));
str += ReplaceAll(CB_DESERIALIZER)
.Change("<TYPE>", st.GetID())
.Change("<BODY>", [&]() {
- std::string ret;
- std::string type_str;
- for (const auto& i : st.GetElements()) {
- auto& t = i->GetType();
- if (t.IsEnumType())
- type_str = "int";
- else
- type_str = GetTypeString(t);
-
- ret += Tab(4) + "map.Read(\"" + i->GetID() +
- "\", \"" + type_str +
- "\"" + ", out param." + i->GetID() + ");" + NLine(1);
- }
- return ret;
- });
- return str;
+ std::string ret;
+ std::string type_str;
+ for (const auto& i : st.GetElements()) {
+ auto& t = i->GetType();
+ if (t.IsEnumType())
+ type_str = "int";
+ else
+ type_str = GetTypeString(t);
+
+ ret += Tab(4) + "map.Read(\"" + i->GetID() + "\", \"" +
+ type_str + "\"" + ", out param." + i->GetID() + ");" +
+ NLine(1);
+ }
+ return ret;
+ });
+ return str;
}
void CsGeneratorBase::GenSerializer(std::ofstream& stream) {
- stream << GetSerializer();
+ stream << GetSerializer();
}
std::string CsGeneratorBase::GetSerializer() {
- std::string str;
- for (auto& i : GetDocument().GetBlocks()) {
- if (i->GetType() == Block::TYPE_STRUCTURE) {
- const Structure& st = static_cast<const Structure&>(*i);
- str += GetSerializer(st);
- }
+ std::string str;
+ for (auto& i : GetDocument().GetBlocks()) {
+ if (i->GetType() == Block::TYPE_STRUCTURE) {
+ const Structure& st = static_cast<const Structure&>(*i);
+ str += GetSerializer(st);
}
+ }
- return str;
+ return str;
}
void CsGeneratorBase::AddSerializerList(const BaseType& type,
- const std::string& st_id) {
+ const std::string& st_id) {
if (type.GetMetaType() != nullptr) {
if (type.GetMetaType()->GetUserDefinedType() == BaseType::UserType::ENUM &&
!st_id.empty()) {
BaseType new_type(type.ToString(), "", type.GetUserDefinedType());
- BaseType* new_meta = new BaseType(st_id + "." +
- type.GetMetaType()->ToString(), "", BaseType::UserType::ENUM);
+ BaseType* new_meta =
+ new BaseType(st_id + "." + type.GetMetaType()->ToString(), "",
+ BaseType::UserType::ENUM);
new_type.SetMetaType(new_meta);
serializer_list_[ConvertTypeToString(type, st_id)] = new_type;
return;
serializer_list_[ConvertTypeToString(type, st_id)] = type;
AddSerializerList(*type.GetMetaType(), st_id);
} else if (type.GetKeyType() != nullptr && type.GetValueType() != nullptr) {
- if (type.GetValueType()->IsEnumType() && !st_id.empty()) {
+ if (type.GetValueType()->IsEnumType() && !st_id.empty()) {
BaseType new_type(type.ToString(), "", type.GetUserDefinedType());
BaseType* new_key = new BaseType(*(type.GetKeyType()));
- BaseType* new_value = new BaseType(st_id + "." +
- type.GetValueType()->ToString(), "", BaseType::UserType::ENUM);
+ BaseType* new_value =
+ new BaseType(st_id + "." + type.GetValueType()->ToString(), "",
+ BaseType::UserType::ENUM);
new_type.SetKeyType(new_key);
new_type.SetValueType(new_value);
}
std::string CsGeneratorBase::GenListWrite(const BaseType& type,
- const std::string& type_str) {
+ const std::string& type_str) {
std::string ret;
std::string type_string;
if (type.ToString() == "map") {
else
type_string = ConvertTypeToString(*type.GetValueType());
- ret = ReplaceAll(CB_LIST_MAP_WRITE)
+ ret = ReplaceAll(CB_LIST_MAP_WRITE)
.Change("<KEY_TYPE>", ConvertTypeToString(*type.GetKeyType()))
.Change("<VALUE_TYPE>", type_string);
} else if (type.ToString() == "set") {
- ret = ReplaceAll(CB_LIST_SET_WRITE)
+ ret = ReplaceAll(CB_LIST_SET_WRITE)
.Change("<VALUE_TYPE>", ConvertTypeToString(*type.GetMetaType()));
} else if (type.GetMetaType()->IsEnumType()) {
- ret = ReplaceAll(CB_LIST_WRITE)
- .Change("<VALUE_TYPE>", std::string("int"));
+ ret = ReplaceAll(CB_LIST_WRITE).Change("<VALUE_TYPE>", std::string("int"));
} else {
- ret = ReplaceAll(CB_LIST_WRITE)
+ ret = ReplaceAll(CB_LIST_WRITE)
.Change("<VALUE_TYPE>", ConvertTypeToString(*type.GetMetaType()));
}
}
std::string CsGeneratorBase::GenListRead(const BaseType& type,
- const std::string& type_str) {
+ const std::string& type_str) {
std::string ret;
if (type.ToString() == "map") {
if (type.GetValueType()->IsEnumType()) {
- ret = ReplaceAll(CB_LIST_MAP_READ)
- .Change("<KEY_TYPE>", ConvertTypeToString(*type.GetKeyType()))
- .Change("<TYPE_STRING>", std::string("int"))
- .Change("<VALUE_TYPE>", type.GetValueType()->ToString());
+ ret = ReplaceAll(CB_LIST_MAP_READ)
+ .Change("<KEY_TYPE>", ConvertTypeToString(*type.GetKeyType()))
+ .Change("<TYPE_STRING>", std::string("int"))
+ .Change("<VALUE_TYPE>", type.GetValueType()->ToString());
} else {
- ret = ReplaceAll(CB_LIST_MAP_READ)
+ ret =
+ ReplaceAll(CB_LIST_MAP_READ)
.Change("<KEY_TYPE>", ConvertTypeToString(*type.GetKeyType()))
.Change("<TYPE_STRING>", ConvertTypeToString(*type.GetKeyType()))
- .Change("<VALUE_TYPE>", ConvertTypeToString(*type.GetValueType()));
+ .Change("<VALUE_TYPE>",
+ ConvertTypeToString(*type.GetValueType()));
}
} else if (type.ToString() == "set") {
- ret = ReplaceAll(CB_LIST_SET_READ)
+ ret = ReplaceAll(CB_LIST_SET_READ)
.Change("<VALUE_TYPE>", ConvertTypeToString(*type.GetMetaType()));
} else if (type.GetMetaType()->IsEnumType()) {
std::string list_method;
if (type.ToString() == "list")
list_method = "Last";
- ret = ReplaceAll(CB_LIST_READ)
+ ret = ReplaceAll(CB_LIST_READ)
.Change("<TYPE_STRING>", std::string("int"))
.Change("<LIST_METHOD>", list_method)
.Change("<VALUE_TYPE>", type.GetMetaType()->ToString());
if (type.ToString() == "list")
list_method = "Last";
- ret = ReplaceAll(CB_LIST_READ)
+ ret = ReplaceAll(CB_LIST_READ)
.Change("<TYPE_STRING>", ConvertTypeToString(*type.GetMetaType()))
.Change("<LIST_METHOD>", list_method)
.Change("<VALUE_TYPE>", ConvertTypeToString(*type.GetMetaType()));
}
std::string CsGeneratorBase::GetLengthName(const BaseType& type) {
- if (type.ToString() == "list") {
- return "length";
- } else {
- return "size";
- }
+ if (type.ToString() == "list") {
+ return "length";
+ } else {
+ return "size";
+ }
}
std::string CsGeneratorBase::GetListSerializer(const BaseType& type,
- const std::string& type_str) {
- std::string code;
- code = ReplaceAll(CB_LIST_SERIALIZER)
- .Change("<TYPE>", type_str)
- .Change("<LENGTH_NAME>", GetLengthName(type))
- .Change("<WRITE_LIST>", GenListWrite(type, type_str));
+ const std::string& type_str) {
+ std::string code;
+ code = ReplaceAll(CB_LIST_SERIALIZER)
+ .Change("<TYPE>", type_str)
+ .Change("<LENGTH_NAME>", GetLengthName(type))
+ .Change("<WRITE_LIST>", GenListWrite(type, type_str));
- code += ReplaceAll(CB_LIST_DESERIALIZER)
- .Change("<TYPE>", type_str)
- .Change("<LENGTH_NAME>", GetLengthName(type))
- .Change("<READ_LIST>", GenListRead(type, type_str));
+ code += ReplaceAll(CB_LIST_DESERIALIZER)
+ .Change("<TYPE>", type_str)
+ .Change("<LENGTH_NAME>", GetLengthName(type))
+ .Change("<READ_LIST>", GenListRead(type, type_str));
- return code;
+ return code;
}
void CsGeneratorBase::GenListSerializer(std::ofstream& stream) {
- stream << GetListSerializer();
+ stream << GetListSerializer();
}
std::string CsGeneratorBase::GetListSerializer() {
- serializer_list_.clear();
- for (auto& i : GetDocument().GetBlocks()) {
- if (i->GetType() == Block::TYPE_STRUCTURE) {
- const Structure& st = static_cast<const Structure&>(*i);
- for (const auto& j : st.GetElements()) {
- auto& t = j->GetType();
- AddSerializerList(t, st.GetID());
- }
- } else if (i->GetType() == Block::TYPE_INTERFACE) {
- const Interface& iface = static_cast<const Interface&>(*i);
- for (const auto& j : iface.GetDeclarations()) {
- auto& t = j->GetType();
- AddSerializerList(t);
- for (const auto& k : j->GetParameters()) {
- auto& t1 = k->GetParameterType().GetBaseType();
- AddSerializerList(t1);
- }
+ serializer_list_.clear();
+ for (auto& i : GetDocument().GetBlocks()) {
+ if (i->GetType() == Block::TYPE_STRUCTURE) {
+ const Structure& st = static_cast<const Structure&>(*i);
+ for (const auto& j : st.GetElements()) {
+ auto& t = j->GetType();
+ AddSerializerList(t, st.GetID());
+ }
+ } else if (i->GetType() == Block::TYPE_INTERFACE) {
+ const Interface& iface = static_cast<const Interface&>(*i);
+ for (const auto& j : iface.GetDeclarations()) {
+ auto& t = j->GetType();
+ AddSerializerList(t);
+ for (const auto& k : j->GetParameters()) {
+ auto& t1 = k->GetParameterType().GetBaseType();
+ AddSerializerList(t1);
}
}
}
+ }
- std::string ret;
- for (auto& p : serializer_list_) {
- auto& type_str = p.first;
- auto& t = p.second;
- ret += GetListSerializer(t, type_str);
- }
+ std::string ret;
+ for (auto& p : serializer_list_) {
+ auto& type_str = p.first;
+ auto& t = p.second;
+ ret += GetListSerializer(t, type_str);
+ }
- return ret;
+ return ret;
}
std::string CsGeneratorBase::ConvertTypeToString(const BaseType& type,
- const std::string& st_id) {
+ const std::string& st_id) {
if (type.GetUserDefinedType() == BaseType::UserType::ENUM && !st_id.empty()) {
return st_id + "." + type.ToString();
}
if (type.GetMetaType() != nullptr)
return type_map_[type.ToString()] + "<" +
- ConvertTypeToString(*(type.GetMetaType()), st_id) + ">";
+ ConvertTypeToString(*(type.GetMetaType()), st_id) + ">";
if (type.GetKeyType() != nullptr && type.GetValueType() != nullptr) {
return type_map_[type.ToString()] + "<" +
}
std::string CsGeneratorBase::ConvertTypeToParcelType(const std::string& key) {
- return parcel_type_map_[key];
+ return parcel_type_map_[key];
}
std::string CsGeneratorBase::ConvertTypeToDeserializer(
const BaseType& type, std::string gen_id, std::string param_id,
std::string map, bool make_new_type, std::string iface_id) {
- std::string ret;
- std::string new_type = "";
+ std::string ret;
+ std::string new_type = "";
- if (make_new_type) {
- if (type.IsUserDefinedType() || type.GetMetaType() != nullptr) {
- if (type.GetMetaType() != nullptr)
- new_type = ConvertTypeToString(type);
- else
- new_type = type.ToString();
- } else {
+ if (make_new_type) {
+ if (type.IsUserDefinedType() || type.GetMetaType() != nullptr) {
+ if (type.GetMetaType() != nullptr)
new_type = ConvertTypeToString(type);
- }
+ else
+ new_type = type.ToString();
+ } else {
+ new_type = ConvertTypeToString(type);
}
+ }
- std::string type_str;
+ std::string type_str;
- if (type.GetUserDefinedType() == BaseType::UserType::ENUM)
- type_str = "int";
- else
- type_str = GetTypeString(type);
- ret += map + ".Read(" + "\"" + param_id + "\", \"" + type_str + "\", out ";
- if (IsDelegateType(type)) {
- ret += "CallbackBase del_" + gen_id + ");\n";
- ret +=
- new_type + " " + gen_id + " = new " + new_type +
- "(GetPort(Port.Type.Callback, instance), new WeakReference(b), del_" +
- gen_id + ");\n";
+ if (type.GetUserDefinedType() == BaseType::UserType::ENUM)
+ type_str = "int";
+ else
+ type_str = GetTypeString(type);
+ ret += map + ".Read(" + "\"" + param_id + "\", \"" + type_str + "\", out ";
+ if (IsDelegateType(type)) {
+ ret += "CallbackBase del_" + gen_id + ");\n";
+ ret +=
+ new_type + " " + gen_id + " = new " + new_type +
+ "(GetPort(Port.Type.Callback, instance), new WeakReference(b), del_" +
+ gen_id + ");\n";
+ } else {
+ if (make_new_type) {
+ ret += new_type + " " + gen_id + ");\n";
} else {
- if (make_new_type) {
- ret += new_type + " " + gen_id + ");\n";
- } else {
- ret += gen_id + ");\n";
- }
+ ret += gen_id + ");\n";
}
+ }
- return ret;
+ return ret;
}
std::string CsGeneratorBase::ConvertTypeToSerializer(std::string gen_id,
std::string param_type,
std::string map) {
return map + ".Write(\"" + param_id + "\", \"" + param_type + "\", " +
- gen_id + ");\n";
+ gen_id + ");\n";
}
std::string CsGeneratorBase::ConvertTypeToSerializer(std::string gen_id,
std::string param_id,
const BaseType& type,
std::string map) {
- if (type.GetUserDefinedType() == BaseType::UserType::ENUM)
- return ConvertTypeToSerializer(gen_id, param_id, "int" , map);
+ if (type.GetUserDefinedType() == BaseType::UserType::ENUM)
+ return ConvertTypeToSerializer(gen_id, param_id, "int", map);
else
- return ConvertTypeToSerializer(gen_id, param_id, GetTypeString(type) , map);
+ return ConvertTypeToSerializer(gen_id, param_id, GetTypeString(type), map);
}
std::string CsGeneratorBase::Tab(int cnt) {
- std::string t;
+ std::string t;
- for (int i = 0; i < cnt; i++) {
- t += " ";
- }
+ for (int i = 0; i < cnt; i++) {
+ t += " ";
+ }
- return t;
+ return t;
}
std::string CsGeneratorBase::NLine(int cnt) {
- std::string t;
+ std::string t;
- for (int i = 0; i < cnt; i++) {
- t += "\n";
- }
+ for (int i = 0; i < cnt; i++) {
+ t += "\n";
+ }
- return t;
+ return t;
}
void CsGeneratorBase::GenWriteBundle(std::ofstream& stream,
const std::string& id) {
- GenTemplate(
- CB_WRITE_BUNDLE, stream, [&]() -> std::string { return id; },
- [&]() -> std::string { return id; });
+ GenTemplate(
+ CB_WRITE_BUNDLE, stream, [&]() -> std::string { return id; },
+ [&]() -> std::string { return id; });
}
std::string CsGeneratorBase::GetMethodId(const Interface& iface) {
- return std::string(ReplaceAll(CB_METHOD_IDS).Change("<METHOD_IDS>", [&]() {
- int cnt = 2;
- std::string str;
- for (const auto& i : iface.GetDeclarations()) {
- if (i->GetMethodType() == Declaration::MethodType::DELEGATE) continue;
- str += Tab(4) + i->GetID() + " = " + std::to_string(cnt++) + "," +
- NLine(1);
- }
- return str;
- }));
+ return std::string(ReplaceAll(CB_METHOD_IDS).Change("<METHOD_IDS>", [&]() {
+ int cnt = 2;
+ std::string str;
+ for (const auto& i : iface.GetDeclarations()) {
+ if (i->GetMethodType() == Declaration::MethodType::DELEGATE) continue;
+ str +=
+ Tab(4) + i->GetID() + " = " + std::to_string(cnt++) + "," + NLine(1);
+ }
+ return str;
+ }));
}
void CsGeneratorBase::GenMethodId(std::ofstream& stream,
const Interface& iface) {
- stream << GetMethodId(iface);
+ stream << GetMethodId(iface);
}
void CsGeneratorBase::GenDelegateId(std::ofstream& stream,
const Interface& iface) {
- if (HasDelegate(iface) == false)
- return;
+ if (HasDelegate(iface) == false)
+ return;
- stream << Tab(3) << "private enum DelegateId : int" << NLine(1);
- GenBrace(stream, TAB_SIZE * 3, [&]() {
- int cnt = 1;
- for (const auto& i : iface.GetDeclarations()) {
- if (i->GetMethodType() != Declaration::MethodType::DELEGATE) continue;
- stream << Tab(4) << i->GetID() << " = " << cnt++ << "," << NLine(1);
- }
- });
- stream << NLine(1);
+ stream << Tab(3) << "private enum DelegateId : int" << NLine(1);
+ GenBrace(stream, TAB_SIZE * 3, [&]() {
+ int cnt = 1;
+ for (const auto& i : iface.GetDeclarations()) {
+ if (i->GetMethodType() != Declaration::MethodType::DELEGATE) continue;
+ stream << Tab(4) << i->GetID() << " = " << cnt++ << "," << NLine(1);
+ }
+ });
+ stream << NLine(1);
}
void CsGeneratorBase::GenDeclaration(std::ofstream& stream,
const Declaration& decl, bool semicol) {
- stream << GetDeclaration(decl, semicol);
+ stream << GetDeclaration(decl, semicol);
}
std::string CsGeneratorBase::GetDeclaration(const Declaration& decl,
bool semicol) {
- std::string ret;
- ret += ConvertTypeToString(decl.GetType()) + " " + decl.GetID() + "(";
- ret += GetParameters(decl.GetParameters());
- if (semicol)
- ret += ");";
- else
- ret += ")";
- return ret;
+ std::string ret;
+ ret += ConvertTypeToString(decl.GetType()) + " " + decl.GetID() + "(";
+ ret += GetParameters(decl.GetParameters());
+ if (semicol)
+ ret += ");";
+ else
+ ret += ")";
+ return ret;
}
void CsGeneratorBase::GenParameters(std::ofstream& stream,
const Parameters& ps) {
- stream << GetParameters(ps);
+ stream << GetParameters(ps);
}
bool CsGeneratorBase::HasDelegate(const Interface& iface) {
- bool found = false;
- for (const auto& i : iface.GetDeclarations()) {
- if (i->GetMethodType() == Declaration::MethodType::DELEGATE) {
- found = true;
- break;
- }
+ bool found = false;
+ for (const auto& i : iface.GetDeclarations()) {
+ if (i->GetMethodType() == Declaration::MethodType::DELEGATE) {
+ found = true;
+ break;
}
- return found;
+ }
+ return found;
}
std::string CsGeneratorBase::GetParameters(const Parameters& ps) {
- bool first = true;
- std::string ret;
- for (const auto& i : ps) {
- if (!first) {
- ret += ", ";
- }
-
- auto dir = i->GetParameterType().GetDirection();
- if (dir == ParameterType::Direction::OUT) {
- ret += "out ";
- } else if (dir == ParameterType::Direction::REF) {
- ret += "ref ";
- }
+ bool first = true;
+ std::string ret;
+ for (const auto& i : ps) {
+ if (!first) {
+ ret += ", ";
+ }
- ret += ConvertTypeToString(i->GetParameterType().GetBaseType()) + " " +
- i->GetID();
- first = false;
+ auto dir = i->GetParameterType().GetDirection();
+ if (dir == ParameterType::Direction::OUT) {
+ ret += "out ";
+ } else if (dir == ParameterType::Direction::REF) {
+ ret += "ref ";
}
- return ret;
+ ret += ConvertTypeToString(i->GetParameterType().GetBaseType()) + " " +
+ i->GetID();
+ first = false;
+ }
+
+ return ret;
}
std::string CsGeneratorBase::GenUnitMapParamType(const BaseType& base_type,
- const std::string& type_str) {
+ const std::string& type_str) {
std::string ret;
if (base_type.GetUserDefinedType() == BaseType::UserType::DELEGATE)
ret = "CallbackBase";
}
std::string CsGeneratorBase::GetTypeString(const BaseType& base_type) {
- std::string ret;
+ std::string ret;
- if (!base_type.IsUserDefinedType() && base_type.GetMetaType() == nullptr
- && base_type.GetKeyType() == nullptr) {
- if (base_type.ToString() == "file")
- ret = base_type.ToString();
- else
- ret = ConvertTypeToString(base_type);
- } else if (base_type.GetUserDefinedType() == BaseType::UserType::DELEGATE) {
- ret = "delegate";
- } else if (base_type.IsUserDefinedType()) {
+ if (!base_type.IsUserDefinedType() && base_type.GetMetaType() == nullptr &&
+ base_type.GetKeyType() == nullptr) {
+ if (base_type.ToString() == "file")
+ ret = base_type.ToString();
+ else
ret = ConvertTypeToString(base_type);
- } else {
- ret = GetEnumTypeString(base_type);
- }
+ } else if (base_type.GetUserDefinedType() == BaseType::UserType::DELEGATE) {
+ ret = "delegate";
+ } else if (base_type.IsUserDefinedType()) {
+ ret = ConvertTypeToString(base_type);
+ } else {
+ ret = GetEnumTypeString(base_type);
+ }
- return ret;
+ return ret;
}
std::string CsGeneratorBase::GenUnitMaUintWrite(const Interface& iface,
const BaseType& base_type) {
std::string ret;
- if (!base_type.IsUserDefinedType() && base_type.GetMetaType() == nullptr
- && base_type.GetKeyType() == nullptr) {
- ret = "unit.parcel.Write" +
- ConvertTypeToParcelType(base_type.ToString()) + "(value);";
+ if (!base_type.IsUserDefinedType() && base_type.GetMetaType() == nullptr &&
+ base_type.GetKeyType() == nullptr) {
+ ret = "unit.parcel.Write" + ConvertTypeToParcelType(base_type.ToString()) +
+ "(value);";
} else if (base_type.GetUserDefinedType() == BaseType::UserType::ENUM) {
ret = "unit.parcel.WriteInt((int)value);";
} else if (base_type.GetUserDefinedType() == BaseType::UserType::DELEGATE) {
const std::string& type_str) {
std::string ret;
- if (!base_type.IsUserDefinedType() && base_type.GetMetaType() == nullptr
- && base_type.GetKeyType() == nullptr) {
+ if (!base_type.IsUserDefinedType() && base_type.GetMetaType() == nullptr &&
+ base_type.GetKeyType() == nullptr) {
ret = "value = unit.parcel.Read" +
ConvertTypeToParcelType(base_type.ToString()) + "();";
} else if (base_type.GetUserDefinedType() == BaseType::UserType::ENUM) {
ret = "int enum_int = unit.parcel.ReadInt();" + NLine(1) + Tab(1) +
- "value = (" + type_str + ")enum_int;";
+ "value = (" + type_str + ")enum_int;";
} else if (base_type.GetUserDefinedType() == BaseType::UserType::DELEGATE) {
ret = "value = new CallbackBase(1, false);" + NLine(1) + Tab(1) +
"CallbackBase.Deserialize(unit.parcel, value);";
} else {
- ret = "value = new " + type_str + "();" + NLine(1) +
- Tab(1) + iface.GetID() + ".Deserialize(unit.parcel, value);";
+ ret = "value = new " + type_str + "();" + NLine(1) + Tab(1) +
+ iface.GetID() + ".Deserialize(unit.parcel, value);";
}
return ret;
}
void CsGeneratorBase::AddTypeMap(
- std::unordered_map<std::string, BaseType>& types,
- const BaseType& base_type, const std::string& st_id) {
-
+ std::unordered_map<std::string, BaseType>& types, const BaseType& base_type,
+ const std::string& st_id) {
types[ConvertTypeToString(base_type, st_id)] = base_type;
if (base_type.GetMetaType() != nullptr) {
}
std::string CsGeneratorBase::GenUnitMapReadWrite(const Interface& iface) {
- std::unordered_map<std::string, BaseType> types;
- BaseType bI("int", "int");
- BaseType bS("string", "string");
- BaseType bB("bool", "bool");
-
- types[bI.GetFullName()] = bI;
- types[bS.GetFullName()] = bS;
- types[bB.GetFullName()] = bB;
-
- for (const auto& i : iface.GetDeclarations()) {
- types[ConvertTypeToString(i->GetType())] = i->GetType();
- if (i->GetMethodType() == Declaration::MethodType::DELEGATE) {
- BaseType del(i->GetID(), "", BaseType::UserType::DELEGATE);
- AddTypeMap(types, del);
- }
+ std::unordered_map<std::string, BaseType> types;
+ BaseType bI("int", "int");
+ BaseType bS("string", "string");
+ BaseType bB("bool", "bool");
+
+ types[bI.GetFullName()] = bI;
+ types[bS.GetFullName()] = bS;
+ types[bB.GetFullName()] = bB;
+
+ for (const auto& i : iface.GetDeclarations()) {
+ types[ConvertTypeToString(i->GetType())] = i->GetType();
+ if (i->GetMethodType() == Declaration::MethodType::DELEGATE) {
+ BaseType del(i->GetID(), "", BaseType::UserType::DELEGATE);
+ AddTypeMap(types, del);
+ }
- for (const auto& j : i->GetParameters()) {
- auto& type = j->GetParameterType().GetBaseType();
- AddTypeMap(types, type);
- }
+ for (const auto& j : i->GetParameters()) {
+ auto& type = j->GetParameterType().GetBaseType();
+ AddTypeMap(types, type);
}
+ }
- for (auto& i : GetDocument().GetBlocks()) {
- if (i->GetType() == Block::TYPE_STRUCTURE) {
- const Structure& st = static_cast<const Structure&>(*i);
- for (const auto& i : st.GetElements()) {
- auto& type = i->GetType();
- AddTypeMap(types, type, st.GetID());
- }
+ for (auto& i : GetDocument().GetBlocks()) {
+ if (i->GetType() == Block::TYPE_STRUCTURE) {
+ const Structure& st = static_cast<const Structure&>(*i);
+ for (const auto& i : st.GetElements()) {
+ auto& type = i->GetType();
+ AddTypeMap(types, type, st.GetID());
}
}
+ }
- types.erase("void");
-
- std::string code = "";
- for (const auto& iter : types) {
- auto& type_str = iter.first;
- auto& base_type = iter.second;
- code += ReplaceAll(CB_UNITMAP_READ_READ_BASE)
- .Change("<PARAM_TYPE>", GenUnitMapParamType(base_type, type_str))
- .Change("<UINT_READ>", GenUnitMaUintRead(iface, base_type, type_str));
- code += ReplaceAll(CB_UNITMAP_READ_WRITE_BASE)
- .Change("<PARAM_TYPE>", GenUnitMapParamType(base_type, type_str))
- .Change("<UINT_WRITE>", GenUnitMaUintWrite(iface, base_type));
- }
+ types.erase("void");
+
+ std::string code = "";
+ for (const auto& iter : types) {
+ auto& type_str = iter.first;
+ auto& base_type = iter.second;
+ code +=
+ ReplaceAll(CB_UNITMAP_READ_READ_BASE)
+ .Change("<PARAM_TYPE>", GenUnitMapParamType(base_type, type_str))
+ .Change("<UINT_READ>",
+ GenUnitMaUintRead(iface, base_type, type_str));
+ code +=
+ ReplaceAll(CB_UNITMAP_READ_WRITE_BASE)
+ .Change("<PARAM_TYPE>", GenUnitMapParamType(base_type, type_str))
+ .Change("<UINT_WRITE>", GenUnitMaUintWrite(iface, base_type));
+ }
- return code;
+ return code;
}
void CsGeneratorBase::GenUnitMap(std::ofstream& stream, const Interface& iface,
int tabSize) {
- stream << GetUnitMap(iface, tabSize);
+ stream << GetUnitMap(iface, tabSize);
}
std::string CsGeneratorBase::GetUnitMap(const Interface& iface, int tabSize) {
- std::string ret_string(CB_UNIT_BASE);
- ret_string += ReplaceAll(CB_UNITMAP_BASE)
-
.Change("<PARAM_READ_WRITE>", GenUnitMapReadWrite(iface));
- return AddIndent(TAB_SIZE * tabSize, ret_string);
+ std::string ret_string(CB_UNIT_BASE);
+ ret_string += ReplaceAll(CB_UNITMAP_BASE)
+ .Change("<PARAM_READ_WRITE>", GenUnitMapReadWrite(iface));
+ return AddIndent(TAB_SIZE * tabSize, ret_string);
}
void CsGeneratorBase::GenCallbacks(std::ofstream& stream,
const Interface& iface, bool is_proxy) {
- if (HasDelegate(iface) == false)
- return;
- stream << CB_CALLBACK_BASE;
-
- for (const auto& i : iface.GetDeclarations()) {
- if (i->GetMethodType() != Declaration::MethodType::DELEGATE)
- continue;
- GenCallback(stream, *i, iface.GetID(), is_proxy);
- }
+ if (HasDelegate(iface) == false)
+ return;
+ stream << CB_CALLBACK_BASE;
+
+ for (const auto& i : iface.GetDeclarations()) {
+ if (i->GetMethodType() != Declaration::MethodType::DELEGATE)
+ continue;
+ GenCallback(stream, *i, iface.GetID(), is_proxy);
+ }
}
void CsGeneratorBase::GenCallback(std::ofstream& stream,
const Declaration& decl,
const std::string& id, bool is_proxy) {
- stream << Tab(3) << "public sealed class " << decl.GetID()
- << " : CallbackBase" << NLine(1);
- GenBrace(stream, TAB_SIZE * 3, [&]() {
- if (is_proxy) {
- GenTemplate(
- CB_CALLBACK_CTOR_PROXY, stream,
- [&]() -> std::string { return decl.GetID(); },
- [&]() -> std::string { return decl.GetID(); });
- } else {
- GenTemplate(
- CB_CALLBACK_CTOR_STUB, stream,
- [&]() -> std::string { return decl.GetID(); },
- [&]() -> std::string { return decl.GetID(); },
- [&]() -> std::string { return decl.GetID(); });
- }
- stream << NLine(1);
-
- if (is_proxy) {
- stream << Tab(4) << "public delegate void Callback(";
- GenParameters(stream, decl.GetParameters());
- stream << ");" << NLine(1);
- stream << Tab(4) << "public event Callback Received;" << NLine(2);
- GenReceivedEvent(stream, decl, id);
- } else {
- stream << CB_CALLBACK_STUB_MEMBERS;
- GenInvokeMethod(stream, decl, id);
- }
- });
+ stream << Tab(3) << "public sealed class " << decl.GetID()
+ << " : CallbackBase" << NLine(1);
+ GenBrace(stream, TAB_SIZE * 3, [&]() {
+ if (is_proxy) {
+ GenTemplate(
+ CB_CALLBACK_CTOR_PROXY, stream,
+ [&]() -> std::string { return decl.GetID(); },
+ [&]() -> std::string { return decl.GetID(); });
+ } else {
+ GenTemplate(
+ CB_CALLBACK_CTOR_STUB, stream,
+ [&]() -> std::string { return decl.GetID(); },
+ [&]() -> std::string { return decl.GetID(); },
+ [&]() -> std::string { return decl.GetID(); });
+ }
stream << NLine(1);
+
+ if (is_proxy) {
+ stream << Tab(4) << "public delegate void Callback(";
+ GenParameters(stream, decl.GetParameters());
+ stream << ");" << NLine(1);
+ stream << Tab(4) << "public event Callback Received;" << NLine(2);
+ GenReceivedEvent(stream, decl, id);
+ } else {
+ stream << CB_CALLBACK_STUB_MEMBERS;
+ GenInvokeMethod(stream, decl, id);
+ }
+ });
+ stream << NLine(1);
}
void CsGeneratorBase::GenReceivedEvent(std::ofstream& stream,
const Declaration& decl,
const std::string& id) {
- stream << Tab(4) << "internal override void OnReceivedEvent(UnitMap map)"
- << NLine(1);
- GenBrace(stream, TAB_SIZE * 4, [&]() {
- int cnt = 1;
- for (const auto& i : decl.GetParameters()) {
- std::string v = "param" + std::to_string(cnt);
- std::string c =
- ConvertTypeToDeserializer(i->GetParameterType().GetBaseType(), v,
- i->GetID(), "map", true, id);
- stream << AddIndent(TAB_SIZE * 5, c);
- cnt++;
- }
+ stream << Tab(4) << "internal override void OnReceivedEvent(UnitMap map)"
+ << NLine(1);
+ GenBrace(stream, TAB_SIZE * 4, [&]() {
+ int cnt = 1;
+ for (const auto& i : decl.GetParameters()) {
+ std::string v = "param" + std::to_string(cnt);
+ std::string c = ConvertTypeToDeserializer(
+ i->GetParameterType().GetBaseType(), v, i->GetID(), "map", true, id);
+ stream << AddIndent(TAB_SIZE * 5, c);
+ cnt++;
+ }
- cnt = 1;
- stream << NLine(1) << Tab(5) << "Received?.Invoke(";
- for (auto i = decl.GetParameters().begin();
- i != decl.GetParameters().end(); ++i) {
- if (cnt != 1) {
- stream << ", ";
- }
- std::string v = "param" + std::to_string(cnt);
- stream << v;
- cnt++;
+ cnt = 1;
+ stream << NLine(1) << Tab(5) << "Received?.Invoke(";
+ for (auto i = decl.GetParameters().begin(); i != decl.GetParameters().end();
+ ++i) {
+ if (cnt != 1) {
+ stream << ", ";
}
- stream << ");" << NLine(1);
- });
- stream << NLine(1);
+ std::string v = "param" + std::to_string(cnt);
+ stream << v;
+ cnt++;
+ }
+ stream << ");" << NLine(1);
+ });
+ stream << NLine(1);
}
void CsGeneratorBase::GenInvokeMethod(std::ofstream& stream,
const Declaration& decl,
const std::string& id) {
- GenTemplate(
- CB_CALLBACK_INVOKE_METHOD, stream,
- [&]() -> std::string { return GetParameters(decl.GetParameters()); },
- [&]() -> std::string {
- std::string m;
- for (const auto& i : decl.GetParameters()) {
- m += ConvertTypeToSerializer(
- i->GetID(), i->GetID(),
- GetTypeString(i->GetParameterType().GetBaseType()), "map");
- }
- return AddIndent(TAB_SIZE * 6, m);
- });
+ GenTemplate(
+ CB_CALLBACK_INVOKE_METHOD, stream,
+ [&]() -> std::string { return GetParameters(decl.GetParameters()); },
+ [&]() -> std::string {
+ std::string m;
+ for (const auto& i : decl.GetParameters()) {
+ m += ConvertTypeToSerializer(
+ i->GetID(), i->GetID(),
+ GetTypeString(i->GetParameterType().GetBaseType()), "map");
+ }
+ return AddIndent(TAB_SIZE * 6, m);
+ });
}
void CsGeneratorBase::GenVersion(std::ofstream& stream) {
- GenTemplate(::cs_cb_version, stream,
- [&]() -> std::string { return FULLVER; });
- stream << NLine(1);
+ GenTemplate(::cs_cb_version, stream,
+ [&]() -> std::string { return FULLVER; });
+ stream << NLine(1);
}
} // namespace version2
projects / platform / core / appfw / tidl.git / commitdiff