NanobindTraitDataStream.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Thibaut Oprinsen
        Mail : thibaut.oprinsen@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "NanobindTraitDataStream.h"

NanobindTraitDataStream::NanobindTraitDataStream()
: PAbstractNanobindTraitBackend()
{}

NanobindTraitDataStream::~NanobindTraitDataStream(){}

void registerDeserializationMethods(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        PString name(classConfig.getName());
        if(classConfig.getIsEnum()){
                name = name + "::" + name;
        }
        fs << std::endl << std::endl << "\t\t///Deserialization method for " << name;
        fs << std::endl << "\t\t.def_static(\"from_bytes\", [](const nb::bytearray &b) -> " << name << " {";
        fs << std::endl << "\t\t\t\t" << name << " result;";
        fs << std::endl << "\t\t\t\tDataStreamIter iter((DataStreamIter)b.data());";
        fs << std::endl << "\t\t\t\tbool res(data_message_load(iter, result));";
        fs << std::endl << "\t\t\t\tif(!res){";
        fs << std::endl << "\t\t\t\t\tthrow nb::buffer_error(\"Failed to deserialize " << name << "\");";
        fs << std::endl << "\t\t\t\t}";
        fs << std::endl << "\t\t\t\treturn result;";
        fs << std::endl << "\t\t\t}, ";
        fs << std::endl << "\t\t\t\"Load a " << name << " from a bytearray\"";
        fs << std::endl << "\t\t)";
}

void registerSerializationMethods(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        PString name(classConfig.getName());
        if(classConfig.getIsEnum()){
                name = name + "::" + name;
        }
        fs << std::endl << std::endl << "\t\t///Serialization method for " << name;
        fs << std::endl << "\t\t.def(\"to_bytes\", [](const " << name << " & self) -> nb::bytearray {";
        fs << std::endl << "\t\t\t\tsize_t size = data_size(self);";
        fs << std::endl << "\t\t\t\tnb::bytearray msg(NULL, size);";
        fs << std::endl << "\t\t\t\tDataStreamIter iter((DataStreamIter)msg.data());";
        fs << std::endl << "\t\t\t\tbool success = data_message_save(iter, self);";
        fs << std::endl << "\t\t\t\tif(success){";
        fs << std::endl << "\t\t\t\t\treturn msg;";
        fs << std::endl << "\t\t\t\t}else{";
        fs << std::endl << "\t\t\t\t\tthrow nb::buffer_error(\"Failed to serialize " << name << "\");";
        fs << std::endl << "\t\t\t\t}";
        fs << std::endl << "\t\t\t}, ";
        fs << std::endl << "\t\t\t\"Serialize the " << name << " to bytearray\"";
        fs << std::endl << "\t\t)";
}

void registerSizeMethod(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        PString name(classConfig.getName());
        if(classConfig.getIsEnum()){
                name = name + "::" + name;
        }
        fs << std::endl << std::endl << "\t\t///Size method for " << name;
        fs << std::endl << "\t\t.def(\"get_size\", [](const " << name << " & self) -> size_t {";
        fs << std::endl << "\t\t\t\treturn data_size(self);";
        fs << std::endl << "\t\t\t}, ";
        fs << std::endl << "\t\t\t\"Get the size of the " << name << " in bytes\"";
        fs << std::endl << "\t\t)";
}

void NanobindTraitDataStream::registerMethod(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableDataStream){return;}
        PString name(classConfig.getName());
 
        registerSerializationMethods(fs, classConfig, mode);
        registerDeserializationMethods(fs, classConfig, mode);
        registerSizeMethod(fs, classConfig, mode);
}
 

void failed_enum_deserialization(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode, const PString & baseFileName){
        PString name(classConfig.getName());
        PString moduleName = baseFileName.toLower();
        fs << "def test_data_stream_deserialization_failed():" << std::endl;
        fs << "\t\"\"\"Test data stream conversion\"\"\"" << std::endl;
        fs << "\t#Test with the value 8 even if there are only two values in the enum" << std::endl;
        fs << "\tdata_stream = bytearray(b'\\x08\\x00\\x00\\x00')" << std::endl;
        fs << "\twith pytest.raises(ValueError, match=\".* is not a valid "<<name<<"\"):" << std::endl;
        fs << "\t\ttest_value = " << moduleName << "." << name << ".from_bytes(data_stream)" << std::endl;
        fs << std::endl;
}

