nanobind_generator.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Thibaut Oprinsen, Pierre Aubert
        Mail : thibaut.oprinsen@lapp.in2p3.fr, pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <set>
#include "header_generator.h"
#include "nanobind_generator.h"
#include "phoenix_color.h"
#include "openFileStream.h"


bool generator_nanobind_class(const PNanobindTraitBackendManager &manager, PPath& baseFileName, const PPath &sourceFile, const PPath &headerFile, const PVecPath &extraInclude, const PVecClassConfig &vecClassConfig, const GeneratorMode &mode){
        if(baseFileName == ""){
                std::cerr << termRed() << "generator_class_cpp : baseFileName is empty" << termDefault() << std::endl;
                return false;
        }
        std::ofstream fs;
        if(!openFileStream(fs, sourceFile)){return false;}
        licenceSave(fs);
        fs << std::endl << "#include \"" << headerFile.getFileName() << "\"" << std::endl << std::endl;
        fs << "#include <nanobind/nanobind.h>" << std::endl;
        std::set<std::string> extraIncludes;
        for (std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                manager.headerExtraInclude(extraIncludes, *it, mode);
        }
        for (const std::string & include : extraIncludes){
                fs << include << std::endl;
        }
        fs << "\nnamespace nb = nanobind;" << std::endl << std::endl;
        PString fileModuleName = baseFileName.toLower();
        fs << "NB_MODULE(" << fileModuleName << ", m) {" << std::endl;
        fs << "\tm.doc() = \"Nanobind bindings for " << baseFileName << " classes\";\n" << std::endl;
 
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        fs << "\tnb::enum_<" << it->getName() << "::" << it->getName() << ">(m, \"" << it->getName() << "\")" << std::endl;
                        fs << "\t\t//Values" << std::endl;
                        manager.registerProperty(fs, *it, mode);
                        manager.registerStaticMethod(fs, *it, mode);
                        manager.registerMethod(fs, *it, mode);
                        fs << ";" << std::endl << std::endl;
                }else{
                        fs << "\tnb::class_<" << it->getName() << ">(m, \"" << it->getName() << "\")" << std::endl;
                        fs << "\t\t//Attributes" << std::endl;
                        manager.registerProperty(fs, *it, mode);
                        manager.registerConstructor(fs, *it, mode);
                        manager.registerStaticMethod(fs, *it, mode);
                        
                        manager.registerMethod(fs, *it, mode);
                        fs << ";" << std::endl << std::endl;
                }
        }
        fs << "}" << std::endl; // Close NB_MODULE
        fs.close();
        return true;
}


bool generator_nanobind_test(const PNanobindTraitBackendManager & manager, const PPath & outputTestDir, const std::vector<PClassConfig> & vecClassConfig, const PString & projectName, const PPath & baseFileName, const GeneratorMode & mode){
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                PString name = it->getName();
                PPath outputCurrentTestDir(outputTestDir + PString("/TEST_") + name.toUpper() + "_BINDINGS");
                if(!outputCurrentTestDir.createDirectory()){
                        std::cerr << "generator_class_test : cannot create TEST directory '"<<outputCurrentTestDir<<"'" << std::endl;
                        return false;
                }
                std::ofstream fs;
                if(!openFileStream(fs, PPath(outputCurrentTestDir + PString("/test_") + name + "_binding.py"))){return false;}
                manager.headerTestInclude(fs, mode, baseFileName);
                manager.testFunction(fs, *it, mode, baseFileName);
                fs.close();
        }
        return true;
}


bool generator_nanobind_full(const PNanobindTraitBackendManager & manager, const ProjectParam & projectParam)
{
        bool b(true);
        b &= projectParam.outputSourceDir.createDirectory();
        b &= projectParam.outputTestDir.createDirectory();
        const PVecDataConfig & vecDataConfig = projectParam.vecDataConfig;
 
        for(const PDataConfig & config : vecDataConfig){
                const PVecPath & extraInclude = config.getVecInclude();
                PPath baseFileName = config.getFileName().getFileName().eraseExtension();
                PPath headerFile = projectParam.outputSourceDir / PPath(baseFileName + ".h");
                PPath sourceFile = projectParam.outputSourceDir / PPath(baseFileName + "_binding.cpp");
                if(!generator_nanobind_class(manager, baseFileName, sourceFile, headerFile, extraInclude, config.getVecClassConfig(), projectParam.mode)){
                        std::cerr << termRed() << "generator_nanobind_full : cannot generate nanobind sources at '"<<projectParam.outputSourceDir<<"'" << termDefault() << std::endl;
                        b = false;      //best effort strategy
                }
                PPath outputCurrentTestDir = projectParam.outputTestDir / PPath("TEST_PYTHON_BINDINGS");
                if(!generator_nanobind_test(manager, outputCurrentTestDir, config.getVecClassConfig(), projectParam.name, baseFileName, projectParam.mode)){
                        std::cerr << termRed() << "generator_nanobind_full : cannot generate nanobind tests at '"<<projectParam.outputTestDir<<"'" << termDefault() << std::endl;
                        b = false;      //best effort strategy
                }
        }
        return b;
}