| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * 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 "../base_types.hpp" |
| #include "CPPCodeGenerator.hpp" |
| #include "Log.hpp" |
| #include "Helper.hpp" |
| #include <iostream> |
| |
| namespace apache { |
| namespace geode { |
| namespace client { |
| namespace pdx_auto_serializer { |
| int CPPCodeGenerator::s_classId = -1; |
| |
| std::string CPPCodeGenerator::s_GFSerializerNamespace = |
| "apache::geode::client::PdxAutoSerializable"; |
| std::string CPPCodeGenerator::s_TempVarPrefix = "var_"; |
| |
| /** The option name for classId. */ |
| std::string CPPCodeGenerator::s_ClassIdOption = "classId"; |
| |
| /** The option name for the output directory. */ |
| std::string CPPCodeGenerator::s_OutDirOption = "outDir"; |
| |
| /** |
| * The directory to be used in generated files for the included headers. |
| * If not provided the path of the header file as provided on |
| * command-line is used. |
| */ |
| std::string CPPCodeGenerator::s_HeaderDirOption = "headerDir"; |
| |
| /** |
| * The option name for the suffix to use for generated files and classes. |
| */ |
| std::string CPPCodeGenerator::s_GenSuffixOption = "suffix"; |
| |
| // CodeGenerator method implementations |
| |
| void CPPCodeGenerator::getOptions(OptionMap& options) const { |
| std::pair<bool, std::string> optionPair; |
| // optionPair.first = true; |
| // optionPair.second |
| // = "\tThe base classId to be used for the serializers [>= 0, < 2^31] " |
| // "(SINGLE,OPTIONAL)"; |
| // options[s_ClassIdOption] = optionPair; |
| |
| optionPair.second = |
| "\tThe output directory of the generated files " |
| "(SINGLE,OPTIONAL)"; |
| options[s_OutDirOption] = optionPair; |
| |
| optionPair.second = |
| "\tThe suffix of the generated filenames " |
| "-- default is '" + |
| defaultGenSuffix() + "' (SINGLE,OPTIONAL)"; |
| options[s_GenSuffixOption] = optionPair; |
| |
| // optionPair.second = "\tThe directory to be used in generated files for " |
| // "the included headers.\n\t\t\tIf not provided the " |
| // "path of the header file as provided on the " |
| // "command-line is used (SINGLE,OPTIONAL)"; |
| // options[s_HeaderDirOption] = optionPair; |
| } |
| |
| void CPPCodeGenerator::init(PropertyMap& properties) { |
| Helper::getSingleProperty(properties, s_OutDirOption, m_outDir); |
| m_outDir += '/'; |
| std::string classIdStr; |
| bool classIdFound = |
| Helper::getSingleProperty(properties, s_ClassIdOption, classIdStr); |
| if (!classIdFound) { |
| // Log::warn(m_moduleName, "No classId given or found for the " |
| // "class; will not generate the classId method."); |
| } else { |
| try { |
| Helper::lexical_cast(classIdStr, s_classId); |
| } catch (const std::invalid_argument&) { |
| Log::fatal(m_moduleName, "classId not a valid integer"); |
| } |
| if (s_classId < 0) { |
| Log::fatal(m_moduleName, "classId should be >= 0."); |
| } |
| } |
| Helper::getSingleProperty(properties, s_GenSuffixOption, m_genSuffix); |
| if (m_genSuffix.length() == 0) { |
| m_genSuffix = defaultGenSuffix(); |
| } |
| if (Helper::getSingleProperty(properties, s_HeaderDirOption, m_headerDir) && |
| (m_headerDir.length() > 0)) { |
| char lastChar = m_headerDir[m_headerDir.length() - 1]; |
| if (lastChar != '/' && lastChar != '\\') { |
| m_headerDir += '/'; |
| } |
| } |
| } |
| |
| void CPPCodeGenerator::initClass(const TypeInfo& classInfo) { |
| std::string namespacePrefixString = ""; |
| StringVector nameSpaceList = classInfo.m_namespaces; |
| for (StringVector::iterator iter = nameSpaceList.begin(); |
| iter != nameSpaceList.end(); ++iter) { |
| namespacePrefixString += *iter; |
| } |
| std::string outFile = ""; |
| if (namespacePrefixString == "") { |
| outFile = m_outDir + classInfo.m_nameOrSize + m_genSuffix + ".cpp"; |
| } else { |
| outFile = m_outDir + namespacePrefixString + "_" + classInfo.m_nameOrSize + |
| m_genSuffix + ".cpp"; |
| } |
| Log::info(m_moduleName, "Writing: " + outFile); |
| m_cppFormatter->open(outFile); |
| m_classInfo = classInfo; |
| } |
| |
| void CPPCodeGenerator::addFileHeader(int argc, char** argv) { |
| *m_cppFormatter |
| << "// This is auto generated file using \"pdxautoserializer\"" |
| << "\n"; |
| *m_cppFormatter |
| << "// Do not edit this file, unless you are sure what you are doing " |
| << "\n"; |
| *m_cppFormatter << "// Options used to generate this files are : " |
| << "\n"; |
| for (int i = 1; i < argc; i++) { |
| *m_cppFormatter << "//\t" << argv[i] << "\n"; |
| } |
| *m_cppFormatter << "\n"; |
| } |
| |
| void CPPCodeGenerator::addReferences(const ReferenceVector& references) { |
| for (ReferenceVectorIterator referenceIterator = references.begin(); |
| referenceIterator != references.end(); ++referenceIterator) { |
| if (referenceIterator->m_kind == Reference::HEADER) { |
| std::string headerPath; |
| std::string::size_type lastSlash = |
| referenceIterator->m_path.find_last_of("/\\"); |
| if (lastSlash != std::string::npos) { |
| headerPath = |
| m_headerDir + referenceIterator->m_path.substr(lastSlash + 1); |
| } else { |
| headerPath = m_headerDir + referenceIterator->m_path; |
| } |
| *m_cppFormatter << "#include \"" << headerPath << "\"\n\n"; |
| } |
| } |
| *m_cppFormatter << "#include <geode/PdxWriter.hpp>" |
| << "\n"; |
| *m_cppFormatter << "#include <geode/PdxReader.hpp>" |
| << "\n"; |
| *m_cppFormatter << "#include <geode/PdxAutoSerializer.hpp>" |
| << "\n\n"; |
| } |
| |
| void CPPCodeGenerator::startClass(const VariableVector& members) { |
| genNamespaceHeader(m_classInfo.m_namespaces, m_cppFormatter); |
| } |
| // Ticket #905 Changes starts here |
| void CPPCodeGenerator::addTryBlockStart(const Method::Type type) { |
| switch (type) { |
| case Method::TODATA: { |
| *m_cppFormatter << "try\n"; |
| *m_cppFormatter << "{\n"; |
| break; |
| } |
| case Method::FROMDATA: { |
| *m_cppFormatter << "try\n"; |
| *m_cppFormatter << "{\n"; |
| break; |
| } |
| default: { break; } |
| } |
| return; |
| } |
| void CPPCodeGenerator::finishTryBlock(const Method::Type type) { |
| switch (type) { |
| case Method::TODATA: { |
| *m_cppFormatter << "}\n"; |
| *m_cppFormatter |
| << "catch(apache::geode::client::IllegalStateException exception)\n"; |
| *m_cppFormatter << "{\n"; |
| *m_cppFormatter << "}\n"; |
| break; |
| } |
| case Method::FROMDATA: { |
| *m_cppFormatter << "}\n"; |
| *m_cppFormatter |
| << "catch(apache::geode::client::IllegalStateException exception)\n"; |
| *m_cppFormatter << "{\n"; |
| *m_cppFormatter << "}\n"; |
| break; |
| } |
| default: { break; } |
| } |
| return; |
| } |
| // Ticket #905 Changes ends here |
| |
| void CPPCodeGenerator::startMethod(const Method::Type type, |
| const std::string& varName, |
| const std::string& methodPrefix) { |
| std::string var; |
| StringVector varVec; |
| std::string className = getTypeString(m_classInfo); |
| |
| switch (type) { |
| case Method::TODATA: { |
| varVec.push_back( |
| "std::shared_ptr<apache::geode::client::PdxWriter> __var"); |
| |
| genFunctionHeader("toData", className, "void", varVec, true, false, |
| m_cppFormatter, methodPrefix); |
| break; |
| } |
| case Method::FROMDATA: { |
| varVec.push_back( |
| "std::shared_ptr<apache::geode::client::PdxReader> __var "); |
| |
| genFunctionHeader("fromData", className, "void", varVec, true, false, |
| m_cppFormatter, methodPrefix); |
| break; |
| } |
| default: { throw std::invalid_argument("unexpected execution"); } |
| } |
| } |
| |
| void CPPCodeGenerator::genMethod(const Method::Type type, |
| const std::string& varName, |
| const VariableInfo& var) { |
| switch (type) { |
| case Method::TODATA: { |
| if (var.m_markPdxUnreadField == true) { |
| *m_cppFormatter << varName << "->writeUnreadFields(" << var.m_name; |
| } else { |
| *m_cppFormatter << s_GFSerializerNamespace << "::writePdxObject(" |
| << varName << ", " |
| << "\"" << var.m_name << "\"" |
| << ", " << var.m_name; |
| if (var.m_type.m_kind & TypeKind::ARRAY) { |
| *m_cppFormatter << ", " << var.m_type.m_nameOrSize; |
| if (var.m_type.m_nameOfArrayElemSize.size() > 0) { |
| *m_cppFormatter << ", " << var.m_type.m_nameOfArrayElemSize; |
| } |
| } |
| } |
| *m_cppFormatter << ");\n"; |
| if (var.m_markIdentityField == true) { |
| *m_cppFormatter << varName << "->markIdentityField(" |
| << "\"" << var.m_name << "\"" |
| << ");" |
| << "\n" |
| << "\n"; |
| } |
| break; |
| } |
| case Method::FROMDATA: { |
| if (var.m_markPdxUnreadField == true) { |
| *m_cppFormatter << var.m_name << " = " << varName |
| << "->readUnreadFields("; |
| } else { |
| *m_cppFormatter << s_GFSerializerNamespace << "::readPdxObject(" |
| << varName << ", " |
| << "\"" << var.m_name << "\"" |
| << ", " << var.m_name; |
| if (var.m_type.m_kind & TypeKind::ARRAY) { |
| *m_cppFormatter << ", " << var.m_type.m_nameOrSize; |
| if (var.m_type.m_nameOfArrayElemSize.size() > 0) { |
| *m_cppFormatter << ", " << var.m_type.m_nameOfArrayElemSize; |
| } |
| } |
| } |
| *m_cppFormatter << ");\n"; |
| break; |
| } |
| default: { throw std::invalid_argument("unexpected execution"); } |
| } |
| } |
| |
| void CPPCodeGenerator::endMethod(const Method::Type type, |
| const std::string& varName) { |
| switch (type) { |
| case Method::TODATA: { |
| genFunctionFooter(m_cppFormatter); |
| break; |
| } |
| case Method::FROMDATA: { |
| //*m_cppFormatter << "return this;\n"; |
| genFunctionFooter(m_cppFormatter); |
| break; |
| } |
| default: { throw std::invalid_argument("unexpected execution"); } |
| } |
| } |
| |
| void CPPCodeGenerator::genTypeId(const std::string& methodPrefix) { |
| if (s_classId >= 0) { |
| StringVector varVec; |
| std::string className = getTypeString(m_classInfo); |
| |
| genFunctionHeader("classId", className, "int32_t", varVec, true, true, |
| m_cppFormatter, methodPrefix); |
| *m_cppFormatter << "return " << s_classId << ";\n"; |
| genFunctionFooter(m_cppFormatter); |
| ++s_classId; |
| } |
| } |
| |
| void CPPCodeGenerator::genClassNameMethod( |
| std::map<std::string, std::string>& classNameStringMap, |
| const std::string& methodPrefix) { |
| StringVector varVec; |
| std::string className = getTypeString(m_classInfo); |
| std::map<std::string, std::string>::iterator found = |
| classNameStringMap.find(className); |
| genFunctionHeader("getClassName", className, "const char*", varVec, true, |
| true, m_cppFormatter, methodPrefix); |
| |
| if (found != classNameStringMap.end()) { |
| *m_cppFormatter << "return " |
| << "\"" << found->second << "\"" |
| << ";\n"; |
| } else { |
| *m_cppFormatter << "return " |
| << "\""; |
| for (StringVector::const_iterator itr = m_classInfo.m_namespaces.begin(); |
| itr != m_classInfo.m_namespaces.end(); ++itr) { |
| *m_cppFormatter << *itr << "."; |
| } |
| *m_cppFormatter << className << "\"" |
| << ";\n"; |
| } |
| genFunctionFooter(m_cppFormatter); |
| } |
| |
| void CPPCodeGenerator::genCreateDeserializable( |
| const std::string& methodPrefix) { |
| StringVector varVec; |
| std::string className = getTypeString(m_classInfo); |
| genFunctionHeader("createDeserializable", className, |
| "apache::geode::client::PdxSerializable*", varVec, true, |
| false, m_cppFormatter, methodPrefix); |
| *m_cppFormatter << "return new " << className << "()" |
| << ";\n"; |
| genFunctionFooter(m_cppFormatter); |
| } |
| |
| void CPPCodeGenerator::endClass() { |
| genNamespaceFooter(m_classInfo.m_namespaces, m_cppFormatter); |
| m_cppFormatter->close(); |
| } |
| |
| void CPPCodeGenerator::cleanup() { |
| std::string fileName; |
| if (m_cppFormatter != NULL) { |
| fileName = m_cppFormatter->getFileName(); |
| m_cppFormatter->close(); |
| if (fileName.length() > 0) { |
| remove(fileName.c_str()); |
| } |
| } |
| } |
| |
| // End CodeGenerator methods |
| |
| std::string CPPCodeGenerator::defaultGenSuffix() const { |
| return "Serializable"; |
| } |
| |
| std::string CPPCodeGenerator::getNamespacePrefix( |
| const StringVector& namespaces) const { |
| std::string namespacePrefix; |
| for (StringVectorIterator namespaceIterator = namespaces.begin(); |
| namespaceIterator != namespaces.end(); ++namespaceIterator) { |
| namespacePrefix += *namespaceIterator + "::"; |
| } |
| return namespacePrefix; |
| } |
| |
| std::string CPPCodeGenerator::getTypeString(const TypeInfo& type, |
| bool prependNS, |
| std::string* postVarStr, |
| StringSet* templateArgs) const { |
| std::string typeString; |
| if (type.m_kind & TypeKind::VALUE) { |
| if (prependNS) { |
| typeString += getNamespacePrefix(type.m_namespaces); |
| } |
| typeString += type.m_nameOrSize; |
| } else if (type.m_kind & TypeKind::TEMPLATEPARAM) { |
| typeString += type.m_nameOrSize; |
| if (templateArgs != NULL) { |
| templateArgs->insert(type.m_nameOrSize); |
| } |
| } else if (type.m_kind & TypeKind::POINTER) { |
| assert(type.m_numChildren == 1); |
| assert(type.m_children != NULL); |
| |
| typeString += |
| getTypeString(*(type.m_children), prependNS, postVarStr, templateArgs); |
| if (postVarStr == NULL || postVarStr->length() == 0) { |
| typeString += '*'; |
| } else { |
| typeString += "(*"; |
| postVarStr->insert(0, ")"); |
| } |
| } else if (type.m_kind & TypeKind::REFERENCE) { |
| assert(type.m_numChildren == 1); |
| assert(type.m_children != NULL); |
| |
| typeString += |
| getTypeString(*(type.m_children), prependNS, postVarStr, templateArgs); |
| if (postVarStr == NULL || postVarStr->length() == 0) { |
| typeString += '&'; |
| } else { |
| typeString += "(&"; |
| postVarStr->insert(0, ")"); |
| } |
| } else if (type.m_kind & TypeKind::TEMPLATE) { |
| if (prependNS) { |
| typeString += getNamespacePrefix(type.m_namespaces); |
| } |
| typeString += type.m_nameOrSize + "< "; |
| if (type.m_numChildren > 0) { |
| typeString += |
| getTypeString(*type.m_children, prependNS, postVarStr, templateArgs); |
| for (int childIndex = 1; childIndex < type.m_numChildren; ++childIndex) { |
| typeString += ", "; |
| typeString += getTypeString(type.m_children[childIndex], prependNS, |
| postVarStr, templateArgs); |
| } |
| } |
| typeString += " >"; |
| } else if (type.m_kind & TypeKind::ARRAY) { |
| assert(type.m_numChildren == 1); |
| assert(type.m_children != NULL); |
| |
| typeString += |
| getTypeString(*(type.m_children), prependNS, postVarStr, templateArgs); |
| if (postVarStr == NULL) { |
| typeString += '*'; |
| } else { |
| postVarStr->append("[]"); |
| } |
| } else if (type.m_kind & TypeKind::FIXEDARRAY) { |
| assert(type.m_numChildren == 1); |
| assert(type.m_children != NULL); |
| |
| typeString += |
| getTypeString(*(type.m_children), prependNS, postVarStr, templateArgs); |
| if (postVarStr == NULL) { |
| typeString += '*'; |
| } else { |
| postVarStr->append("[" + type.m_nameOrSize + "]"); |
| } |
| } |
| return typeString; |
| } |
| |
| void CPPCodeGenerator::genNamespaceHeader(const StringVector& namespaces, |
| OutputFormatter* formatter) { |
| for (StringVectorIterator namespaceIterator = namespaces.begin(); |
| namespaceIterator != namespaces.end(); ++namespaceIterator) { |
| *formatter << "namespace " << *namespaceIterator << "\n{\n"; |
| } |
| *formatter << '\n'; |
| } |
| |
| void CPPCodeGenerator::genFunctionHeader(const std::string& functionName, |
| const std::string& className, |
| const std::string& returnType, |
| const StringVector& arguments, |
| bool isDefinition, bool isConst, |
| OutputFormatter* formatter, |
| const std::string& methodPrefix) { |
| *formatter << returnType << ' '; |
| if (isDefinition) { |
| if (methodPrefix != "") { |
| *formatter << methodPrefix << className << "::"; |
| } else { |
| *formatter << className << "::"; |
| } |
| } |
| *formatter << functionName << "("; |
| if (arguments.size() > 0) { |
| StringVectorIterator argumentIterator = arguments.begin(); |
| *formatter << *argumentIterator; |
| while (++argumentIterator != arguments.end()) { |
| *formatter << ", " << *argumentIterator; |
| } |
| } |
| *formatter << ")"; |
| if (isConst) { |
| *formatter << " const"; |
| } |
| *formatter << "\n{\n"; |
| } |
| |
| void CPPCodeGenerator::genFunctionFooter(OutputFormatter* formatter) { |
| *formatter << "}\n\n"; |
| } |
| |
| void CPPCodeGenerator::genNamespaceFooter(const StringVector& namespaces, |
| OutputFormatter* formatter) { |
| for (StringVector::size_type i = 0; i < namespaces.size(); ++i) { |
| *formatter << "}\n"; |
| } |
| } |
| |
| CodeGenerator* CPPCodeGenerator::create() { return new CPPCodeGenerator(); } |
| |
| CPPCodeGenerator::CPPCodeGenerator() |
| : m_cppFormatter(new OutputFormatter()), |
| m_outDir("."), |
| m_moduleName("CPPCodeGenerator") {} |
| |
| CPPCodeGenerator::~CPPCodeGenerator() { |
| if (m_cppFormatter != NULL) { |
| m_cppFormatter->close(); |
| delete m_cppFormatter; |
| m_cppFormatter = NULL; |
| } |
| } |
| } // namespace pdx_auto_serializer |
| } // namespace client |
| } // namespace geode |
| } // namespace apache |
