Writer.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
 * Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
 
// Simox
#include <SimoxUtility/algorithm/string.h>
 
// Header
#include "Writer.h"
 
// ArmarX
 
namespace armarx::aron::codegenerator::cpp
{
 
    // Function to convert camel case
    // string to snake case string
    std::string
    camelToSnake(const std::string& str)
    {
 
        // Empty String
        std::string result = "";
 
        // Append first character(in lower case)
        // to result string
        char c = std::tolower(str[0]);
        result += (char(c));
 
        // Traverse the string from
        // ist index to last index
        for (unsigned int i = 1; i < str.length(); i++)
        {
 
            char ch = str[i];
 
            // Check if the character is upper case
            // then append '_' and such character
            // (in lower case) to result string
            if (std::isupper(ch))
            {
                result = result + '_';
                result += char(std::tolower(ch));
            }
 
            // If the character is lower case then
            // add such character into result string
            else
            {
                result = result + ch;
            }
        }
 
        // return the result
        return result;
    }
 
    Writer::Writer(const std::string& producerName,
                   const std::vector<std::string>& additionalIncludesFromXMLFile) :
        CodeWriter(producerName, additionalIncludesFromXMLFile)
    {
        addSpecificWriterMethods();
        addSpecificReaderMethods();
    }
 
    void
    Writer::addSpecificWriterMethods()
    {
        // DictData stuff
        {
            {
                codegenerator::WriterInfo toAron;
                toAron.methodName = "toAron";
                toAron.returnType = "armarx::aron::data::DictPtr";
                toAron.writerClassType = "armarx::aron::data::writer::VariantWriter";
                toAron.include =
                    "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
                toAron.enforceConversion = "armarx::aron::data::Dict::DynamicCastAndCheck";
                toAron.override = true;
                dictDataWriters.push_back(toAron);
            }
            {
                codegenerator::WriterInfo toAronDTO;
                toAronDTO.methodName = "toAronDTO";
                toAronDTO.returnType = "armarx::aron::data::dto::DictPtr";
                toAronDTO.writerClassType = "armarx::aron::data::writer::VariantWriter";
                toAronDTO.include =
                    "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
                toAronDTO.enforceConversion = "armarx::aron::data::Dict::DynamicCastAndCheck";
                toAronDTO.enforceMemberAccess = "->toAronDictDTO()";
                toAronDTO.override = true;
                dictDataWriters.push_back(toAronDTO);
            }
            {
                // The toAron Serializer is visible by default
                codegenerator::WriterInfo ToAronType;
                ToAronType.methodName = "ToAronType";
                ToAronType.returnType = "armarx::aron::type::ObjectPtr";
                ToAronType.writerClassType = "armarx::aron::type::writer::VariantWriter";
                ToAronType.include =
                    "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
                ToAronType.enforceConversion = "armarx::aron::type::Object::DynamicCastAndCheck";
                initialDictTypeWriters.push_back(ToAronType);
            }
            {
                // The toAron Serializer is visible by default
                codegenerator::WriterInfo ToAronTypeDTO;
                ToAronTypeDTO.methodName = "ToAronTypeDTO";
                ToAronTypeDTO.returnType = "armarx::aron::type::dto::AronObjectPtr";
                ToAronTypeDTO.writerClassType = "armarx::aron::type::writer::VariantWriter";
                ToAronTypeDTO.include =
                    "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
                ToAronTypeDTO.enforceConversion = "armarx::aron::type::Object::DynamicCastAndCheck";
                ToAronTypeDTO.enforceMemberAccess = "->toAronObjectDTO()";
                initialDictTypeWriters.push_back(ToAronTypeDTO);
            }
        }
 
        // IntEnum stuff
        {
            {
                codegenerator::WriterInfo toAron;
                toAron.methodName = "toAron";
                toAron.returnType = "armarx::aron::data::IntPtr";
                toAron.writerClassType = "armarx::aron::data::writer::VariantWriter";
                toAron.include =
                    "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
                toAron.enforceConversion = "armarx::aron::data::Int::DynamicCastAndCheck";
                toAron.override = true;
                intEnumDataWriters.push_back(toAron);
            }
            {
                codegenerator::WriterInfo toAronDTO;
                toAronDTO.methodName = "toAronDTO";
                toAronDTO.returnType = "armarx::aron::data::dto::AronIntPtr";
                toAronDTO.writerClassType = "armarx::aron::data::writer::VariantWriter";
                toAronDTO.include =
                    "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
                toAronDTO.enforceConversion = "armarx::aron::data::Int::DynamicCastAndCheck";
                toAronDTO.enforceMemberAccess = "->toAronIntDTO()";
                toAronDTO.override = true;
                intEnumDataWriters.push_back(toAronDTO);
            }
            {
                // The toAron Serializer is visible by default
                codegenerator::WriterInfo ToAronType;
                ToAronType.methodName = "ToAronType";
                ToAronType.returnType = "armarx::aron::type::IntEnumPtr";
                ToAronType.writerClassType = "armarx::aron::type::writer::VariantWriter";
                ToAronType.include =
                    "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
                ToAronType.enforceConversion = "armarx::aron::type::IntEnum::DynamicCastAndCheck";
                initialIntEnumTypeWriters.push_back(ToAronType);
            }
            {
                // The toAron Serializer is visible by default
                codegenerator::WriterInfo ToAronTypeDTO;
                ToAronTypeDTO.methodName = "ToAronTypeDTO";
                ToAronTypeDTO.returnType = "armarx::aron::type::dto::IntEnumPtr";
                ToAronTypeDTO.writerClassType = "armarx::aron::type::writer::VariantWriter";
                ToAronTypeDTO.include =
                    "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
                ToAronTypeDTO.enforceConversion =
                    "armarx::aron::type::IntEnum::DynamicCastAndCheck";
                ToAronTypeDTO.enforceMemberAccess = "->toIntEnumDTO()";
                initialIntEnumTypeWriters.push_back(ToAronTypeDTO);
            }
        }
    }
 
