data_stream_message.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
 
#include "data_stream_message.h"
 
 
 
bool DataStream<char*, DataStreamMode::READ, bool>::data_stream(char* & ds, bool & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(bool));
        ds += sizeof(bool);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, bool>::data_stream(char* & ds, bool * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(bool)*nbElement);
        ds += sizeof(bool)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, bool>::data_stream(char* & ds, bool & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(bool));
        ds += sizeof(bool);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, bool>::data_stream(char* & ds, bool * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(bool)*nbElement);
        ds += sizeof(bool)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, char>::data_stream(char* & ds, char & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(char));
        ds += sizeof(char);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, char>::data_stream(char* & ds, char * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(char)*nbElement);
        ds += sizeof(char)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, char>::data_stream(char* & ds, char & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(char));
        ds += sizeof(char);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, char>::data_stream(char* & ds, char * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(char)*nbElement);
        ds += sizeof(char)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, short>::data_stream(char* & ds, short & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(short));
        ds += sizeof(short);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, short>::data_stream(char* & ds, short * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(short)*nbElement);
        ds += sizeof(short)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, short>::data_stream(char* & ds, short & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(short));
        ds += sizeof(short);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, short>::data_stream(char* & ds, short * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(short)*nbElement);
        ds += sizeof(short)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, int>::data_stream(char* & ds, int & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(int));
        ds += sizeof(int);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, int>::data_stream(char* & ds, int * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(int)*nbElement);
        ds += sizeof(int)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, int>::data_stream(char* & ds, int & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(int));
        ds += sizeof(int);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, int>::data_stream(char* & ds, int * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(int)*nbElement);
        ds += sizeof(int)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, long int>::data_stream(char* & ds, long int & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(long int));
        ds += sizeof(long int);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, long int>::data_stream(char* & ds, long int * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(long int)*nbElement);
        ds += sizeof(long int)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, long int>::data_stream(char* & ds, long int & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(long int));
        ds += sizeof(long int);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, long int>::data_stream(char* & ds, long int * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(long int)*nbElement);
        ds += sizeof(long int)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, unsigned char>::data_stream(char* & ds, unsigned char & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(unsigned char));
        ds += sizeof(unsigned char);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, unsigned char>::data_stream(char* & ds, unsigned char * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(unsigned char)*nbElement);
        ds += sizeof(unsigned char)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, unsigned char>::data_stream(char* & ds, unsigned char & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(unsigned char));
        ds += sizeof(unsigned char);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, unsigned char>::data_stream(char* & ds, unsigned char * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(unsigned char)*nbElement);
        ds += sizeof(unsigned char)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, unsigned short>::data_stream(char* & ds, unsigned short & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(unsigned short));
        ds += sizeof(unsigned short);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, unsigned short>::data_stream(char* & ds, unsigned short * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(unsigned short)*nbElement);
        ds += sizeof(unsigned short)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, unsigned short>::data_stream(char* & ds, unsigned short & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(unsigned short));
        ds += sizeof(unsigned short);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, unsigned short>::data_stream(char* & ds, unsigned short * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(unsigned short)*nbElement);
        ds += sizeof(unsigned short)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, unsigned int>::data_stream(char* & ds, unsigned int & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(unsigned int));
        ds += sizeof(unsigned int);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, unsigned int>::data_stream(char* & ds, unsigned int * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(unsigned int)*nbElement);
        ds += sizeof(unsigned int)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, unsigned int>::data_stream(char* & ds, unsigned int & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(unsigned int));
        ds += sizeof(unsigned int);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, unsigned int>::data_stream(char* & ds, unsigned int * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(unsigned int)*nbElement);
        ds += sizeof(unsigned int)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, long unsigned int>::data_stream(char* & ds, long unsigned int & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(long unsigned int));
        ds += sizeof(long unsigned int);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, long unsigned int>::data_stream(char* & ds, long unsigned int * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(long unsigned int)*nbElement);
        ds += sizeof(long unsigned int)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, long unsigned int>::data_stream(char* & ds, long unsigned int & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(long unsigned int));
        ds += sizeof(long unsigned int);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, long unsigned int>::data_stream(char* & ds, long unsigned int * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(long unsigned int)*nbElement);
        ds += sizeof(long unsigned int)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, float>::data_stream(char* & ds, float & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(float));
        ds += sizeof(float);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, float>::data_stream(char* & ds, float * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(float)*nbElement);
        ds += sizeof(float)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, float>::data_stream(char* & ds, float & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(float));
        ds += sizeof(float);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, float>::data_stream(char* & ds, float * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(float)*nbElement);
        ds += sizeof(float)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, double>::data_stream(char* & ds, double & data){
        char* srcByte = (char*)&data;
        memcpy(srcByte, ds, sizeof(double));
        ds += sizeof(double);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, double>::data_stream(char* & ds, double * data, size_t nbElement){
        char* srcByte = (char*)data;
        memcpy(srcByte, ds, sizeof(double)*nbElement);
        ds += sizeof(double)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, double>::data_stream(char* & ds, double & data){
        const char* srcByte = (const char*)&data;
        memcpy(ds, srcByte, sizeof(double));
        ds += sizeof(double);
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::WRITE, double>::data_stream(char* & ds, double * data, size_t nbElement){
        const char* srcByte = (const char*)data;
        memcpy(ds, srcByte, sizeof(double)*nbElement);
        ds += sizeof(double)*nbElement;
        return true;
}
 
 
bool DataStream<char*, DataStreamMode::READ, std::string>::data_stream(char* & ds, std::string & data){
        size_t nbElement(0lu);
        bool b = DataStream<char*, DataStreamMode::READ, size_t>::data_stream(ds, nbElement);
        if(nbElement == 0lu || !b){return b;}
        data.resize(nbElement);
        memcpy((char*)data.data(), ds, nbElement);
        ds += nbElement;
        return b;
}
 
 
 
bool DataStream<char*, DataStreamMode::WRITE, std::string>::data_stream(char* & ds, std::string & data){
        size_t nbElement(data.size());
        bool b = DataStream<char*, DataStreamMode::WRITE, size_t>::data_stream(ds, nbElement);
        if(nbElement == 0lu || !b){return b;}
        memcpy(ds, (const char*)data.data(), nbElement);
        ds += nbElement;
        return b;
}