generator_class_rust.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : LGPL-3.0-only
****************************************/
 
#include "openFileStream.h"
#include "header_generator.h"
#include "rust_type_utils.h"
#include "generator_class_rust.h"


bool rust_checkDefaultValueExist(const std::vector<PClassAttribute> & vecAttr){
        bool hasDefaultValue = false;
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end() && !hasDefaultValue; ++it){
                hasDefaultValue |= it->getDefaultValue() != "";
        }
        return hasDefaultValue;
}


bool generator_rust_enum_file(std::ofstream & fs, const PClassConfig & classConfig){
        PString name(classConfig.getName());
        const std::vector<PClassAttribute> & vecAttr(classConfig.getListAttribute());
        if(vecAttr.size() == 0LU){
                fs << "//Error : missing enum values as attribute for '" << name << "'" << std::endl;
                return false;
        }
        if(classConfig.getClassDocumentation() != ""){fs << classConfig.getClassDocumentation() << std::endl;}
        fs << "#[derive(Debug, Clone, Copy, PartialEq, Eq)]" << std::endl;
        fs << "pub enum " << name << " {" << std::endl;
        bool isDefaultCounterActivated = !rust_checkDefaultValueExist(vecAttr);
        size_t i(0LU);
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                if(it->getDocumentation() != ""){fs << "\t" << it->getDocumentation() << std::endl;}
                fs << "\t" << it->getName().toLower().firstToUpper();
                if(isDefaultCounterActivated){
                        fs << " = " << i;
                }else if(it->getDefaultValue() != ""){
                        fs << " = " << it->getDefaultValue();
                }
                fs << "," << std::endl;
                ++i;
        }
        fs << "}" << std::endl << std::endl;
 
        fs << "impl Default for " << name << " {" << std::endl;
        fs << "\tfn default() -> Self {" << std::endl;
        fs << "\t\t" << name << "::" << vecAttr.front().getName().toLower().firstToUpper() << std::endl;
        fs << "\t}" << std::endl;
        fs << "}" << std::endl << std::endl;
        return true;
}


bool generator_rust_class_file(const PRustTraitBackendManager & manager, std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        PString name(classConfig.getName());
        const std::vector<PClassAttribute> & vecAttr(classConfig.getListAttribute());
 
        if(classConfig.getClassDocumentation() != ""){fs << classConfig.getClassDocumentation() << std::endl;}
        fs << "#[derive(Debug, Clone, PartialEq)]" << std::endl;
        fs << "pub struct " << name << " {" << std::endl;
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                if(it->getDocumentation() != ""){fs << "\t" << it->getDocumentation() << std::endl;}
                fs << "\t" << it->getName().toSnakeCase() << ": " << getRustType(it->getType()) << "," << std::endl;
        }
        fs << "}" << std::endl << std::endl;
 
        fs << "impl Default for " << name << " {" << std::endl;
        fs << "\tfn default() -> Self {" << std::endl;
        fs << "\t\t" << name << " {" << std::endl;
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                fs << "\t\t\t" << it->getName().toSnakeCase() << ": " << getRustAttributeDefaultValue(*it) << "," << std::endl;
        }
        fs << "\t\t}" << std::endl;
        fs << "\t}" << std::endl;
        fs << "}" << std::endl << std::endl;
 
        fs << "impl " << name << " {" << std::endl;
        fs << "\t///Creates a new " << name << " with default values" << std::endl;
        fs << "\tpub fn new() -> Self { Self::default() }" << std::endl << std::endl;
        manager.implMethodDeclaration(fs, classConfig, mode);
        fs << "}" << std::endl << std::endl;
        manager.classExtraDeclaration(fs, classConfig, mode);
        return true;
}


bool generator_rust_class(const PRustTraitBackendManager & manager, const std::vector<PClassConfig> & vecClassConfig, const PPath & outputSourceDir, const PPath & baseFileName, const GeneratorMode & mode){
        if(baseFileName == ""){return false;}
        PPath rsFile = outputSourceDir / PPath(baseFileName.toSnakeCase() + PString(".rs"));
        std::ofstream fs;
        if(!openFileStream(fs, rsFile)){return false;}
        licenceSave(fs);
        manager.headerExtraInclude(fs, mode);
        fs << std::endl;
        bool b(true);
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        b &= generator_rust_enum_file(fs, *it);
                }else{
                        b &= generator_rust_class_file(manager, fs, *it, mode);
                }
        }
        fs.close();
        return b;
}


bool generator_rust_class_test(const PRustTraitBackendManager & manager, const PPath & outputTestDir, const PString & crateName, const PPath & baseFileName, const std::vector<PClassConfig> & vecClassConfig, const GeneratorMode & mode){
        PString moduleName(baseFileName.toSnakeCase());
        PPath testFile = outputTestDir / PPath(moduleName + PString("_test.rs"));
        std::ofstream fs;
        if(!openFileStream(fs, testFile)){return false;}
        licenceSave(fs);
        PString comma("");
        fs << "use " << crateName << "::" << moduleName << "::{";
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){continue;}
                fs << comma << it->getName();
                comma = ", ";
        }
        fs << "};" << std::endl << std::endl;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                manager.testFunction(fs, *it, mode);
        }
        fs.close();
        return true;
}


bool generator_rust_class_full(const PRustTraitBackendManager & manager, const ProjectParam & projectParam){
        bool b(true);
        b &= projectParam.outputSourceDir.createDirectory();
        if(projectParam.mode.enableUnitTest){
                b &= projectParam.outputTestDir.createDirectory();
        }
        for(const PDataConfig & config : projectParam.vecDataConfig){
                PPath baseFileName = config.getFileName().getFileName().eraseExtension();
                b &= generator_rust_class(manager, config.getVecClassConfig(), projectParam.outputSourceDir, baseFileName, projectParam.mode);
                if(projectParam.mode.enableUnitTest){
                        b &= generator_rust_class_test(manager, projectParam.outputTestDir, projectParam.mode.moduleName, baseFileName, config.getVecClassConfig(), projectParam.mode);
                }
        }
        return b;
}