    void
    Writer::addSpecificReaderMethods()
    {
        // Dict stuff
        {
            {
                codegenerator::StaticReaderInfo fromAron;
                fromAron.methodName = "FromAron";
                fromAron.argumentType = "armarx::aron::data::DictPtr";
                fromAron.returnType = OWN_TYPE_NAME;
                staticDictDataReaders.push_back(fromAron);
            }
            {
                codegenerator::StaticReaderInfo fromAronDTO;
                fromAronDTO.methodName = "FromAron";
                fromAronDTO.argumentType = "armarx::aron::data::dto::DictPtr";
                fromAronDTO.returnType = OWN_TYPE_NAME;
                staticDictDataReaders.push_back(fromAronDTO);
            }
            {
                codegenerator::ReaderInfo fromAron;
                fromAron.methodName = "fromAron";
                fromAron.argumentType = "armarx::aron::data::DictPtr";
                fromAron.readerClassType = "armarx::aron::data::reader::VariantReader";
                fromAron.include =
                    "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
                fromAron.override = true;
                dictDataReaders.push_back(fromAron);
            }
            {
                codegenerator::ReaderInfo fromAronDTO;
                fromAronDTO.methodName = "fromAron";
                fromAronDTO.argumentType = "armarx::aron::data::dto::DictPtr";
                fromAronDTO.readerClassType = "armarx::aron::data::reader::VariantReader";
                fromAronDTO.include =
                    "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
                fromAronDTO.enforceConversion = "std::make_shared<armarx::aron::data::Dict>";
                fromAronDTO.override = true;
                dictDataReaders.push_back(fromAronDTO);
            }
        }
 
        // IntEnum stuff
        {
            {
                codegenerator::StaticReaderInfo fromAron;
                fromAron.methodName = "FromAron";
                fromAron.argumentType = "armarx::aron::data::IntPtr";
                fromAron.returnType = OWN_TYPE_NAME;
                staticIntEnumDataReaders.push_back(fromAron);
            }
            {
                codegenerator::StaticReaderInfo fromAronDTO;
                fromAronDTO.methodName = "FromAron";
                fromAronDTO.argumentType = "armarx::aron::data::dto::AronIntPtr";
                fromAronDTO.returnType = OWN_TYPE_NAME;
                staticIntEnumDataReaders.push_back(fromAronDTO);
            }
            {
                codegenerator::ReaderInfo fromAron;
                fromAron.methodName = "fromAron";
                fromAron.argumentType = "armarx::aron::data::IntPtr";
                fromAron.readerClassType = "armarx::aron::data::reader::VariantReader";
                fromAron.include =
                    "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
                fromAron.override = true;
                intEnumDataReaders.push_back(fromAron);
            }
            {
                codegenerator::ReaderInfo fromAronDTO;
                fromAronDTO.methodName = "fromAron";
                fromAronDTO.argumentType = "armarx::aron::data::dto::AronIntPtr";
                fromAronDTO.readerClassType = "armarx::aron::data::reader::VariantReader";
                fromAronDTO.include =
                    "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
                fromAronDTO.enforceConversion = "std::make_shared<armarx::aron::data::Int>";
                fromAronDTO.override = true;
                intEnumDataReaders.push_back(fromAronDTO);
            }
        }
    }
 
