saveClassConfig.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "header_generator.h"
#include "saveClassConfig.h"
 
 
bool getIsSimpleType(const PString & varType){
        PString restVarName(varType.replace("unsigned", "").eraseChar(" \n\t*&"));
        return (restVarName == "char" || restVarName == "short" || restVarName == "int" || restVarName == "float" || restVarName == "double" || restVarName == "bool" || restVarName == "long" || restVarName == "longint" || restVarName == "size_t" || restVarName == "ssize_t" || restVarName == "void");
}
 
 
bool getIsPointer(const PString & varType){
        if(varType.size() == 0lu){return false;}
        return varType.find('*') && varType.back() == '*';
}
 
 
PString getDefaultValueTypeInCpp(const PString & type){
        if(type == "PString"){
                return "\"\"";
        }else if(type == "char"){
                return "0";
        }else if(type == "unsigned char"){
                return "0";
        }else if(type == "int" || type == "short" || type == "unsigned short"){
                return "0";
        }else if(type == "unsigned int"){
                return "0u";
        }else if(type == "long int" || type == "long" || type == "ssize_t"){
                return "0l";
        }else if(type == "size_t" || type == "long unsigned int"){
                return "0lu";
        }else if(type == "bool"){
                return "false";
        }else{
                return "";
        }
}
 
 
PString makeVarType(const PString & varType, bool isSetter, bool isConst, bool isRef, bool isPtr){
        PString varTypeName("");
//      std::cout << "makeVarType : varType = '" << varType << "'" << std::endl;
        bool isSimpleType = getIsSimpleType(varType);
        if(isSimpleType || isPtr){
                if(isConst && !isSetter && (!isSimpleType || isPtr)) varTypeName += "const ";
                varTypeName += varType;
                if(isRef && !isPtr) varTypeName += " &";
        }else{
                if(isConst && !isPtr) varTypeName += "const ";
                varTypeName += varType + " &";
        }
        return varTypeName;
}
 
 
PString createSetterDecl(const PString & varType, const PString & varName, const PString & className, bool isPtr){
        PString functionDecl("void ");
        if(className != "") functionDecl += className + "::";
        functionDecl += "set" + varName.firstToUpper() + "(";
        functionDecl += makeVarType(varType, true, true, false, isPtr);
        functionDecl += " " + varName + ")";
        return functionDecl;
}
 
 
PString createGetterDecl(const PString & varType, const PString & varName, const PString & className, bool isConst, bool isPtr){
        PString functionDecl("");
        functionDecl += makeVarType(varType, false, isConst, !isConst, isPtr) + " ";
        if(className != "") functionDecl += className + "::";
        functionDecl += "get" + varName.firstToUpper() + "()";
        return functionDecl;
}
 
 
void saveDeclSetters(std::ofstream & fs, const PClassConfig & classConfig){
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                fs << "\t\t" << createSetterDecl(it->getType(), it->getName(), "", it->getIsPointer()) << ";" << std::endl;
        }
}
 
 
void saveDeclGetters(std::ofstream & fs, const PClassConfig & classConfig){
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                fs << "\t\t" << createGetterDecl(it->getType(), it->getName(), "", true, it->getIsPointer()) << " const;" << std::endl;
                fs << "\t\t" << createGetterDecl(it->getType(), it->getName(), "", false, it->getIsPointer()) << ";" << std::endl;
        }
}
 
 
void saveClassDataStreamMethod(std::ofstream & fs, const PClassConfig & classConfig){
        PString name(classConfig.getName());
        fs << std::endl;
        fs << "\t\t///Load the current "<<name<<" with a stream" << std::endl;
        fs << "\t\t/**  @param[out] ds : stream to be used" << std::endl;
        fs << "\t\t *   @return true on success, false otherwise" << std::endl;
        fs << "\t\t*/" << std::endl;
        fs << "\t\ttemplate<typename Stream, DataStreamMode::DataStreamMode Mode>" << std::endl;
        fs << "\t\tbool readWriteStream(Stream & ds){" << std::endl;
        fs << "\t\t\tbool b(true);" << std::endl;
        
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                fs << "\t\t\tb &= DataStream<Stream, Mode, "<<it->getType()<<" >::data_stream(ds, p_" << it->getName() << ");" << std::endl;
        }
        
        fs << "\t\t\treturn b;" << std::endl;
        fs << "\t\t}" << std::endl << std::endl;
}
 
 
void saveClassDataStreamGenericFunction(std::ofstream & fs, const PClassConfig & classConfig){
        PString name(classConfig.getName());
        fs << "///@brief Generic "<<name<<" serialisation/deserialisation, load/save and size function" << std::endl;
        fs << "template<typename Stream, DataStreamMode::DataStreamMode Mode>" << std::endl;
        fs << "struct DataStream<Stream, Mode, "<<name<<">{" << std::endl;
        fs << "\t///Generic function to load/save/serialise/deserialise "<<name << std::endl;
        fs << "\t/**\t@param data : "<<name<<" to be used" << std::endl;
        fs << "\t * \t@return true on success, false otherwise" << std::endl;
        fs << "\t*/" << std::endl;
        fs << "\tstatic bool data_stream(Stream & ds, "<<name<<" & data){" << std::endl;
        fs << "\t\treturn data.readWriteStream<Stream, Mode>(ds);" << std::endl;
        fs << "\t}" << std::endl;
        fs << "};" << std::endl << std::endl;
}
 
 
PString getClassDeclTempalteDef(const PVecString & listTemplate){
        if(listTemplate.size() == 0lu){return "";}
        PString templateDef("template<");
        PString comma("");
        for(PVecString::const_iterator it(listTemplate.begin()); it != listTemplate.end(); ++it){
                templateDef += comma;
                templateDef += *it;
                comma = ", ";
        }
        templateDef += ">\n";
        return templateDef;
}
 
 
PString getClassDefTemplate(const PVecString & listTemplate){
        PString defTemplate("<"), comma("");
        for(PVecString::const_iterator it(listTemplate.begin()); it != listTemplate.end(); ++it){
                defTemplate += comma + it->split(' ').back();
                comma = ", ";
        }
        defTemplate += ">";
        return defTemplate;
}
 
 
void saveEnumDecl(std::ofstream & fs, const PClassConfig & classConfig, bool enableDataStream, bool enableTypeStream){
        PString name(classConfig.getName());
        fs << "namespace " << name << " {\n";
        if(classConfig.getClassDocumentation() != "") fs << classConfig.getClassDocumentation() << std::endl;
        fs << "\tenum " << name << " {\n\t\t";
        PString comma("");
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(it->getDocumentation() != "") fs << "\t\t" << it->getDocumentation() << std::endl;
                fs << comma << it->getName();
                if(it->getDefaultValue() != ""){
                        fs << " = " << it->getDefaultValue();
                }
                comma = ",\n\t\t";
        }
        fs << "\n\t};" << std::endl;
        fs << "}" << std::endl << std::endl;
        
        if(enableDataStream){
                fs << "///@brief Generic "<<name << " deserialisation, load and size function for a "<<name << "::"<<name << "" << std::endl;
                fs << "template<typename Stream>" << std::endl;
                fs << "struct DataStream<Stream, DataStreamMode::READ, "<<name << "::"<<name << ">{" << std::endl;
                fs << "\t///Generic function to load/deserialise "<<name << "" << std::endl;
                fs << "\t/**\t@param[out] ds : Stream to be used" << std::endl;
                fs << "\t * \t@param data : "<<name << " to be loaded" << std::endl;
                fs << "\t * \t@return true on success, false otherwise" << std::endl;
                fs << "\t*/" << std::endl;
                fs << "\tstatic bool data_stream(Stream & ds, "<<name << "::"<<name << " & data){" << std::endl;
                fs << "\t\tint value(0);" << std::endl;
                fs << "\t\tbool b = DataStream<Stream, DataStreamMode::READ, int>::data_stream(ds, value);" << std::endl;
                fs << "\t\tdata = ("<<name << "::"<<name << ")value;" << std::endl;
                fs << "\t\treturn b;" << std::endl;
                fs << "\t}" << std::endl;
                fs << "};" << std::endl << std::endl;
 
                fs << "///@brief Generic "<<name << " serialisation, save and size function for a "<<name << "::"<<name << "" << std::endl;
                fs << "template<typename Stream>" << std::endl;
                fs << "struct DataStream<Stream, DataStreamMode::WRITE, "<<name << "::"<<name << ">{" << std::endl;
                fs << "\t///Generic function to save/serialise "<<name << "" << std::endl;
                fs << "\t/**\t@param[out] ds : Stream to be used" << std::endl;
                fs << "\t * \t@param data : "<<name << " to be saved" << std::endl;
                fs << "\t * \t@return true on success, false otherwise" << std::endl;
                fs << "\t*/" << std::endl;
                fs << "\tstatic bool data_stream(Stream & ds, "<<name << "::"<<name << " & data){" << std::endl;
                fs << "\t\tint value = (int)data;" << std::endl;
                fs << "\t\treturn DataStream<Stream, DataStreamMode::WRITE, int>::data_stream(ds, value);" << std::endl;
                fs << "\t}" << std::endl;
                fs << "};" << std::endl << std::endl;
        }
        if(enableTypeStream){
                fs << "///Get the type name of "<<name << std::endl;
                fs << "/**\t@return type name of "<<name << " as string" << std::endl;
                fs << "*/" << std::endl;
                fs << "template<>" << std::endl;
                fs << "std::string phoenix_getTypeName<"<<name<<"::"<<name<<">(){" << std::endl;
                fs << "\treturn \""<<name<<"\";" << std::endl;
                fs << "}" << std::endl << std::endl;
        }
}
 
 
void saveClassDecl(std::ofstream & fs, const PClassConfig & classConfig, bool enableDataStream, bool enableTypeStream){
        if(classConfig.getClassDocumentation() != "") fs << classConfig.getClassDocumentation() << std::endl;
        PString name(classConfig.getName());
        const PVecString & listTemplate = classConfig.getListTemplate();
        if(listTemplate.size() != 0lu){
                fs << getClassDeclTempalteDef(listTemplate);
        }
        fs << "class " << name;
        if(classConfig.getListParentClass().size() != 0lu){
                PVecString::const_iterator it(classConfig.getListParentClass().begin());
                fs << " : public " << *it;
                if(classConfig.getListParentClass().size() > 1lu){
                        while(it != classConfig.getListParentClass().end()){
                                fs << ", " << *it;
                                ++it;
                        }
                }
        }
        fs << "{" << std::endl;
        fs << "\tpublic:" << std::endl;
        fs << "\t\t" << name << "();" << std::endl;
        fs << "\t\t" << name << "(const " << name << " & other);" << std::endl;
        fs << "\t\tvirtual ~" << name << "();" << std::endl;
        fs << "\t\t" << name << " & operator = (const " << name << " & other);" << std::endl;
        saveDeclSetters(fs, classConfig);
        saveDeclGetters(fs, classConfig);
        
        if(enableDataStream){
                saveClassDataStreamMethod(fs, classConfig);
        }
        
        fs << "\tprotected:" << std::endl;
        fs << "\t\tvoid copy" << name << "(const " << name << " & other);" << std::endl;
        
        fs << "\tprivate:" << std::endl;
        fs << "\t\tvoid initialisation" << name << "();" << std::endl;
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(it->getDocumentation() != "") fs << "\t\t" << it->getDocumentation() << std::endl;
                
                fs << "\t\t" << it->getType() << " p_" << it->getName() << ";" << std::endl;
        }
        fs << "};" << std::endl << std::endl;
        
        if(enableDataStream){
                saveClassDataStreamGenericFunction(fs, classConfig);
                fs << std::endl << std::endl;
        }
        if(enableTypeStream){
                if(listTemplate.size() != 0lu){
                        fs << "///Get the name of the class " << name << std::endl;
                        fs << "/**\t@return name of the class " << name << std::endl;
                        fs << "*/" << std::endl;
                        fs << getClassDeclTempalteDef(listTemplate);
                        fs << "std::string phoenix_getTypeName<"<<name << getClassDefTemplate(listTemplate) <<" >(){" << std::endl;
                        fs << "\treturn \""<<name<<"\"";
                        fs << " + \"<\"";
                        for(PVecString::const_iterator it(listTemplate.begin()); it != listTemplate.end(); ++it){
                                fs  << " + phoenix_getTypeToStr<"<<it->split(' ').back()<<">()";
                        }
                        fs << " + \">\"";
                        fs << ";" << std::endl;
                        fs << "}" << std::endl << std::endl;
                        
                }else{
                        fs << "template<>" << std::endl;
                        fs << "std::string phoenix_getTypeName<"<<name<<">();" << std::endl << std::endl;
                }
        }
}
 
 
void saveClassGetTypeNameImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate, const PString & templateDeclaration, bool enableTypeStream){
        if(!enableTypeStream){return;}
        PString name(classConfig.getName());
        fs << "///Get the name of the class " << name << std::endl;
        fs << "/**\t@return name of the class " << name << std::endl;
        fs << "*/" << std::endl;
        const PVecString & listTemplate = classConfig.getListTemplate();
        if(listTemplate.size() == 0lu){
                fs << "template<>" << std::endl;
        }else{
                fs << templateDeclaration;
        }
        fs << "std::string phoenix_getTypeName<"<<name << defTemplate <<" >(){" << std::endl;
        fs << "\treturn \""<<name<<"\"";
        if(listTemplate.size() != 0lu){
                fs << " + \"<\"";
                for(PVecString::const_iterator it(listTemplate.begin()); it != listTemplate.end(); ++it){
                        fs  << " + phoenix_getTypeToStr<"<<it->split(' ').back()<<">()";
                }
                fs << " + \">\"";
        }
        fs << ";" << std::endl;
        fs << "}" << std::endl << std::endl;
}
 
 
void saveClassConstructorImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate, const PString & templateDeclaration){
        PString name(classConfig.getName());
        fs << "///Constructor of class " << name << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << "::" << name << "()";
        if(classConfig.getListParentClass().size() != 0lu){
                PVecString::const_iterator it(classConfig.getListParentClass().begin());
                fs << std::endl << "\t: " << *it << "()";
                if(classConfig.getListParentClass().size() > 1lu){
                        while(it != classConfig.getListParentClass().end()){
                                fs << ", " << *it << "()";
                                ++it;
                        }
                }
                fs << std::endl;
        }
        fs << "{" << std::endl;
        fs << "\tinitialisation" << name << "();" << std::endl;
        fs << "}" << std::endl << std::endl;
}
 
 
void saveClassCopyConstructorImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate, const PString & templateDeclaration){
        PString name(classConfig.getName());
        fs << "///Copy Constructor of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want ot copy" << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate  << "::" << name << "(const " << name << defTemplate << " & other){" << std::endl;
        fs << "\tcopy" << name << "(other);" << std::endl;
        fs << "}" << std::endl << std::endl;
}
 
 
void saveClassDestructorImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate, const PString & templateDeclaration){
        PString name(classConfig.getName());
        fs << "///Destructor of class " << name << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << "::~" << name << "(){" << std::endl;
        fs << "\t" << std::endl;
        fs << "}" << std::endl << std::endl;
}
 
 
void saveClassEqualOperatorImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate, const PString & templateDeclaration){
        PString name(classConfig.getName());
        fs << "///Operator = of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want ot copy" << std::endl;
        fs << " * \t@return copied class " << name << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << " & " << name << defTemplate << "::operator =" << " (const " << name << defTemplate << " & other){" << std::endl;
        fs << "\tcopy" << name << "(other);" << std::endl;
        fs << "\treturn *this;" << std::endl;
        fs << "}" << std::endl << std::endl;
}
 
 
void saveClassSettersImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate, const PString & templateDeclaration){
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                fs << "///Sets the " << it->getName() << " of the " << classConfig.getName() << std::endl;
                fs << "/**\t@param " << it->getName() << " : " << it->getName() << " of the " << classConfig.getName() << std::endl;
                fs << "*/" << std::endl;
                fs << templateDeclaration;
                fs << createSetterDecl(it->getType(), it->getName(), classConfig.getName() + defTemplate, it->getIsPointer()) << "{" << std::endl;
                fs << "\tp_" << it->getName() << " = " << it->getName() << ";" << std::endl;
                fs << "}" << std::endl << std::endl;
        }
}
 
 
void saveClassGettersImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate, const PString & templateDeclaration){
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                fs << "///Gets the " << it->getName() << " of the " << classConfig.getName() << std::endl;
                fs << "/**\t@return " << it->getName() << " of the " << classConfig.getName() << std::endl;
                fs << "*/" << std::endl;
                fs << templateDeclaration;
                fs << createGetterDecl(it->getType(), it->getName(), classConfig.getName() + defTemplate, true, it->getIsPointer()) << " const{" << std::endl;
                fs << "\treturn p_" << it->getName() << ";" << std::endl;
                fs << "}" << std::endl << std::endl;
                fs << "///Gets the " << it->getName() << " of the " << classConfig.getName() << std::endl;
                fs << "/**\t@return " << it->getName() << " of the " << classConfig.getName() << std::endl;
                fs << "*/" << std::endl;
                fs << templateDeclaration;
                fs << createGetterDecl(it->getType(), it->getName(), classConfig.getName() + defTemplate, false, it->getIsPointer()) << "{" << std::endl;
                fs << "\treturn p_" << it->getName() << ";" << std::endl;
                fs << "}" << std::endl << std::endl;
        }
}
 
 
void saveClassCopyFunctionImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate, const PString & templateDeclaration){
        PString name(classConfig.getName());
        fs << "///Copy Function of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want ot copy" << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << "void " << name << defTemplate << "::copy" << name << "(const " << name << defTemplate << " & other){" << std::endl;
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                fs << "\tp_" << it->getName() << " = other.p_" << it->getName() << ";" << std::endl;
        }
        fs << "}" << std::endl << std::endl;
}
 
 
void saveClassInitialisationFunctionImpl(std::ofstream & fs, const PClassConfig & classConfig, const PString & defTemplate,
                                        const PString & templateDeclaration)
{
        PString name(classConfig.getName());
        fs << "///Initialisation Function of class " << name << std::endl;
        fs << templateDeclaration;
        fs << "void " << name << defTemplate << "::initialisation" << name << "(){" << std::endl;
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(it->getDefaultValue() != ""){
                        fs << "\tp_" << it->getName() << " = "<<it->getDefaultValue()<<";" << std::endl;
                }else{
                        PString varType(it->getType());
                        bool isSimpleType = getIsSimpleType(varType);
                        bool isPtr(getIsPointer(varType));
                        if(isPtr){
                                fs << "\tp_" << it->getName() << " = NULL;" << std::endl;
                        }else if(isSimpleType){
                                PString defaultValue(getDefaultValueTypeInCpp(varType));
                                if(defaultValue != ""){
                                        fs << "\tp_" << it->getName() << " = "<<defaultValue<<";" << std::endl;
                                }
                        }else if(varType == "PString"){
                                fs << "\tp_" << it->getName() << " = \"\";" << std::endl;
                        }
                }
        }
        fs << "}" << std::endl << std::endl;
}
 
 
void saveClassImpl(std::ofstream & fs, const PClassConfig & classConfig, bool enableTypeStream){
        saveClassGetTypeNameImpl(fs, classConfig, "", "", enableTypeStream);
        saveClassConstructorImpl(fs, classConfig, "", "");
        saveClassCopyConstructorImpl(fs, classConfig, "", "");
        saveClassDestructorImpl(fs, classConfig, "", "");
        saveClassEqualOperatorImpl(fs, classConfig, "", "");
        saveClassSettersImpl(fs, classConfig, "", "");
        saveClassGettersImpl(fs, classConfig, "", "");
        saveClassCopyFunctionImpl(fs, classConfig, "", "");
        saveClassInitialisationFunctionImpl(fs, classConfig, "", "");
}
 
 
bool saveClassDecl(const std::vector<PClassConfig> & classConfig, const PPath & headerFile, const PVecPath & listInclude, bool enableDataStream, bool enableTypeStream,
                        const PString & includeTemplate)
{
        if(headerFile == "") return false;
        std::ofstream fs;
        fs.open(headerFile.c_str());
        if(!fs.is_open()){
                std::cerr << "saveClassDecl : can't open file '" << headerFile << "'" << std::endl;
                return false;
        }
        licenceSave(fs);
        PString macroDef(makeMultiIncludeDefineMacro(headerFile.getFileName()));
        fs << "#ifndef " << macroDef << std::endl;
        fs << "#define " << macroDef << std::endl << std::endl;
        if(listInclude.size() != 0lu){
                for(PVecPath::const_iterator it(listInclude.begin()); it != listInclude.end(); ++it){
                        fs << "#include " << *it << std::endl;
                }
                fs << std::endl;
        }
        if(enableDataStream){
                fs << "#include \"data_all.h\"" << std::endl << std::endl;
        }
        if(enableTypeStream){
                fs << "#include \"phoenix_type_stream.h\"" << std::endl << std::endl;
        }
        
        for(std::vector<PClassConfig>::const_iterator it(classConfig.begin()); it != classConfig.end(); ++it){
                if(it->getIsEnum()){
                        saveEnumDecl(fs, *it, enableDataStream, enableTypeStream);
                }else{
                        saveClassDecl(fs, *it, enableDataStream, enableTypeStream);
                }
        }
        
        if(includeTemplate != ""){
                fs << "#include \""<<includeTemplate<<"\"" << std::endl << std::endl;
        }
        
        fs << std::endl << std::endl << "#endif" << std::endl << std::endl;
        fs.close();
        return true;
}
 
 
bool saveClassImpl(const std::vector<PClassConfig> & classConfig, const PPath & sourceFile, const PPath & headerFile, bool enableTypeStream){
        if(sourceFile == "" || headerFile == "") return false;
        std::ofstream fs;
        fs.open(sourceFile.c_str());
        if(!fs.is_open()){
                std::cerr << "saveClassImpl : can't open file '" << sourceFile << "'" << std::endl;
                return true;
        }
        licenceSave(fs);
        fs << std::endl << "#include \"" << headerFile.getFileName() << "\"" << std::endl << std::endl;
        for(std::vector<PClassConfig>::const_iterator it(classConfig.begin()); it != classConfig.end(); ++it){
                if(it->getIsEnum()){continue;}
                saveClassImpl(fs, *it, enableTypeStream);
        }
        fs.close();
        return true;
}
 
 
 
