CppTraitCopy.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : LGPL-3.0-only
****************************************/
 
#include "type_utils.h"
#include "CppTraitCopy.h"
 


void class_createCheckClassEquality(std::ofstream & fs, const PClassConfig & classConfig, bool isConst){
        PString name(classConfig.getName()), strConst("");
        if(isConst){
                strConst = "const ";
        }
        fs << "///Check the equality between two "+name+" classes\n";
        fs << "/**\t@param var : variable to be checked\n";
        fs << " * \t@param reference : reference\n";
        fs << " * \t@return true on success, false otherwise\n";
        fs << "*/\n";
        fs << "bool check"+name+"Equality";
        if(isConst){
                fs << "Const";
        }
        fs << "(" + strConst + name + " & var, " + strConst + name + " & reference){\n";
        fs << "\tbool b(true);\n";
        const PVecClassAttribute & listAttr = classConfig.getListAttribute();
        for(PVecClassAttribute::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                PString attrName(it->getName().firstToUpper());
                bool isSimpleType = getIsSimpleType(it->getType());
//              std::cout << "createCheckClassEquality : attrName = '"<<attrName<<"', isSimpleType = " << isSimpleType << ", it->getIsPointer() = " << it->getIsPointer() << ", it->getIsReference() = " << it->getIsReference() << std::endl;
                if(isSimpleType || it->getIsPointer() || it->getType() == "PString"){
                        fs << "\tb &= var.get"+attrName+"() == reference.get"+attrName+"();\n";
                }
        }
        fs << "\treturn b;\n";
        fs << "}\n\n";
}


bool copy_hasPointerAttribute(const PClassConfig & classConfig){
        const PVecClassAttribute & listAttr(classConfig.getListAttribute());
        for(PVecClassAttribute::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(getIsPointerType(it->getType())){return true;}
        }
        return false;
}


void class_createTestClassCopy(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        PString name(classConfig.getName());
        fs << "///Check copy of class "+name+"\n";
        fs << "void check"+name+"Copy(){\n";
        fs << "\t"+name+" reference;\n";
        fs << "\t//Let's use the setters\n";
        const PVecClassAttribute & listAttr = classConfig.getListAttribute();
        for(PVecClassAttribute::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                PString defaultValue(getTestDefaultValueTypeInCpp(it->getType())), attrName(it->getName().firstToUpper());;
                if(defaultValue != ""){
                        fs << "\treference.set"+attrName+"("+defaultValue+");\n";
                }
        }
        fs << "\t"+name+" varCopy(reference);\n";
        fs << "\t"+name+" varEqual;\n";
        fs << "\tvarEqual = reference;\n";
        fs << "\t"<<mode.assertCall<<"(check"+name+"Equality(varCopy, reference));\n";
        fs << "\t"<<mode.assertCall<<"(check"+name+"EqualityConst(varCopy, reference));\n";
        fs << "\t"<<mode.assertCall<<"(check"+name+"Equality(varEqual, reference));\n";
        fs << "\t"<<mode.assertCall<<"(check"+name+"EqualityConst(varEqual, reference));\n";
        fs << "}\n\n";
}

CppTraitCopy::CppTraitCopy()
        :PAbstractTraitBackend()
{}

CppTraitCopy::~CppTraitCopy(){}


void CppTraitCopy::publicMethodDeclaration(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        //Rule of zero : no hand-written copy constructor / operator= anymore, let the compiler generate them (or delete them, for classes owning a unique_ptr attribute)
}


void CppTraitCopy::publicMethodImplementation(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        //Rule of zero : no hand-written copy constructor / operator= anymore, let the compiler generate them (or delete them, for classes owning a unique_ptr attribute)
}


void CppTraitCopy::protectedMethodDeclaration(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        //Rule of zero : no hand-written copy<Name>() helper anymore
}


void CppTraitCopy::protectedMethodImplementation(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        //Rule of zero : no hand-written copy<Name>() helper anymore
}
 


void CppTraitCopy::testFunction(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableCopy || !mode.enableGetter || classConfig.getIsEnum()){return;}
        class_createCheckClassEquality(fs, classConfig, false);
        class_createCheckClassEquality(fs, classConfig, true);
        //A class owning a pointer attribute (std::unique_ptr storage) is no longer copyable under rule of zero, so no copy test can be generated for it
        if(!copy_hasPointerAttribute(classConfig)){
                class_createTestClassCopy(fs, classConfig, mode);
        }
}


void CppTraitCopy::testCallFunction(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableCopy || classConfig.getIsEnum()){return;}
        PString name(classConfig.getName());
        if(!mode.enableGetter){
                fs << "\t//Cannot create check"+name+"Copy() because there is no getter enabled" << std::endl;
                return;
        }
        if(copy_hasPointerAttribute(classConfig)){
                fs << "\t//Cannot create check"+name+"Copy() because "+name+" owns a pointer attribute and is not copyable anymore" << std::endl;
                return;
        }
        fs << "\tcheck"+name+"Copy();\n";
}