    void
    Writer::generateTypeObjects(const std::vector<typereader::GenerateObjectInfo>& generateObjects)
    {
        for (const auto& publicGenerateObjectType : generateObjects)
        {
            const auto type = publicGenerateObjectType.correspondingType;
 
            //std::cout << "Generating: " << nav->getName() << std::endl;
 
            // Convert to Object type and create class object
            ARMARX_CHECK_NOT_NULL(type);
 
            generator::ObjectClass generator(*type);
            CppClassPtr c = setupBasicCppClass(publicGenerateObjectType, generator);
            setupMemberFields(c, publicGenerateObjectType.doc_members, generator);
 
            // check for templates
            if (!type->getTemplates().empty())
            {
                std::vector<std::string> tmpl;
                std::vector<std::string> tmpl_requires;
                for (auto& t : type->getTemplates())
                {
                    tmpl_requires.push_back("armarx::aron::cpp::isAronGeneratedObject<" + t + ">");
                    tmpl.push_back("class " + t);
                }
                std::string templateDef = "template <" + simox::alg::join(tmpl, ", ") + ">";
                std::string requiresDef = "requires " + simox::alg::join(tmpl_requires, " && ");
                c->setTemplates(templateDef + "\n" + requiresDef);
            }
 
            // check for inheritance
            if (type->getExtends() != nullptr)
            {
                generator::ObjectClass extendsSerializer(*type->getExtends());
                c->addInherit("public " + extendsSerializer.getFullInstantiatedCppTypename());
            }
            else
            {
                c->addInherit("public armarx::aron::cpp::AronGeneratedObject<" +
                              generator.getFullClassCppTypename() + ">");
            }
 
            // Writermethods
            for (codegenerator::WriterInfo info : dictDataWriters)
            {
                if (info.returnType == OWN_TYPE_NAME)
                {
                    info.returnType = generator.getFullClassCppTypename();
                }
 
                if (!info.include.empty())
                {
                    c->addInclude(info.include);
                }
 
                CppMethodPtr convert = generator.toSpecializedDataWriterMethod(info);
                c->addPublicMethod(convert);
            }
 
            // Add methods to set the member variables
            // also resolve the original class name if the return type is set to special
            for (codegenerator::StaticReaderInfo info : staticDictDataReaders)
            {
                if (info.returnType == OWN_TYPE_NAME)
                {
                    info.returnType = generator.getFullClassCppTypename();
                }
                if (info.argumentType == OWN_TYPE_NAME)
                {
                    info.argumentType = generator.getFullClassCppTypename();
                }
 
                CppMethodPtr convert = generator.toSpecializedStaticDataReaderMethod(info);
                c->addPublicMethod(convert);
            }
 
            // Add methods to set the member variables
            for (codegenerator::ReaderInfo info : dictDataReaders)
            {
                if (info.argumentType == OWN_TYPE_NAME)
                {
                    info.argumentType = generator.getFullClassCppTypename();
                }
 
                if (!info.include.empty())
                {
                    c->addInclude(info.include);
                }
 
                CppMethodPtr convert = generator.toSpecializedDataReaderMethod(info);
                c->addPublicMethod(convert);
            }
 
            // Typewritermethods
            for (codegenerator::WriterInfo info : initialDictTypeWriters)
            {
                if (info.returnType == OWN_TYPE_NAME)
                {
                    info.returnType = generator.getFullClassCppTypename();
                }
 
                if (!info.include.empty())
                {
                    c->addInclude(info.include);
                }
                CppMethodPtr convert = generator.toSpecializedTypeWriterMethod(info);
                c->addPublicMethod(convert);
            }
 
            typeClasses.push_back(c);
        }
    }
 
