PClassGenerator.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "PClassGenerator.h"
#include "header_generator.h"
 
PClassGenerator::PClassGenerator(){
        initialisationPClassGenerator();
}
 
PClassGenerator::~PClassGenerator(){
        
}
 
 
bool PClassGenerator::saveFileImplDef(const PPath & baseFileName){
        PPath baseToUse("");
        if(baseFileName == ""){baseToUse = p_className;}
        else{baseToUse = baseFileName;}
        if(baseToUse == ""){return false;}
        PPath includeName(baseToUse + PPath(".h"));
        PPath sourceName(baseToUse + PPath(".cpp"));
        if(p_useTemplate){sourceName = PString(baseToUse + "_impl.h");}
        bool b(saveFileDef(includeName, sourceName));
        b &= saveFileImpl(sourceName, includeName);
        return b;
}
 
 
bool PClassGenerator::saveFileDef(const PPath & fileNameInclude, const PPath & fileNameSource){
        std::ofstream fs;
        fs.open(fileNameInclude.c_str());
        if(!fs.is_open()){
                std::cerr << "PClassGenerator::saveFileDef : can't open file '" << fileNameInclude << "'" << std::endl;
                return false;
        }
        licenceSave(fs);
        PString macroDef(makeMultiIncludeDefineMacro(fileNameInclude));
        fs << "#ifndef " << macroDef << std::endl;
        fs << "#define " << macroDef << std::endl << std::endl << std::endl;
        bool b = saveClassDef(fs);
        saveTemplateEndDefinition(fs, fileNameSource);
        fs << std::endl << std::endl << "#endif" << std::endl << std::endl;
        fs.close();
        return b;
}
 
 
bool PClassGenerator::saveFileImpl(const PPath & fileNameSource, const PPath & fileNameInclude){
        std::ofstream fs;
        fs.open(fileNameSource.c_str());
        if(!fs.is_open()){
                std::cerr << "PClassGenerator::saveFileImpl : can't open file '" << fileNameSource << "'" << std::endl;
                return false;
        }
        licenceSave(fs);
        saveTemplateBeginImpl(fs, fileNameInclude);
        fs << std::endl << "#include \"" << fileNameInclude << "\"" << std::endl << std::endl;
        bool b = saveClassImpl(fs);
        fs << std::endl << std::endl;
        saveTemplateEndImpl(fs);
        fs << std::endl << std::endl;
        fs.close();
        return b;
}
 
 
bool PClassGenerator::saveClassDef(std::ofstream & fs){
        if(p_classBrief != "") fs << "///@brief " << p_classBrief << std::endl;
        saveTemplateDefinition(fs);
        fs << "class " << p_className << "{" << std::endl;
        fs << "\tpublic:" << std::endl;
        saveConstructorDef(fs);
        saveCopyContructorDef(fs);
        saveDestructorDef(fs);
        
        saveCopyEqualOperatorDef(fs);
        fs << "\tprotected:" << std::endl;
        saveCopyFunctionDef(fs);
        fs << "\tprivate:" << std::endl;
        saveInitialisationFunctionDef(fs);
        fs << "};" << std::endl << std::endl;;
        return true;
}
 
 
bool PClassGenerator::saveClassImpl(std::ofstream & fs){
        saveConstructorImpl(fs);
        saveCopyContructorImpl(fs);
        saveDestructorImpl(fs);
        
        saveCopyEqualOperatorImpl(fs);
        
        saveCopyFunctionImpl(fs);
        
        saveInitialisationFunctionImpl(fs);
        return true;
        
}
 
 
void PClassGenerator::setClassName(const PString & className){
        p_className = className;
        p_classNameSpace = className;
        p_classTypeName = className;
}
 
 
void PClassGenerator::setTemplateDefVar(const PString & templateDef){
        if(templateDef == ""){
                p_templateDefVar = "";
                p_templateListVar = "";
                p_useTemplate = false;
                return;
        }
        p_templateDefVar = templateDef;
        PVecString listDef(templateDef.split(','));
        p_templateListVar = "";
        bool firstDef(true);
        for(PVecString::iterator it(listDef.begin()); it != listDef.end(); ++it){
                PVecString partDef(it->split(' '));
                if(partDef.size() == 2lu){
                        if(firstDef){
                                p_templateListVar += partDef.back();
                                firstDef = false;
                        }else{
                                p_templateListVar += ", " + partDef.back();
                        }
                }
        }
        p_useTemplate = true;
        p_classTypeName = p_className + "<" + p_templateListVar + ">";
        p_classNameSpace = p_className + "<" + p_templateListVar + ">";
}
 