void saveClassTemplate(std::ofstream & fs, const PClassConfig & classConfig){
        const PVecString & listTemplate = classConfig.getListTemplate();
        if(listTemplate.size() == 0lu){return;}
        
        PString defTemplate(getClassDefTemplate(listTemplate));
        PString templateDeclaration(getClassDeclTempalteDef(listTemplate));
        
        saveClassConstructorImpl(fs, classConfig, defTemplate, templateDeclaration);
        saveClassCopyConstructorImpl(fs, classConfig, defTemplate, templateDeclaration);
        saveClassDestructorImpl(fs, classConfig, defTemplate, templateDeclaration);
        saveClassEqualOperatorImpl(fs, classConfig, defTemplate, templateDeclaration);
        saveClassSettersImpl(fs, classConfig, defTemplate, templateDeclaration);
        saveClassGettersImpl(fs, classConfig, defTemplate, templateDeclaration);
        saveClassCopyFunctionImpl(fs, classConfig, defTemplate, templateDeclaration);
        saveClassInitialisationFunctionImpl(fs, classConfig, defTemplate, templateDeclaration);
}
 
 
bool saveClassTemplate(const std::vector<PClassConfig> & classConfig, const PPath & sourceFile, const PPath & headerFile){
        if(sourceFile == "" || headerFile == "") return false;
        std::ofstream fs;
        fs.open(sourceFile.c_str());
        if(!fs.is_open()){
                std::cerr << "saveClassTemplate : can't open file '" << sourceFile << "'" << std::endl;
                return true;
        }
        licenceSave(fs);
        PString macroDef(makeMultiIncludeDefineMacro(headerFile.getFileName() + "_IMPL"));
        fs << "#ifndef " << macroDef << std::endl;
        fs << "#define " << macroDef << std::endl << std::endl;
        fs << std::endl << "#include \"" << headerFile.getFileName() << "\"" << std::endl << std::endl;
        for(std::vector<PClassConfig>::const_iterator it(classConfig.begin()); it != classConfig.end(); ++it){
                saveClassTemplate(fs, *it);
        }
        fs << "\n\n#endif\n\n" << std::endl;
        fs.close();
        return true;
}
 
 
void checkClassConfig(bool & hasSource, bool & hasTemplate, const std::vector<PClassConfig> & classConfig){
        hasSource = false;
        hasTemplate = false;
        for(std::vector<PClassConfig>::const_iterator it(classConfig.begin()); it != classConfig.end(); ++it){
                bool isTemplate = it->getListTemplate().size() != 0lu;
                hasSource |= !isTemplate;
                hasTemplate |= isTemplate;
        }
}
 
 
bool saveClassImplDecl(const std::vector<PClassConfig> & classConfig, const PPath & baseFileName, const PVecPath & listInclude, bool enableDataStream, bool enableTypeStream){
        if(baseFileName == "") return false;
        bool hasSource(false), hasTemplate(false);
        checkClassConfig(hasSource, hasTemplate, classConfig);
        PPath includeTemplate("");
        if(hasTemplate){
                includeTemplate = PString(baseFileName.getFileName() + "_impl.h");
        }
        
        if(!saveClassDecl(classConfig, PString(baseFileName + ".h"), listInclude, enableDataStream, enableTypeStream, includeTemplate)) return false;
        
        if(hasSource){
                if(!saveClassImpl(classConfig, PPath(baseFileName + PString(".cpp")), PPath(baseFileName + PString(".h")), enableTypeStream)) return false;
        }
        if(hasTemplate){
                if(!saveClassTemplate(classConfig, PPath(baseFileName + PString("_impl.h")), PPath(baseFileName + PString(".h")))) return false;
        }
        return true;
}