    void
    Writer::generateTypeIntEnums(
        const std::vector<typereader::GenerateIntEnumInfo>& generateIntEnums)
    {
        for (const auto& publicGenerateIntEnumType : generateIntEnums)
        {
            const auto& nav = publicGenerateIntEnumType.correspondingType;
            ARMARX_CHECK_NOT_NULL(nav);
 
            generator::IntEnumClass generator(*nav);
 
            // Create enum class and add to enums
            CppEnumPtr enumrepresentation = setupEnumPtr(publicGenerateIntEnumType, generator);
            typeEnums.push_back(enumrepresentation);
 
            // Generate aron wrapper class and add to classes
            CppClassPtr c = setupBasicCppClass(publicGenerateIntEnumType, generator);
            c->addInclude("<RobotAPI/libraries/aron/core/data/variant/primitive/Int.h>");
 
            setupMemberFields(c, publicGenerateIntEnumType.doc_values, generator);
 
            c->addInherit("public armarx::aron::cpp::AronGeneratedIntEnum<" +
                          generator.getFullClassCppTypename() + ">");
 
            // ctor
            c->addCtor(generator.toEnumCtor(c->getName()));
 
            CppMethodPtr toString = generator.toToStringMethod();
            c->addPublicMethod(toString);
 
            CppMethodPtr fromString = generator.toFromStringMethod();
            c->addPublicMethod(fromString);
 
            CppMethodPtr intConversion = generator.toIntMethod();
            c->addPublicMethod(intConversion);
 
            CppMethodPtr enumAssignment = generator.toEnumAssignmentMethod();
            c->addPublicMethod(enumAssignment);
 
            CppMethodPtr enumAssignment2 = generator.toCopyAssignmentMethod();
            c->addPublicMethod(enumAssignment2);
 
            CppMethodPtr enumAssignment3 = generator.toIntAssignmentMethod();
            c->addPublicMethod(enumAssignment3);
 
            // Writermethods
            for (codegenerator::WriterInfo info : intEnumDataWriters)
            {
                if (info.returnType == OWN_TYPE_NAME)
                {
                    info.returnType = generator.getFullClassCppTypename();
                }
 
                if (!info.include.empty())
                {
                    c->addInclude(info.include);
                }
 
                CppMethodPtr convert = generator.toSpecializedDataWriterMethod(info);
                c->addPublicMethod(convert);
            }
 
            // Add methods to set the member variables
            // also resolve the original class name if the return type is set to special
            for (codegenerator::StaticReaderInfo info : staticIntEnumDataReaders)
            {
                if (info.returnType == OWN_TYPE_NAME)
                {
                    info.returnType = generator.getFullClassCppTypename();
                }
                if (info.argumentType == OWN_TYPE_NAME)
                {
                    info.argumentType = generator.getFullClassCppTypename();
                }
 
                CppMethodPtr convert = generator.toSpecializedStaticDataReaderMethod(info);
                c->addPublicMethod(convert);
            }
 
            // Add methods to set the member variables
            for (codegenerator::ReaderInfo info : intEnumDataReaders)
            {
                if (info.argumentType == OWN_TYPE_NAME)
                {
                    info.argumentType = generator.getFullClassCppTypename();
                }
 
                if (!info.include.empty())
                {
                    c->addInclude(info.include);
                }
                CppMethodPtr convert = generator.toSpecializedDataReaderMethod(info);
                c->addPublicMethod(convert);
            }
 
            // Typewritermethods
            for (codegenerator::WriterInfo info : initialIntEnumTypeWriters)
            {
                if (info.returnType == OWN_TYPE_NAME)
                {
                    info.returnType = generator.getFullClassCppTypename();
                }
 
                if (!info.include.empty())
                {
                    c->addInclude(info.include);
                }
                CppMethodPtr convert = generator.toSpecializedTypeWriterMethod(info);
                c->addPublicMethod(convert);
            }
 
            typeClasses.push_back(c);
        }
    }
 
    CppEnumPtr
    Writer::setupEnumPtr(const typereader::GenerateInfo& info,
                         const generator::IntEnumClass& gen) const
    {
        const auto& type = gen.getType();
        if (type.getMaybe() != type::Maybe::NONE)
        {
            // Should not happen since we check the maybe flag on creation of the generator. However, better to double check
            throw error::ValueNotValidException(
                __PRETTY_FUNCTION__,
                "Somehow the maybe flag of a top level object declaration is set. This is not "
                "valid!",
                std::to_string((int)type.getMaybe()) + " aka " +
                    type::defaultconversion::string::Maybe2String.at(type.getMaybe()),
                type.getPath());
        }
 
        const std::string classCppTypename = gen.getClassCppTypename();
 
        std::vector<std::string> namespaces = info.getNamespaces();
        std::string rawObjectName = info.getNameWithoutNamespace();
        namespaces.push_back(simox::alg::to_lower(camelToSnake(rawObjectName)) + "_details");
 
        std::string enumdoc = "The enum definition of the enum of the auogenerated class '" +
                              gen.getFullClassCppTypename() + "'.";
        CppEnumPtr e = std::make_shared<CppEnum>(namespaces, "Enum");
        auto enumFields = gen.toEnumFields();
 
        ARMARX_CHECK(enumFields.size() > 0);
 
        for (const auto& field : enumFields)
        {
            e->addField(field);
        }
 
        return e;
    }
 