void PClassGenerator::initialisationPClassGenerator(){
        p_templateDefVar = "";
        p_templateListVar = "";
        p_useCopyFunction = true;
        p_useTemplate = false;
        p_classTypeName = "";
}
 
 
void PClassGenerator::saveTemplateDefinition(std::ofstream & fs){
        if(!p_useTemplate) return;
        fs << "template<" << p_templateDefVar << ">" << std::endl;
}
 
 
void PClassGenerator::saveTemplateEndDefinition(std::ofstream & fs, const PPath & fileNameSource){
        if(!p_useTemplate) return;
        fs << "#include \"" << fileNameSource << "\"" << std::endl; 
}
 
 
void PClassGenerator::saveTemplateBeginImpl(std::ofstream & fs, const PPath & fileNameInclude){
        if(!p_useTemplate) return;
        PString macroDef("__"+fileNameInclude.replace(".", "_").toUpper()+"_IMPL__");
        fs << "#ifndef " << macroDef << std::endl;
        fs << "#define " << macroDef << std::endl << std::endl << std::endl;
}
 
 
void PClassGenerator::saveTemplateEndImpl(std::ofstream & fs){
        if(!p_useTemplate) return;
        fs << std::endl << std::endl << "#endif" << std::endl << std::endl;
        
}
 
 
void PClassGenerator::saveConstructorDef(std::ofstream & fs){
        fs << "\t\t" << p_className << "();" << std::endl;
}
 
 
void PClassGenerator::saveConstructorImpl(std::ofstream & fs){
        fs << "///Default constructor of " << p_className << std::endl;
        saveTemplateDefinition(fs);
        fs << p_classNameSpace << "::" << p_className << "(){" << std::endl;
        fs << "\tinitialisation" << p_className.firstToUpper() << "();" << std::endl;
        fs << "}" << std::endl;
        fs << std::endl;
}
 
 
void PClassGenerator::saveDestructorDef(std::ofstream & fs){
        fs << "\t\tvirtual ~" << p_className << "();" << std::endl;
}
 
 
void PClassGenerator::saveDestructorImpl(std::ofstream & fs){
        fs << "///Destructor of " << p_className << std::endl;
        saveTemplateDefinition(fs);
        fs << p_classNameSpace << "::~" << p_className << "(){" << std::endl;
        fs << "\t" << std::endl;
        fs << "}" << std::endl;
        fs << std::endl;
}
 
 
void PClassGenerator::saveInitialisationFunctionDef(std::ofstream & fs){
        fs << "\t\tvoid initialisation" << p_className.firstToUpper() << "();" << std::endl;
}
 
 
void PClassGenerator::saveInitialisationFunctionImpl(std::ofstream & fs){
        fs << "///Initialisation function of the class " << p_className << std::endl;
        saveTemplateDefinition(fs);
        fs << "void " << p_classNameSpace << "::initialisation" << p_className.firstToUpper() << "(){" << std::endl;
        fs << "\t" << std::endl;
        fs << "}" << std::endl;
        fs << std::endl;
}
 
 
void PClassGenerator::saveCopyContructorDef(std::ofstream & fs){
        if(!p_useCopyFunction) return;
        fs << "\t\t" << p_className << "(const " << p_classTypeName << " & other);" << std::endl;
}
 
 
void PClassGenerator::saveCopyContructorImpl(std::ofstream & fs){
        if(!p_useCopyFunction) return;
        fs << "///Copy constructor of " << p_className << std::endl;
        fs << "/**\t@param other : class to copy" << std::endl;
        fs << "*/" << std::endl;
        saveTemplateDefinition(fs);
        fs << p_classNameSpace << "::" << p_className << "(const " << p_classTypeName << " & other){" << std::endl;
        fs << "\tcopy" << p_className.firstToUpper() << "(other);" << std::endl;
        fs << "}" << std::endl;
        fs << std::endl;
}
 
 
void PClassGenerator::saveCopyEqualOperatorDef(std::ofstream & fs){
        if(!p_useCopyFunction) return;
        fs << "\t\t" << p_className << " & operator = (const " << p_classTypeName << " & other);" << std::endl;
}
 
 
void PClassGenerator::saveCopyEqualOperatorImpl(std::ofstream & fs){
        if(!p_useCopyFunction) return;
        fs << "///Definition of equal operator of " << p_className << std::endl;
        fs << "/**\t@param other : class to copy" << std::endl;
        fs << " * \t@return copied class" << std::endl;
        fs << "*/" << std::endl;
        saveTemplateDefinition(fs);
//      if(p_useTemplate) fs << "typename " << p_classNameSpace << "::";
        fs << p_classTypeName << " & " << p_classNameSpace << "::operator = (const " << p_classTypeName << " & other){" << std::endl;
        fs << "\tcopy" << p_className.firstToUpper() << "(other);" << std::endl;
        fs << "\treturn *this;" << std::endl;
        fs << "}" << std::endl;
        fs << std::endl;
}
 
 
void PClassGenerator::saveCopyFunctionDef(std::ofstream & fs){
        if(!p_useCopyFunction) return;
        fs << "\t\tvoid copy" << p_className.firstToUpper() << "(const " << p_classTypeName << " & other);" << std::endl;
}
 
 
void PClassGenerator::saveCopyFunctionImpl(std::ofstream & fs){
        if(!p_useCopyFunction) return;
        fs << "///Copy function of " << p_className << std::endl;
        fs << "/**\t@param other : class to copy" << std::endl;
        fs << "*/" << std::endl;
        saveTemplateDefinition(fs);
        fs << "void " << p_classNameSpace << "::copy" << p_className.firstToUpper() << "(const " << p_classTypeName << " & other){" << std::endl;
        fs << "\t" << std::endl;
        fs << "}" << std::endl;
        fs << std::endl;
}