void NanobindTraitDataStream::testFunction(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode, const PString & baseFileName) const{
        if(!mode.enableDataStream){return;}
        PString name(classConfig.getName());
        PString moduleName = baseFileName.toLower();
        fs << "def test_data_stream_conversion():" << std::endl;
        fs << "\t\"\"\"Test data stream conversion\"\"\"" << std::endl;
        
        const PVecClassAttribute & listAttr(classConfig.getListAttribute());
        if(classConfig.getIsEnum()){
                if(listAttr.size() != 0lu){
                        fs << "\ttest_value1 = " << moduleName << "." << name << "." << listAttr.front().getName() << std::endl;
                }
                fs << "\tdata_stream = test_value1.to_bytes()" << std::endl;
                fs << "\tassert data_stream == bytearray(b'\\x00\\x00\\x00\\x00')" << std::endl;
                fs << "\ttest_value2 = " << moduleName << "." << name << ".from_bytes(data_stream)" << std::endl;
                fs << std::endl;
                fs << "\tassert test_value1.get_size() == 4" << std::endl;
                fs << "\tassert test_value1 == test_value2" << std::endl;
                fs << std::endl;
        }else{
                fs << "\t" << name.toLower() << " = " << moduleName << "." << name << "()" << std::endl;
                fs << "\t# Set some example values" << std::endl;
                for(PVecClassAttribute::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                        PString defaultValue = getTestDefaultValueTypeInPython(it->getType());
                        if(defaultValue != ""){
                                fs << "\t" << name.toLower() << "." << it->getName() << " = " << defaultValue << std::endl;
                        }
                }
                fs << std::endl;
                fs << "\tdata_stream = " << name.toLower() << ".to_bytes()" << std::endl;
                fs << std::endl;
                fs << "\tnew_" << name.toLower() << " = " << moduleName << "." << name << "()" << std::endl;
                fs << "\tnew_" << name.toLower() << " = " << moduleName << "." << name << ".from_bytes(data_stream)" << std::endl;
                fs << std::endl;
                for(PVecClassAttribute::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                        PString defaultValue = getTestDefaultValueTypeInPython(it->getType());
                        if(defaultValue != ""){
                                fs << "\tassert new_" << name.toLower() << "." << it->getName() << " == " << defaultValue << std::endl;
                        }
                }
                fs << std::endl;
                fs << "def test_serialization_type_errors():" << std::endl;
                fs << "\t\"\"\"Test erro types for from_bytes\"\"\"" << std::endl;
                fs << std::endl;
                fs << "\t" << name.toLower() << " = " << moduleName << "." << name << "()" << std::endl;
                fs << "\twith pytest.raises(TypeError, match=\".*from_bytes\\(\\): incompatible function arguments.*\"):" << std::endl;
                fs << "\t\tresult = " << name.toLower() << ".from_bytes(\"A string is not a bytearray !!!\")  # deserialize string instead of bytearray" << std::endl;
                fs << std::endl;
                fs << "\twith pytest.raises(TypeError, match=\".*from_bytes\\(\\): incompatible function arguments.*\"):" << std::endl;
                fs << "\t\tresult = " << name.toLower() << ".from_bytes(42)  #  deserialize instead of bytearray" << std::endl;
                fs << std::endl;
                fs << "\twith pytest.raises(TypeError, match=\".*from_bytes\\(\\): incompatible function arguments.*\"):" << std::endl;
                fs << "\t\tresult = " << name.toLower() << ".from_bytes([1, 2, 3, 4])  # deserialize list instead of bytearray" << std::endl;
                fs << std::endl;
        }
        if(classConfig.getIsEnum()){
                failed_enum_deserialization(fs, classConfig, mode, baseFileName);
        }
}
        
void NanobindTraitDataStream::testCallFunction(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableDataStream){return;}
        PString name(classConfig.getName());
        fs << "\ttest_data_stream_conversion()" << std::endl;
        fs << "\ttest_serialization_type_errors()" << std::endl;
}