    CppClassPtr
    Writer::setupBasicCppClass(const typereader::GenerateInfo& info, const Generator& gen) const
    {
        const auto& type = gen.getType();
        if (type.getMaybe() != type::Maybe::NONE)
        {
            // Should not happen since we check the maybe flag on creation of the generator. However, better to double check
            throw error::ValueNotValidException(
                __PRETTY_FUNCTION__,
                "Somehow the maybe flag of a top level object declaration is set. This is not "
                "valid!",
                std::to_string((int)type.getMaybe()) + " aka " +
                    type::defaultconversion::string::Maybe2String.at(type.getMaybe()),
                type.getPath());
        }
 
        const std::string classCppTypename = gen.getClassCppTypename();
 
        std::vector<std::string> namespaces = info.getNamespaces();
        std::string rawObjectName = info.getNameWithoutNamespace();
 
        CppClassPtr c = std::make_shared<CppClass>(namespaces, rawObjectName);
        // Add includes and guard
        std::string classDoc = "******************************************\n"
                               "* AUTOGENERATED CLASS. Please do NOT edit.\n"
                               "******************************************\n";
 
        if (!info.doc_author.empty() or !info.doc_brief.empty())
        {
            classDoc += (info.doc_brief.empty() ? "" : " * @brief " + info.doc_brief + "\n");
            classDoc += (info.doc_author.empty() ? "" : " * @author " + info.doc_author + "\n");
        }
 
        c->addClassDoc(classDoc);
 
        // add generator includes (e.g. coming from dto types)
        for (const auto& s : gen.getRequiredIncludes())
        {
            if (!s.empty())
            {
                c->addInclude(s);
            }
        }
 
        // add predefined includes from generator app (e.g. coming from aron includes)
        for (const std::string& s : additionalIncludes)
        {
            if (!s.empty())
            {
                c->addInclude(
                    simox::alg::replace_last(s, ".aron.generated.codesuffix", ".aron.generated.h"));
            }
        }
 
        // always add aron includes
        c->addInclude("<RobotAPI/libraries/aron/core/aron_conversions.h>");
        c->addInclude("<RobotAPI/libraries/aron/core/rw.h>");
        c->addInclude("<RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedClass.h>");
        c->addInclude("<RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedObject.h>");
        c->addInclude("<RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedIntEnum.h>");
 
        // ctor
        c->addCtor(gen.toCtor(c->getName()));
        c->addCtor(gen.toCopyCtor(c->getName()));
 
        // dtor
        c->addPublicMethod(gen.toDtor(c->getName()));
 
        // Generic methods
        //std::cout << "Generate equals method" << std::endl;
        CppMethodPtr equals = gen.toEqualsMethod();
        c->addPublicMethod(equals);
 
        //std::cout << "Generate reset method" << std::endl;
        CppMethodPtr resetHard = gen.toResetHardMethod();
        c->addPublicMethod(resetHard);
 
        //std::cout << "Generate init method" << std::endl;
        CppMethodPtr resetSoft = gen.toResetSoftMethod();
        c->addPublicMethod(resetSoft);
 
        //std::cout << "Generate writeInit method" << std::endl;
        CppMethodPtr writeType = gen.toWriteTypeMethod();
        c->addPublicMethod(writeType);
 
        //std::cout << "Generate write method" << std::endl;
        CppMethodPtr write = gen.toWriteMethod();
        c->addPublicMethod(write);
 
        //std::cout << "Generate read method" << std::endl;
        CppMethodPtr read = gen.toReadMethod();
        c->addPublicMethod(read);
        return c;
    }
 
    void
    Writer::setupMemberFields(CppClassPtr& c,
                              const std::map<std::string, std::string>& doc_members,
                              const generator::ObjectClass& o) const
    {
        auto publicFields = o.getPublicVariableDeclarations(c->getName());
        for (const auto& f : publicFields)
        {
            if (auto it = doc_members.find(f->getName()); it != doc_members.end())
            {
                f->setDoc("@brief " + it->second);
            }
            c->addPublicField(f);
        }
    }
 
    void
    Writer::setupMemberFields(CppClassPtr& c,
                              const std::map<std::string, std::string>& doc_members,
                              const generator::IntEnumClass& o) const
    {
        auto publicFields = o.getPublicVariableDeclarations(camelToSnake(c->getName()));
        for (const auto& f : publicFields)
        {
            if (auto it = doc_members.find(f->getName()); it != doc_members.end())
            {
                f->setDoc("@brief " + it->second);
            }
            c->addPublicField(f);
        }
    }
} // namespace armarx::aron::codegenerator::cpp