diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..f1df49b7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,24 @@ +CMakeFiles/ +*.cmake +bin/ +tmp/ +src/ +Makefile +CMakeCache.txt +download/ +*.a +install_manifest.txt +servant/servant/AdminF.h +servant/servant/AuthF.h +servant/servant/BaseF.h +servant/servant/ConfigF.h +servant/servant/EndpointF.h +servant/servant/LogF.h +servant/servant/NodeF.h +servant/servant/NotifyF.h +servant/servant/PropertyF.h +servant/servant/QueryF.h +servant/servant/StatF.h +servant/tup/RequestF.h +tools/tarsgrammar/tars.lex.cpp +tools/tarsgrammar/tars.tab.hpp diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt index 6121c70b..4519ae11 100755 --- a/tools/CMakeLists.txt +++ b/tools/CMakeLists.txt @@ -40,6 +40,7 @@ add_subdirectory(tars2php) add_subdirectory(tars2android) add_subdirectory(tars2node) add_subdirectory(tars2case) +add_subdirectory(tars2dart) IF(TARS_PROTOBUF) add_subdirectory(pb2tarscpp) diff --git a/tools/README.md b/tools/README.md index 7318150b..92a59192 100755 --- a/tools/README.md +++ b/tools/README.md @@ -17,5 +17,6 @@ tars2php | Source code implementation of IDL tool for generating PHP code t tars2python | Source code implementation of IDL tool for generating Python code through tars file tars2node | Source code implementation of IDL tool for generating Node.js code through tars file tars2android | Source code implementation of IDL tool for generating Android code through tars file +tars2dart | Source code implementation of IDL tool for generating Dart(Flutter) code through tars file,[Dependences](https://github.com/brooklet/dart_tars_protocol) tars2case | Generate test case for tars server pb2tarscpp | Generate protoc plugin source code for tars C++ code via proto file diff --git a/tools/README.zh.md b/tools/README.zh.md index 7705cec6..f4f08dbd 100755 --- a/tools/README.zh.md +++ b/tools/README.zh.md @@ -16,4 +16,5 @@ tars2python | 通过tars文件生成 Python 代码的IDL工具的源码实现 tars2node | 通过tars文件生成 Node.js 代码的IDL工具的源码实现 tars2android | 通过tars文件生成 Android 代码的IDL工具的源码实现 tars2case | 通过tars文件生成 tars 服务生成测试用例 +tars2dart | 通过tars文件生成 Dart(Flutter) 代码的IDL工具的源码实现,[依赖库](https://github.com/brooklet/dart_tars_protocol) pb2tarscpp | 通过proto文件生成tars C++ 代码的protoc插件源码实现 diff --git a/tools/tars2dart/CMakeLists.txt b/tools/tars2dart/CMakeLists.txt new file mode 100644 index 00000000..c3b1977c --- /dev/null +++ b/tools/tars2dart/CMakeLists.txt @@ -0,0 +1 @@ +tars2language("tars2dart") diff --git a/tools/tars2dart/interface_analysis.cpp b/tools/tars2dart/interface_analysis.cpp new file mode 100644 index 00000000..72a16c5c --- /dev/null +++ b/tools/tars2dart/interface_analysis.cpp @@ -0,0 +1,100 @@ +/** + * Tencent is pleased to support the open source community by making Tars available. + * + * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ +#include "interface_analysis.h" + +#include + +InterfaceAnalysis::InterfaceAnalysis() { +} + +void InterfaceAnalysis::analysis(const vector& interfacePtrs) { + for (size_t index = 0; index < interfacePtrs.size(); ++index) { + analysis(interfacePtrs[index]); + } +} + +void InterfaceAnalysis::analysis(const InterfacePtr& interfacePtr) { + const vector& operations = interfacePtr->getAllOperationPtr(); + + for (size_t operationIndex = 0; operationIndex < operations.size(); ++operationIndex) { + const OperationPtr& operation = operations[operationIndex]; + + analysis(operation->getReturnPtr()->getTypePtr()); + + const vector& paramDecls = operation->getAllParamDeclPtr(); + + for (size_t paramIndex = 0; paramIndex < paramDecls.size(); paramIndex++) { + const ParamDeclPtr& paramDeclPtr = paramDecls[paramIndex]; + analysis(paramDeclPtr->getTypeIdPtr()->getTypePtr()); + } + } +} + +void InterfaceAnalysis::analysis(const StructPtr& structPtr) { + const vector& allMembersPtr = structPtr->getAllMemberPtr(); + for (size_t index = 0; index < allMembersPtr.size(); ++index) { + analysis(allMembersPtr[index]->getTypePtr()); + } +} + +void InterfaceAnalysis::analysis(const TypePtr& typePtr) { + VectorPtr vPtr = VectorPtr::dynamicCast(typePtr); + if (vPtr) { + analysis(vPtr->getTypePtr()); + return ; + } + + MapPtr mPtr = MapPtr::dynamicCast(typePtr); + if (mPtr) { + analysis(mPtr->getLeftTypePtr()); + analysis(mPtr->getRightTypePtr()); + return ; + } + + StructPtr sPtr = StructPtr::dynamicCast(typePtr); + if (sPtr) { + // 说明已经分析过，并且找到了 + if (mAllStructs.find(sPtr->getSid()) != mAllStructs.end()) { + return ; + } + + mAllStructs.insert(std::pair(sPtr->getSid(), sPtr)); + analysis(sPtr); + } + + EnumPtr ePtr = EnumPtr::dynamicCast(typePtr); + if (ePtr) { + if (mAllEnums.find(ePtr->getSid()) != mAllEnums.end()) { + return ; + } + + mAllEnums.insert(std::pair(ePtr->getSid(), ePtr)); + } +} + +const std::map& InterfaceAnalysis::getAllStructs() const { + return mAllStructs; +} + +const std::map& InterfaceAnalysis::getAllEnums() const { + return mAllEnums; +} + +const std::map& InterfaceAnalysis::getAllConsts() const { + return mAllConsts; +} + + diff --git a/tools/tars2dart/interface_analysis.h b/tools/tars2dart/interface_analysis.h new file mode 100644 index 00000000..5b0e301f --- /dev/null +++ b/tools/tars2dart/interface_analysis.h @@ -0,0 +1,47 @@ +/** + * Tencent is pleased to support the open source community by making Tars available. + * + * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +#ifndef INTERFACE_ANALYSIS_H_ +#define INTERFACE_ANALYSIS_H_ + +#include "parse.h" +#include +#include + +class InterfaceAnalysis { +public: + InterfaceAnalysis(); + + const std::map& getAllStructs() const; + const std::map& getAllEnums() const; + const std::map& getAllConsts() const; + + void analysis(const InterfacePtr& interfacePtr); + void analysis(const vector& interfacePtrs); + +private: + void analysis(const StructPtr& structPtr); + void analysis(const TypePtr& typePtr); + +private: + std::map mAllStructs; + std::map mAllEnums; + std::map mAllConsts; +}; + + + +#endif /* INTERFACE_ANALYSIS_H_ */ diff --git a/tools/tars2dart/main.cpp b/tools/tars2dart/main.cpp new file mode 100644 index 00000000..64cece30 --- /dev/null +++ b/tools/tars2dart/main.cpp @@ -0,0 +1,135 @@ +/** + * Tencent is pleased to support the open source community by making Tars available. + * + * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ +#include "util/tc_option.h" +#include "util/tc_file.h" +#include "tars2dart.h" + +void usage() +{ + cout << "Usage : tars2dart [OPTION] tarsfile" << endl; + cout << " tars2dart support type: bool byte short int long float double vector map" << endl; + cout << "supported [OPTION]:" << endl; + cout << " --help help,print this" << endl; + cout << " --dir=DIRECTORY generate dart file to DIRECTORY(default to current)" << endl; + cout << " --base-package=NAME package prefix, default(tars_idl)" << endl; + cout << " --extends-package=NAME set the extends package name, default(/tars/)"<< endl; + cout << " --with-charset set charset, default UTF8" << endl; + + + cout << endl; + exit(0); +} + +void check(vector &vTars) +{ + for(size_t i = 0; i < vTars.size(); i++) + { + string ext = tars::TC_File::extractFileExt(vTars[i]); + if(ext == "tars") + { + if(!tars::TC_File::isFileExist(vTars[i])) + { + cerr << "file '" << vTars[i] << "' not exists" << endl; + usage(); + exit(0); + } + } + else + { + cerr << "only support tars file." << endl; + exit(0); + } + } +} + +int main(int argc, char* argv[]) +{ + if(argc < 2) + { + usage(); + } + + tars::TC_Option option; + option.decode(argc, argv); + vector vTars = option.getSingle(); + + check(vTars); + + if(option.hasParam("help")) + { + usage(); + } + + Tars2Dart t2d; + + g_parse->setTars(option.hasParam("with-tars")); + + if(option.getValue("dir") != "") + { + t2d.setBaseDir(option.getValue("dir")); + } + else + { + t2d.setBaseDir("."); + } + + if(option.hasParam("base-package")) + { + t2d.setBasePackage(option.getValue("base-package")); + } + else + { + t2d.setBasePackage("tars_idl."); + } + + if (option.hasParam("extends-package")) + { + t2d.setTafPacket(option.getValue("extends-package")); + } + + if(option.hasParam("with-JavaBeanRule")) + { + t2d.setWithJbr(true); + } + else + { + t2d.setWithJbr(false); + } + + t2d.setWithCompact(false); + t2d.setEnumCompact(true); + + t2d.setWithGenerateInterfaceDependencies(true); + t2d.setWithFilterRomTars(true); + + try + { + //增加include搜索路径 + g_parse->addIncludePath(option.getValue("include")); + + for(size_t i = 0; i < vTars.size(); i++) + { + g_parse->parse(vTars[i]); + t2d.createFile(vTars[i]); + } + }catch(exception& e) + { + cerr< + +#define TAB g_parse->getTab() +#define INC_TAB g_parse->incTab() +#define DEL_TAB g_parse->delTab() + +static string g_default_package = "tars_idl"; +static string g_default_tars_package = "/tars/codec/"; + +////////////////////////////////////////////////////////////////////////////////// +// +Tars2Dart::Tars2Dart() +{ + _bWithCompact = false; + s_TARS_PACKAGE = g_default_package + TARS_PACKAGE; + s_PROXY_PACKAGE = g_default_package + PROXY_PACKAGE; + s_WUP_PACKAGE = g_default_package + WUP_PACKAGE; + _tarsPackage = g_default_tars_package; +} + +string Tars2Dart::writeTo(const TypeIdPtr& pPtr) const +{ + ostringstream s; + if (EnumPtr::dynamicCast(pPtr->getTypePtr())) + { + s << TAB << "_os.write(" << pPtr->getId() << ", " << pPtr->getTag() << ");" << endl; + } + else + { + s << TAB << "_os.write(" << pPtr->getId() << ", " << pPtr->getTag() << ");" << endl; + } + + return s.str(); +} + +string Tars2Dart::readFrom(const TypeIdPtr& pPtr) const +{ + ostringstream s; + if (EnumPtr::dynamicCast(pPtr->getTypePtr())) + { + s << TAB << "_is.read((tars::Int32&)" << pPtr->getId(); + } + else + { + s << TAB << "_is.read(" << pPtr->getId(); + } + + s << ", " << pPtr->getTag() << ", " << (pPtr->isRequire() ? "true" : "false") << ");" << endl; + + return s.str(); +} + +string Tars2Dart::display(const TypeIdPtr& pPtr) const +{ + ostringstream s; + if (EnumPtr::dynamicCast(pPtr->getTypePtr())) + { + s << TAB << "_ds.display((tars::Int32)" << pPtr->getId() << ",\"" << pPtr->getId() << "\");" << endl;; + } + else + { + s << TAB << "_ds.display(" << pPtr->getId() << ",\"" << pPtr->getId() << "\");" << endl;; + } + + return s.str(); +} + +string Tars2Dart::toTypeInit(const TypePtr& pPtr) const +{ + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(pPtr); + if (bPtr) + { + switch (bPtr->kind()) + { + case Builtin::KindBool: + return "false"; + case Builtin::KindByte: + return "0"; + case Builtin::KindShort: + return "0"; + case Builtin::KindInt: + return "0"; + case Builtin::KindLong: + return "0"; + case Builtin::KindFloat: + return "0.0f"; + case Builtin::KindDouble: + return "0.0"; + case Builtin::KindString: + return "\"\""; + default: + return ""; + } + } + + VectorPtr vPtr = VectorPtr::dynamicCast(pPtr); + if (vPtr) + { + // BuiltinPtr bPtr = BuiltinPtr::dynamicCast(vPtr->getTypePtr()); + // if (bPtr && bPtr->kind() == Builtin::KindByte) + // { + // return "Uint8List(1);"; + // } + + // return "" + tostrVector(vPtr) + "();"; + return "null"; + } + + MapPtr mPtr = MapPtr::dynamicCast(pPtr); + // if (mPtr) return " " + tostrMap(mPtr, true) + "();"; + if (mPtr) return "null"; + + StructPtr sPtr = StructPtr::dynamicCast(pPtr); + // if (sPtr) return " " + tostrStruct(sPtr) + "();"; + if (sPtr) return "null"; + + EnumPtr ePtr = EnumPtr::dynamicCast(pPtr); + if (ePtr) return "0"; + + return ""; +} + + +string Tars2Dart::toObjStr(const TypePtr& pPtr) const +{ + string sType = tostr(pPtr); + + if (sType == "boolean") return "bool"; + if (sType == "byte") return "Uint8List"; + if (sType == "short") return "int"; + if (sType == "int") return "int"; + if (sType == "long") return "int"; + if (sType == "float") return "double"; + if (sType == "double") return "double"; + + return sType; +} + +bool Tars2Dart::isObjType(const TypePtr& pPtr) const +{ + EnumPtr ePtr = EnumPtr::dynamicCast(pPtr); + if (ePtr) + { + return false; + } + + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(pPtr); + if (bPtr) + { + switch (bPtr->kind()) + { + case Builtin::KindBool: + return false; + case Builtin::KindByte: + return false; + case Builtin::KindShort: + return false; + case Builtin::KindInt: + return false; + case Builtin::KindLong: + return false; + case Builtin::KindFloat: + return false; + case Builtin::KindDouble: + return false; + default: + return true; + } + } + + return true; +} + +string Tars2Dart::tostr(const TypePtr& pPtr) const +{ + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(pPtr); + if (bPtr) return tostrBuiltin(bPtr); + + VectorPtr vPtr = VectorPtr::dynamicCast(pPtr); + if (vPtr) return tostrVector(vPtr); + + MapPtr mPtr = MapPtr::dynamicCast(pPtr); + if (mPtr) return tostrMap(mPtr); + + StructPtr sPtr = StructPtr::dynamicCast(pPtr); + if (sPtr) return tostrStruct(sPtr); + + EnumPtr ePtr = EnumPtr::dynamicCast(pPtr); + if (ePtr) return tostrEnum(ePtr); + + if (!pPtr) return "void"; + + assert(false); + return ""; +} + +vector Tars2Dart::toImportStrs(const TypePtr& pPtr) const{ + vector result; + itrToImportStrs(pPtr, result); + return result; +} + +void Tars2Dart::itrToImportStrs(const TypePtr& pPtr, vector& result) const{ + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(pPtr); + if (bPtr) return; + + VectorPtr vPtr = VectorPtr::dynamicCast(pPtr); + if (vPtr){ + itrToImportStrs(vPtr->getTypePtr(), result); + return; + } + + MapPtr mPtr = MapPtr::dynamicCast(pPtr); + if (mPtr) { + itrToImportStrs(mPtr->getLeftTypePtr(), result); + itrToImportStrs(mPtr->getRightTypePtr(), result); + return; + } + + StructPtr sPtr = StructPtr::dynamicCast(pPtr); + if (sPtr) { result.push_back(sPtr->getId()); return; } + + EnumPtr ePtr = EnumPtr::dynamicCast(pPtr); + if (ePtr){ result.push_back(ePtr->getId()); return; } + + return; +} + + +/*******************************BuiltinPtr********************************/ +string Tars2Dart::tostrBuiltin(const BuiltinPtr& pPtr) const +{ + string s; + + switch (pPtr->kind()) + { + case Builtin::KindBool: + s = "bool"; + break; + case Builtin::KindByte: + s = "int"; + break; + case Builtin::KindShort: + s = "int"; + break; + case Builtin::KindInt: + s = "int"; + break; + case Builtin::KindLong: + s = "int"; + break; + case Builtin::KindFloat: + s = "double"; + break; + case Builtin::KindDouble: + s = "double"; + break; + case Builtin::KindString: + s = "String"; + break; + case Builtin::KindVector: + s = "List"; + break; + case Builtin::KindMap: + s = "Map"; + break; + default: + assert(false); + break; + } + + return s; +} +/*******************************VectorPtr********************************/ +string Tars2Dart::tostrVector(const VectorPtr& pPtr) const +{ + string s; + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(pPtr->getTypePtr()); + if (bPtr && bPtr->kind() == Builtin::KindByte) + { + s = "Uint8List"; + } + else + { + s = "List" + string("<") + toObjStr(pPtr->getTypePtr()) + ">"; + } + return s; +} + +/*******************************MapPtr********************************/ +string Tars2Dart::tostrMap(const MapPtr& pPtr, bool bNew) const +{ + string s; + s = "Map"; + s += string("<") + toObjStr(pPtr->getLeftTypePtr()) + ", " + toObjStr(pPtr->getRightTypePtr()) + ">"; + + return s; +} + +string Tars2Dart::tostrStruct(const StructPtr& pPtr) const +{ + // return _packagePrefix + tars::TC_Common::replace(pPtr->getSid(), "::", "."); + return pPtr->getId(); +} + +string Tars2Dart::tostrEnum(const EnumPtr& pPtr) const +{ + return "int"; +} + +///////////////////////////////////////////////////////////////////// + +string Tars2Dart::MD5(const StructPtr& pPtr) const +{ + string s; + vector& member = pPtr->getAllMemberPtr(); + for (size_t j = 0; j < member.size(); j++) + { + s += "_" + tostr(member[j]->getTypePtr()); + } + + return "\"" + tars::TC_MD5::md5str(s) + "\""; +} + +string Tars2Dart::generateDart(const ParamDeclPtr& pPtr) const +{ + ostringstream s; + + TypePtr typePtr = pPtr->getTypeIdPtr()->getTypePtr(); + if (!pPtr->isOut()) + { + s << tostr(typePtr); + } + + s << " " << pPtr->getTypeIdPtr()->getId(); + + return s.str(); +} + +struct SortOperation +{ + bool operator ()(const OperationPtr& o1, const OperationPtr& o2) + { + return o1->getId() < o2->getId(); + } +}; + +string Tars2Dart::generateDart(const InterfacePtr& pPtr, const NamespacePtr& nPtr) const +{ + ostringstream s; + //generateAndroidStub(pPtr, nPtr); + return s.str(); +} + +string Tars2Dart::generateDefautElem(const TypePtr& pPtr, const string& sElemName) const +{ + static int iCount = 0; + ostringstream s; + return s.str(); +} + +string Tars2Dart::getDefaultValue(const TypeIdPtr& pPtr, const string sp) const{ + string sDefalut; + if (pPtr -> hasDefault()){ + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(pPtr->getTypePtr()); + EnumPtr ePtr = EnumPtr::dynamicCast(pPtr->getTypePtr()); + //string转义 + if (bPtr && bPtr->kind() == Builtin::KindString) + { + sDefalut = tars::TC_Common::replace(pPtr->def(), "\"", "\\\""); + //sDefalut = " = (" + tostr(member[i]->getTypePtr()) + ")\"" + sDefalut + "\""; + sDefalut = " " + sp +" \"" + sDefalut + "\""; + } + else if (ePtr) + { + std::string sdef = pPtr->def(); + std::string::size_type pos = sdef.rfind("::"); + if (pos != std::string::npos && pos + 2 < sdef.size()) + { + sdef = sdef.substr(pos + 2); + } + + if (_bEnumCompact) + { + sDefalut = " " + sp + " " + _packagePrefix + tars::TC_Common::replace(ePtr->getSid(), "::", ".") + "._" + sdef; + } + else + { + sDefalut = " " + sp + " " + _packagePrefix + tars::TC_Common::replace(ePtr->getSid(), "::", ".") + "." + sdef + ".value()"; + } + } + else + { + //sDefalut = " = (" + tostr(member[i]->getTypePtr()) + ")" + member[i]->def(); + sDefalut = " " + sp + " " + pPtr->def(); + } + }else{ + string typeDefault = toTypeInit(pPtr->getTypePtr()); + if(typeDefault == "" || typeDefault == "null"){ + sDefalut = ""; + }else{ + sDefalut = " " + sp + " " + toTypeInit(pPtr->getTypePtr()); + } + } + return sDefalut; +} + +string Tars2Dart::generateNewElem(const TypePtr& pPtr) const +{ + ostringstream s; + + VectorPtr vPtr = VectorPtr::dynamicCast(pPtr); + if (vPtr) + { + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(vPtr->getTypePtr()); + if (bPtr && bPtr->kind() == Builtin::KindByte) + { + return "[0x0]"; + } + + return "["+ generateNewElem(vPtr->getTypePtr()) +"]"; + } + + MapPtr mPtr = MapPtr::dynamicCast(pPtr); + if (mPtr) + { + s << " " << tostrMap(mPtr, true) << "()" << endl; + return s.str(); + } + + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(pPtr); + if (bPtr) + { + switch (bPtr->kind()) + { + case Builtin::KindBool: + return "false"; + case Builtin::KindByte: + return "0"; + case Builtin::KindShort: + return "0"; + case Builtin::KindInt: + return "0"; + case Builtin::KindLong: + return "0"; + case Builtin::KindFloat: + return "0.0f"; + case Builtin::KindDouble: + return "0.0"; + case Builtin::KindString: + return "\"\""; + default: + return ""; + } + } + + StructPtr sPtr = StructPtr::dynamicCast(pPtr); + if (sPtr) return " " + tostrStruct(sPtr) + "()"; + + EnumPtr ePtr = EnumPtr::dynamicCast(pPtr); + if (ePtr) return "0"; + + return ""; +} + +string Tars2Dart::tostrCache(const TypeIdPtr& pPtr) const +{ + string prefix = "cache"; + string cacheName = prefix +"_" + pPtr->getId(); + + static int iCount = 0; + string cacheCodeStr = ""; + + VectorPtr vPtr = VectorPtr::dynamicCast(pPtr->getTypePtr()); + if (vPtr) + { + int iId = iCount; + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(vPtr->getTypePtr()); + if (bPtr && bPtr->kind() == Builtin::KindByte) + { + cacheCodeStr = "static Uint8List " + cacheName+ " = Uint8List.fromList([0x0])"; + }else{ + cacheCodeStr = "static List<" + tostr(vPtr->getTypePtr()) + "> " + cacheName + " = ["+ generateNewElem(vPtr->getTypePtr()) +"]"; + } + } + + MapPtr mPtr = MapPtr::dynamicCast(pPtr->getTypePtr()); + if (mPtr) + { + string leftType = tostr(mPtr->getLeftTypePtr()); + string rightType = tostr(mPtr->getRightTypePtr()); + + cacheCodeStr = "static Map<"+ leftType +", "+ rightType +"> " + cacheName + + " = {"+ generateNewElem(mPtr->getLeftTypePtr()) +":"+ generateNewElem(mPtr->getRightTypePtr()) + "}"; + } + + StructPtr sPtr = StructPtr::dynamicCast(pPtr->getTypePtr()); + if (sPtr) + { + cacheCodeStr = "static "+ toObjStr(sPtr) +" " + cacheName+ " = "+ generateNewElem(sPtr) ; + } + + EnumPtr ePtr = EnumPtr::dynamicCast(pPtr->getTypePtr()); + if (ePtr) + { + cacheCodeStr = "static "+ toObjStr(ePtr) +" " + cacheName+ " = "+ generateNewElem(ePtr) ; + } + + return cacheCodeStr; +} + +/******************************StructPtr***************************************/ +string Tars2Dart::generateDart(const StructPtr& pPtr, const NamespacePtr& nPtr) const +{ + ostringstream s; + s << g_parse->printHeaderRemark(); + + vector key = pPtr->getKey(); + vector& member = pPtr->getAllMemberPtr(); + + // s << TAB << "package " << _packagePrefix << nPtr->getId() << ";" << endl; + // s << endl; + + s << TAB << "import 'dart:core';"<< endl; + s << TAB << "import 'dart:typed_data';"<< endl; + s << TAB << "import '" << _tarsPackage << "tars_input_stream.dart';"<< endl; + s << TAB << "import '" << _tarsPackage << "tars_output_stream.dart';"<< endl; + s << TAB << "import '" << _tarsPackage << "tars_struct.dart';"<< endl; + s << TAB << "import '" << _tarsPackage << "tars_displayer.dart';"<< endl; + s << TAB << "import '" << _tarsPackage << "tars_deep_copyable.dart';"<< endl; + s << endl; + + + //导入tars定义的结构体 + map mapImport; + for (size_t i = 0; i < member.size(); i++) + { + vector packages = toImportStrs(member[i]->getTypePtr()); + if(!packages.empty()){ + for (size_t j = 0; j < packages.size(); j++){ + if(mapImport.count(packages[j])){ + continue; + } + mapImport.insert(pair(packages[j] , true)); + s << TAB << "import '" << packages[j] << ".dart';"<< endl; + } + } + } + + s << endl; + + bool bHasImpPrefix = false; + + //class定义部分 + s << TAB << "class " << pPtr->getId() << " extends " << "TarsStruct"; + + s << endl; + s << TAB << "{" << endl; + INC_TAB; + + if (!_bWithCompact) + { + //生成结构名称 + s << TAB << "String className()" << endl; + s << TAB << "{" << endl; + INC_TAB; + s << TAB << "return " << "\"" << pPtr->getId() << "\"" << ";" << endl; + DEL_TAB; + s << TAB << "}" << endl; + s << endl; + + } + + + //定义成员变量 + for (size_t i = 0; i < member.size(); i++) + { + string sDefalut; + if (member[i]->hasDefault()) + { + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(member[i]->getTypePtr()); + EnumPtr ePtr = EnumPtr::dynamicCast(member[i]->getTypePtr()); + s << TAB << tostr(member[i]->getTypePtr()) << ((bPtr && bPtr->isSimple())? " " :"? ") << member[i]->getId() << getDefaultValue(member[i],"=") << ";" << endl; + } + else + { + //s << TAB << "public " << tostr(member[i]->getTypePtr()) << " "<< member[i]->getId() << sDefalut << endl; + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(member[i]->getTypePtr()); + EnumPtr ePtr = EnumPtr::dynamicCast(member[i]->getTypePtr()); + if ((!bPtr && !ePtr) || (bPtr && bPtr->kind() == Builtin::KindString)) + { + s << TAB << tostr(member[i]->getTypePtr()) << ((bPtr && bPtr->isSimple())? " " :"? ") << member[i]->getId() << ";" << endl; + } + else + { + s << TAB << tostr(member[i]->getTypePtr()) << (( ePtr || (bPtr && bPtr->isSimple()))? " " :"? ") << member[i]->getId() << getDefaultValue(member[i],"=") << ";" << endl; + } + } + s << endl; + } + + + //带参数的构造函数，格式为： TestData({int id : 0, String? code : ""}){...} + //(constructor)(...) + s << TAB << "" << pPtr->getId() << "({"; + for (size_t i = 0; i < member.size(); i++) + { + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(member[i]->getTypePtr()); + EnumPtr ePtr = EnumPtr::dynamicCast(member[i]->getTypePtr()); + s << tostr(member[i]->getTypePtr()) << (( ePtr || (bPtr && bPtr->isSimple()))? " " :"? ") << member[i]->getId() + << getDefaultValue(member[i],":") + << ((i < member.size() - 1) ? ", " : ""); + } + s << "})" << endl; + s << TAB << "{" << endl; + INC_TAB; + for (size_t i = 0; i < member.size(); i++) + { + s << TAB << "this." << member[i]->getId() << " = " << member[i]->getId() << ";" << endl; + } + DEL_TAB; + s << TAB << "}" << endl; + s << endl; + + + //writeTo() + s << TAB << "@override" << endl; + s << TAB << "void writeTo(" << "TarsOutputStream _os)" << endl; + s << TAB << "{" << endl; + INC_TAB; + for (size_t i = 0; i < member.size(); i++) + { + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(member[i]->getTypePtr()); + EnumPtr ePtr = EnumPtr::dynamicCast(member[i]->getTypePtr()); + if (!member[i]->isRequire() && ((!bPtr && !ePtr) || (bPtr && bPtr->kind() == Builtin::KindString))) + { + s << TAB << "if (null != " << member[i]->getId() << ")" << endl; + s << TAB << "{" << endl; + INC_TAB; + s << TAB << "_os.write(" << member[i]->getId() << ", " << member[i]->getTag() << ");" << endl; + DEL_TAB; + s << TAB << "}" << endl; + } + else if (EnumPtr::dynamicCast(member[i]->getTypePtr())) + { + s << TAB << "_os.write(" << member[i]->getId() << ", " << member[i]->getTag() << ");" << endl; + } + else + { + s << TAB << "_os.write(" << member[i]->getId() << ", " << member[i]->getTag() << ");" << endl; + } + } + DEL_TAB; + s << TAB << "}" << endl; + s << endl; + + + //生成cache + for (size_t i = 0; i < member.size(); i++) + { + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(member[i]->getTypePtr()); + EnumPtr ePtr = EnumPtr::dynamicCast(member[i]->getTypePtr()); + if (!bPtr && !ePtr) + { + s << TAB << tostrCache(member[i]) << ";" << endl; + } + } + s << endl; + + + + //readFrom() + s << TAB << "@override" << endl; + s << TAB << "void readFrom(" << "TarsInputStream _is)" << endl; + s << TAB << "{" << endl; + INC_TAB; + for (size_t i = 0; i < member.size(); i++) + { + string prefix = ""; + TypePtr& tPtr = member[i]->getTypePtr(); + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(tPtr); + EnumPtr ePtr = EnumPtr::dynamicCast(tPtr); + VectorPtr vPtr = VectorPtr::dynamicCast(tPtr); + MapPtr mPtr = MapPtr::dynamicCast(tPtr); + StructPtr sPtr = StructPtr::dynamicCast(tPtr); + + if (!bPtr && !ePtr) + { + prefix = "cache_"; + } + + //基础类型 + if (bPtr){ + s << TAB << "this." << member[i]->getId() << " = " + << " _is.read<" << toObjStr(member[i]->getTypePtr()) << ">(" << prefix + member[i]->getId() + << ", " << member[i]->getTag() << ", " << (member[i]->isRequire() ? "true" : "false") << ")" << ";" << endl; + } + + //数组 + if (vPtr) + { + s << TAB << "this." << member[i]->getId() << " = " + << " _is.read<" << toObjStr(vPtr->getTypePtr()) << ">(" << prefix + member[i]->getId() + << ", " << member[i]->getTag() << ", " << (member[i]->isRequire() ? "true" : "false") << ");" << endl; + } + + //map + if (mPtr) + { + VectorPtr svPtr = VectorPtr::dynamicCast(mPtr->getRightTypePtr()); + MapPtr smPtr = MapPtr::dynamicCast(mPtr->getRightTypePtr()); + if (svPtr) + { + //Map> 结构 + s << TAB << "this." << member[i]->getId() << " = " + << " _is.readMapList<" << toObjStr(mPtr->getLeftTypePtr()) << "," << toObjStr(svPtr->getTypePtr()) << ">(" << prefix + member[i]->getId() + << ", " << member[i]->getTag() << ", " << (member[i]->isRequire() ? "true" : "false") << ");" << endl; + }else if (smPtr) + { + //Map> 结构 + s << TAB << "this." << member[i]->getId() << " = " + << " _is.readMapMap<" << toObjStr(mPtr->getLeftTypePtr()) << "," << toObjStr(smPtr->getLeftTypePtr()) << "," << toObjStr(smPtr->getRightTypePtr()) << ">(" << prefix + member[i]->getId() + << ", " << member[i]->getTag() << ", " << (member[i]->isRequire() ? "true" : "false") << ");" << endl; + }else{ + //普通 Map 结构 + s << TAB << "this." << member[i]->getId() << " = " + << " _is.readMap<" << toObjStr(mPtr->getLeftTypePtr()) << "," << toObjStr(mPtr->getRightTypePtr()) << ">(" << prefix + member[i]->getId() + << ", " << member[i]->getTag() << ", " << (member[i]->isRequire() ? "true" : "false") << ");" << endl; + } + } + + //自定义结构体 + if (sPtr) + { + s << TAB << "this." << member[i]->getId() << " = " + << " _is.read<" << toObjStr(member[i]->getTypePtr()) << ">(" << prefix + member[i]->getId() + << ", " << member[i]->getTag() << ", " << (member[i]->isRequire() ? "true" : "false") << ");" << endl; + } + + //枚举 + if (ePtr){ + s << TAB << "this." << member[i]->getId() << " = " + << " _is.read(" << prefix + member[i]->getId() + << ", " << member[i]->getTag() << ", " << (member[i]->isRequire() ? "true" : "false") << ")" << ";" << endl; + } + + } + + DEL_TAB; + s << TAB << "}" << endl; + s << endl; + + if (!_bWithCompact) + { + //display() + s << TAB << "@override" << endl; + s << TAB << "void displayAsString(StringBuffer _os, int _level)" << endl; + s << TAB << "{" << endl; + INC_TAB; + s << TAB << "TarsDisplayer _ds = " << "TarsDisplayer(_os, level : _level);" << endl; + for (size_t i = 0; i < member.size(); i++) + { + s << TAB << "_ds.display(" << member[i]->getId() + << ", \"" << member[i]->getId() << "\");" << endl; + } + DEL_TAB; + s << TAB << "}" << endl; + s << endl; + } + + //deepCopy() + s << TAB << "@override" << endl; + s << TAB << "Object deepCopy()" << endl; + s << TAB << "{" << endl; + INC_TAB; + s << TAB << "var o = " << pPtr->getId() << "();" << endl; + for (size_t i = 0; i < member.size(); i++) + { + + string prefix = ""; + TypePtr& tPtr = member[i]->getTypePtr(); + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(tPtr); + EnumPtr ePtr = EnumPtr::dynamicCast(tPtr); + VectorPtr vPtr = VectorPtr::dynamicCast(tPtr); + MapPtr mPtr = MapPtr::dynamicCast(tPtr); + StructPtr sPtr = StructPtr::dynamicCast(tPtr); + + if (!bPtr && !ePtr) + { + prefix = "cache_"; + } + + //基础类型 + if (bPtr || ePtr){ + s << TAB << "o." << member[i]->getId() << " = " << "this." << member[i]->getId() << ";" << endl; + } + + + //数组 + if (vPtr) + { + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(vPtr->getTypePtr()); + if (bPtr && bPtr->kind() == Builtin::KindByte) + { + s << TAB << "o." << member[i]->getId() << " = " << "this." << member[i]->getId() << ";" << endl; + } else { + s << TAB << "if (null != " << member[i]->getId() << ")" << endl; + s << TAB << "{" << endl; + INC_TAB; + s << TAB << "o." << member[i]->getId() << " = " + << " listDeepCopy<" << toObjStr(vPtr->getTypePtr()) << ">(this." << member[i]->getId() << "!);" << endl; + DEL_TAB; + s << TAB << "}" << endl; + } + } + + //map + if (mPtr) + { + s << TAB << "if (null != " << member[i]->getId() << ")" << endl; + s << TAB << "{" << endl; + INC_TAB; + VectorPtr svPtr = VectorPtr::dynamicCast(mPtr->getRightTypePtr()); + MapPtr smPtr = MapPtr::dynamicCast(mPtr->getRightTypePtr()); + if (svPtr) + { + //Map> 结构 + s << TAB << "o." << member[i]->getId() << " = " + << " mapListDeepCopy<" << toObjStr(mPtr->getLeftTypePtr()) << "," << toObjStr(svPtr->getTypePtr()) << ">(this." << member[i]->getId() << "!);" << endl; + + }else if (smPtr) + { + //Map> 结构 + s << TAB << "o." << member[i]->getId() << " = " + << " mapMapDeepCopy<" << toObjStr(mPtr->getLeftTypePtr()) << "," << toObjStr(smPtr->getLeftTypePtr()) << "," << toObjStr(smPtr->getRightTypePtr()) << "!);" << endl; + + }else{ + //普通 Map 结构 + s << TAB << "o." << member[i]->getId() << " = " + << " mapDeepCopy<" << toObjStr(mPtr->getLeftTypePtr()) << "," << toObjStr(mPtr->getRightTypePtr()) << ">(this." << member[i]->getId() << "!);" << endl; + } + DEL_TAB; + s << TAB << "}" << endl; + } + + //自定义结构体 + if (sPtr) + { + s << TAB << "o." << member[i]->getId() << " = this." << member[i]->getId() << "?.deepCopy() as " << toObjStr(member[i]->getTypePtr()) << "?;" << endl; + } + + } + s << TAB << "return o;" << endl; + + DEL_TAB; + s << TAB << "}" << endl; + s << endl; + + + DEL_TAB; + s << TAB << "}" << endl; + s << endl; + + + string fileJava = getFilePath(nPtr->getId()) + pPtr->getId() + ".dart"; + tars::TC_File::makeDirRecursive(getFilePath(nPtr->getId())); + tars::TC_File::save2file(fileJava, s.str()); + + return s.str(); +} + +/******************************EnumPtr***************************************/ +string Tars2Dart::generateDart(const EnumPtr& pPtr, const NamespacePtr& nPtr) const +{ + ostringstream s; + s << g_parse->printHeaderRemark(); + + s << TAB << "import 'dart:core';"<< endl; + s << endl; + + s << TAB << "class " << pPtr->getId() << "" << endl; + s << TAB << "{" << endl; + INC_TAB; + + + //成员变量 + vector& member = pPtr->getAllMemberPtr(); + bool bFlag = false; + string sValue; + for (size_t i = 0; i < member.size(); i++) + { + s << TAB << "static const int " << member[i]->getId() << " = "; + if (member[i]->hasDefault()) + { + bFlag = true; + sValue = member[i]->def(); + s << sValue; + } + else + { + if (bFlag == true) + { + assert(i > 0); + string stem = tars::TC_Common::tostr(tars::TC_Common::strto(sValue) + 1); + sValue = stem; + s << stem; + } + else + { + s << tars::TC_Common::tostr(i); + } + } + s << ";" << endl; + } + + DEL_TAB; + s << TAB << "}" << endl; + + string fileJava = getFilePath(nPtr->getId()) + pPtr->getId() + ".dart"; + tars::TC_File::makeDirRecursive(getFilePath(nPtr->getId())); + tars::TC_File::save2file(fileJava, s.str()); + + + return s.str(); +} + +/******************************ConstPtr***************************************/ +void Tars2Dart::generateDart(const ConstPtr& pPtr, const NamespacePtr& nPtr) const +{ + return; +} + +/******************************Tars2Dart***************************************/ + +void Tars2Dart::generateDart(const ContextPtr& pPtr) const +{ + ostringstream s; + + vector namespaces = pPtr->getNamespaces(); + + for (size_t i = 0; i < namespaces.size(); i++) + { + generateDart(namespaces[i]); + } + +} + +void Tars2Dart::createFile(const string& file) +{ + std::vector contexts = g_parse->getContexts(); + for (size_t i = 0; i < contexts.size(); i++) + { + if (file == contexts[i]->getFileName()) + { + generateDart(contexts[i]); + } + } +} + +void Tars2Dart::setBaseDir(const string& dir) +{ + _baseDir = dir; +} + + +void Tars2Dart::setBasePackage(const string& prefix) +{ + _packagePrefix = prefix; + if (_packagePrefix.length() != 0 + && _packagePrefix.substr(_packagePrefix.length() - 1, 1) != ".") + { + _packagePrefix += "."; + } +} + + +string Tars2Dart::getFilePath(const string& ns) const +{ + return _baseDir + FILE_SEP + tars::TC_Common::replace(_packagePrefix, ".", FILE_SEP) + FILE_SEP + ns + FILE_SEP; +} + +// 增加的函数 +static string firstCharUpper(const string& castStr) { + string resultStr = castStr; + if (castStr.size() > 0) { + resultStr[0] = toupper(castStr[0]); + } + return resultStr; +} + +void Tars2Dart::generateDart(const NamespacePtr &pPtr) const +{ + vector &is = pPtr->getAllInterfacePtr(); + vector &ss = pPtr->getAllStructPtr(); + vector &es = pPtr->getAllEnumPtr(); + vector &cs = pPtr->getAllConstPtr(); + + InterfaceAnalysis interfaceAnalysis; + + if (_bWithGenerateInterfaceDependencies) { + interfaceAnalysis.analysis(is); + } + + for (size_t i = 0; i < is.size(); i++) + { + generateDart(is[i], pPtr); + } + + TarsFilter romTarsFilter; + std::map needGenerateStructMap; + if (_bWithGenerateInterfaceDependencies) { + if (_bWithFilterRomTars) { + romTarsFilter.filterStructs( + interfaceAnalysis.getAllStructs(), needGenerateStructMap); + } else { + needGenerateStructMap = interfaceAnalysis.getAllStructs(); + } + } + + for (size_t i = 0; i < ss.size(); i++) + { + generateDart(ss[i], pPtr); + needGenerateStructMap.erase(ss[i]->getSid()); + } + for (std::map::const_iterator + it = needGenerateStructMap.begin(); it != needGenerateStructMap.end(); ++it) { + generateDart(it->second, pPtr); + } + + std::map needGenerateEnumMap; + if (_bWithGenerateInterfaceDependencies) { + if (_bWithFilterRomTars) { + romTarsFilter.filterEnums( + interfaceAnalysis.getAllEnums(), needGenerateEnumMap); + } else { + needGenerateEnumMap = interfaceAnalysis.getAllEnums(); + } + } + + for (size_t i = 0; i < es.size(); i++) + { + generateDart(es[i], pPtr); + needGenerateEnumMap.erase(es[i]->getSid()); + } + for (std::map::const_iterator + it = needGenerateEnumMap.begin(); it != needGenerateEnumMap.end(); ++it) { + generateDart(it->second, pPtr); + } + + for (size_t i = 0; i < cs.size(); i++) + { + generateDart(cs[i], pPtr); + } + + return; +} + +// 增加的实现 +string Tars2Dart::generateConstructor(const TypePtr& vType) const { + stringstream s; + + BuiltinPtr bPtr = BuiltinPtr::dynamicCast(vType); + if (bPtr) { + switch (bPtr->kind()) { + case Builtin::KindBool: { + s << "Boolean.valueOf(false)"; + } break; + case Builtin::KindByte: { + s << "Byte.valueOf((byte)0)"; + } break; + case Builtin::KindShort: { + s << "Short.valueOf((short)0)"; + } break; + case Builtin::KindInt: { + s << "Integer.valueOf(0)"; + } break; + case Builtin::KindLong: { + s << "Long.valueOf(0)"; + } break; + case Builtin::KindFloat : { + s << "Float.valueOf((float)0)"; + } break; + case Builtin::KindDouble : { + s << "Double.valueOf((double)0)"; + } break; + default:{ + s << "new " << toObjStr(vType) << "()"; + } break; + } + } else { + s << "new " << toObjStr(vType) << "()"; + } + + return s.str(); +} + +string Tars2Dart::generateAndroidJavaParams( + const vector& vParamDecl + , bool needParamType + , bool needOutParam) const { + ostringstream s; + + bool needDot = false; + for (size_t index = 0; index < vParamDecl.size(); ++index) { + ParamDeclPtr paramDeclPtr = vParamDecl[index]; + + if (!paramDeclPtr->isOut()) { + if (!needDot) { + needDot = true; + } else { + s << ", "; + } + if (needParamType) { + s << tostr(paramDeclPtr->getTypeIdPtr()->getTypePtr()) << " "; + } + s << "in" << firstCharUpper(paramDeclPtr->getTypeIdPtr()->getId()); + } else if (needOutParam){ + if (!needDot) { + needDot = true; + } else { + s << ", "; + } + if (needParamType) { + s << "WupOutWrapper<" << toObjStr(paramDeclPtr->getTypeIdPtr()->getTypePtr()) << "> "; + } + s<< "out" << firstCharUpper(paramDeclPtr->getTypeIdPtr()->getId()); + } + } + return s.str(); +} + + + diff --git a/tools/tars2dart/tars2dart.h b/tools/tars2dart/tars2dart.h new file mode 100644 index 00000000..6b86c4ce --- /dev/null +++ b/tools/tars2dart/tars2dart.h @@ -0,0 +1,415 @@ +/** + * Tencent is pleased to support the open source community by making Tars available. + * + * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ +#ifndef _TARS2DART_H +#define _TARS2DART_H + +#include "parse.h" + +#include +#include +#include + +#define TARS_PACKAGE ".tup.tars" +#define PROXY_PACKAGE ".proxy" +#define WUP_PACKAGE ".tup" + +/** + * 根据tars生成dart文件 + * 包括结构的编解码以及生成Proxy和Servant + */ +class Tars2Dart +{ +public: + Tars2Dart(); + + /** + * 设置代码生成的根目录 + * @param dir + */ + void setBaseDir(const string& dir); + + /** + * 设置包前缀 + * @param prefix + */ + void setBasePackage(const string& prefix); + + /*支持javabean规范*/ + void setWithJbr(bool bJbr) { _bWithJbr = bJbr;} + /*去掉属性的read write方法、 cloneable、equals、hashCode、clone、display*/ + void setWithCompact(bool bCompact) { _bWithCompact = bCompact;} + + /*生成枚举类时，采用int方式实现*/ + void setEnumCompact(bool bCompact) { _bEnumCompact = bCompact;} + + /*tars与json互相转换*/ + void setJsonSupport(bool bJson) { _bJson = bJson;} + + void setWithGenerateInterfaceDependencies(bool bWithGenerateInterfaceDependencies) + { + _bWithGenerateInterfaceDependencies = bWithGenerateInterfaceDependencies; + } + void setWithFilterRomTars(bool bWithFilterRomTars) + { + _bWithFilterRomTars = bWithFilterRomTars; + } + +// 增加的接口定义 + string generateConstructor(const TypePtr& vType) const; + string generateAndroidJavaParams(const vector& vParamDecl, bool needParamType, bool needOutParam) const; + + /** + * 生成 + * @param file + * @param isFramework 是否是框架 + */ + void createFile(const string& file); + + /** + * 设置TAF库的包名 + */ + void setTafPacket(const std::string& sPacket) + { + _tarsPackage = sPacket; + s_TARS_PACKAGE = sPacket + TARS_PACKAGE; + s_PROXY_PACKAGE = sPacket + PROXY_PACKAGE; + s_WUP_PACKAGE = sPacket + WUP_PACKAGE; + } + +protected: + /** + * 根据命名空间获取文件路径 + * @param ns 命名空间 + * + * @return string + */ + string getFilePath(const string& ns) const; + + string _packagePrefix; + string _baseDir; + bool _bWithJbr; + bool _bWithCompact; + bool _bEnumCompact; + bool _bJson; + + bool _bWithGenerateInterfaceDependencies; + bool _bWithFilterRomTars; + string _tarsPackage; + +protected: + + /** + * 生成某类型的解码源码 + * @param pPtr + * + * @return string + */ + string writeTo(const TypeIdPtr& pPtr) const; + + /** + * 生成某类型的编码源码 + * @param pPtr + * + * @return string + */ + string readFrom(const TypeIdPtr& pPtr) const; + + /** + * + * 这个函数目前是用不到的 + * @param pPtr + * + * @return string + */ + string display(const TypeIdPtr& pPtr) const; + + //下面是类型描述的源码生成 +protected: + + /* + * 生成某类型的初始化字符串 + * @param pPtr + * + * @return string + */ + string toTypeInit(const TypePtr& pPtr) const; + + /** + * 生成某类型的对应对象的字符串描述源码 + * @param pPtr + * + * @return string + */ + string toObjStr(const TypePtr& pPtr) const; + + /** + * 判断是否是对象类型 + */ + bool isObjType(const TypePtr& pPtr) const; + + /** + * 生成某类型的字符串描述源码 + * @param pPtr + * + * @return string + */ + string tostr(const TypePtr& pPtr) const; + + /** + * 生成内建类型的字符串源码 + * @param pPtr + * + * @return string + */ + string tostrBuiltin(const BuiltinPtr& pPtr) const; + /** + * 生成vector的字符串描述 + * @param pPtr + * + * @return string + */ + string tostrVector(const VectorPtr& pPtr) const; + + /** + * 生成map的字符串描述 + * @param pPtr + * + * @return string + */ + string tostrMap(const MapPtr& pPtr, bool bNew = false) const; + + /** + * 生成某种结构的符串描述 + * @param pPtr + * + * @return string + */ + string tostrStruct(const StructPtr& pPtr) const; + + /** + * 生成某种枚举的符串描述 + * @param pPtr + * + * @return string + */ + string tostrEnum(const EnumPtr& pPtr) const; + + /** + * 生成类型变量的解码源码 + * @param pPtr + * + * @return string + */ + string decode(const TypeIdPtr& pPtr) const; + + /** + * 生成类型变量的编码源码 + * @param pPtr + * + * @return string + */ + string encode(const TypeIdPtr& pPtr) const; + + /** + * 获得类型变量的默认值 + * @param pPtr + * + * @return string + */ + string getDefaultValue(const TypeIdPtr& pPtr, const string sp) const; + + /** + * 获得类型变量的导入类名 + * @param pPtr + * + * @return string，不需要导入返回"" + */ + vector toImportStrs(const TypePtr& pPtr) const; + + /** + * 获得类型变量的导入类名 + * @param pPtr + * @param result + * + * @return + */ + void itrToImportStrs(const TypePtr& pPtr, vector& result) const; + + /** + * 生成非原生类型的cache代码 + * @param pPtr + * + * @return string + */ + string tostrCache(const TypeIdPtr& pPtr) const; + + /** + * 生成非原生类型的新对象 + * @param pPtr + * + * @return string + */ + string generateNewElem(const TypePtr& pPtr) const; + + //以下是h和dart文件的具体生成 +protected: + /** + * 结构的md5 + * @param pPtr + * + * @return string + */ + string MD5(const StructPtr& pPtr) const; + + /** + * 生成结构的Holder类，用于引用传递 + * @param pPtr + * @param nPtr + * + * @return string + */ + string generateHolder(const StructPtr& pPtr, const NamespacePtr& nPtr) const; + + /** + * 放置默认元素用于识别map/list类型 + * @param pPtr + * @param sElemName 元素名称 + * + * @return string + */ + string generateDefautElem(const TypePtr& pPtr, const string& sElemName) const; + + /** + * 生成结构的dart文件内容 + * @param pPtr + * + * @return string + */ + string generateDart(const StructPtr& pPtr, const NamespacePtr& nPtr) const; + + /** + * 生成容器的dart源码 + * @param pPtr + * + * @return string + */ + string generateDart(const ContainerPtr& pPtr) const; + + /** + * 生成参数声明的dart文件内容 + * @param pPtr + * + * @return string + */ + string generateDart(const ParamDeclPtr& pPtr) const; + + /** + * 生成作操作的proxy的dart文件内容 + * @param pPtr + * @param cn + * + * @return string + */ + string generateDart(const OperationPtr& pPtr, const string& cn) const; + + /** + * 生成操作dart文件函数调用分发的源码 + * @param pPtr + * @param cn + * + * @return string + */ + string generateDispatchJava(const OperationPtr& pPtr, const string& cn) const; + + /** + * 生成接口的dart文件的源码 + * @param pPtr + * @param nPtr + * + * @return string + */ + string generateDart(const InterfacePtr& pPtr, const NamespacePtr& nPtr) const; + + /** + * 生成Proxy接口的dart文件的源码 + * @param pPtr + * @param nPtr + * + * @return string + */ + string generatePrx(const InterfacePtr& pPtr, const NamespacePtr& nPtr) const; + + /** + * 生成Proxy帮助类的dart文件的源码 + * @param pPtr + * @param nPtr + * + * @return string + */ + string generatePrxHelper(const InterfacePtr& pPtr, const NamespacePtr& nPtr) const; + + /** + * 生成Proxy回调类的dart文件的源码 + * @param pPtr + * @param nPtr + * + * @return string + */ + string generatePrxCallback(const InterfacePtr& pPtr, const NamespacePtr& nPtr) const; + + /** + * 生成枚举的头文件源码 + * @param pPtr + * + * @return string + */ + string generateDart(const EnumPtr& pPtr, const NamespacePtr& nPtr) const; + + /** + * 生成常量dart源码 + * @param pPtr + * + * @return string + */ + void generateDart(const ConstPtr& pPtr, const NamespacePtr& nPtr) const; + + /** + * 生成名字空间dart文件源码 + * @param pPtr + * + * @return string + */ + void generateDart(const NamespacePtr& pPtr) const; + + /** + * 生成每个tars文件的dart文件源码 + * @param pPtr + * + * @return string + */ + void generateDart(const ContextPtr& pPtr) const; + +private: + std::string s_TARS_PACKAGE; + std::string s_PROXY_PACKAGE; + std::string s_HOLDER_PACKAGE; + std::string s_SERVER_PACKAGE; + std::string s_WUP_PACKAGE; +}; + +#endif + + diff --git a/tools/tars2dart/tars_filter.cpp b/tools/tars2dart/tars_filter.cpp new file mode 100644 index 00000000..81d46108 --- /dev/null +++ b/tools/tars2dart/tars_filter.cpp @@ -0,0 +1,61 @@ +/** + * Tencent is pleased to support the open source community by making Tars available. + * + * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ +#include "tars_filter.h" + +TarsFilter::TarsFilter() { + addSid("TRom::E_ROM_DEVICE_TYPE"); + addSid("TRom::EAPNTYPE"); + addSid("TRom::EIPType"); + addSid("TRom::ELOGINRET"); + addSid("TRom::ENETTYPE"); + addSid("TRom::IPListReq"); + addSid("TRom::IPListRsp"); + addSid("TRom::JoinIPInfo"); + addSid("TRom::LoginReq"); + addSid("TRom::LoginRsp"); + addSid("TRom::RomBaseInfo"); + addSid("TRom::SECPROXY_RETCODE"); + addSid("TRom::SecureReq"); + addSid("TRom::SecureRsp"); +} + +void TarsFilter::addSid(const std::string& sid) { + mFilterTarsSidMap.insert(std::pair(sid, true)); +} + +void TarsFilter::filterStructs( + const std::map& orignalMap + , std::map& resultMap) const { + for (std::map::const_iterator it = orignalMap.begin() + ; it != orignalMap.end(); ++it) { + if (mFilterTarsSidMap.find(it->first) != mFilterTarsSidMap.end()) { + continue; + } + resultMap.insert(std::pair(it->first, it->second)); + } +} + +void TarsFilter::filterEnums( + const std::map& orignalMap + , std::map& resultMap) const { + for (std::map::const_iterator it = orignalMap.begin() + ; it != orignalMap.end(); ++it) { + if (mFilterTarsSidMap.find(it->first) != mFilterTarsSidMap.end()) { + continue; + } + resultMap.insert(std::pair(it->first, it->second)); + } +} diff --git a/tools/tars2dart/tars_filter.h b/tools/tars2dart/tars_filter.h new file mode 100644 index 00000000..b3eb3900 --- /dev/null +++ b/tools/tars2dart/tars_filter.h @@ -0,0 +1,39 @@ +/** + * Tencent is pleased to support the open source community by making Tars available. + * + * Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ +#ifndef TARS_FILTER_H_WILEY +#define TARS_FILTER_H_WILEY + +#include "parse.h" +#include + +class TarsFilter { +public: + TarsFilter(); + + void filterStructs(const std::map& orignalMap + , std::map& resultMap) const; + void filterEnums(const std::map& orignalMap + , std::map& resultMap) const; + +private: + void addSid(const std::string& sid); + + std::map mFilterTarsSidMap; +}; + + + +#endif /* TARS_FILTER_H_ */