Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	tmp_project/DataStream/src/data_stream_message.cpp	Lines:	235	235	100.0 %
Date:	2024-12-09 15:30:52	Branches:	7	11	63.6 %

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/


#include "data_stream_message.h"


///Read the bool in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the bool in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the bool in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the bool in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the char in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the char in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the char in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the char in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the short in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the short in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the short in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the short in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the int in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the int in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the int in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the int in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the long int in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the long int in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the long int in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the long int in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the unsigned char in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the unsigned char in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the unsigned char in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the unsigned char in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the unsigned short in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the unsigned short in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the unsigned short in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the unsigned short in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the unsigned int in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the unsigned int in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the unsigned int in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the unsigned int in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the long unsigned int in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the long unsigned int in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the long unsigned int in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the long unsigned int in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the float in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the float in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the float in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the float in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Read the double in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@return true on success, false otherwise
*/
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;
}

///Read the double in the message
/**	@param[out] ds : message to be read
* 	@param[out] data : data to be set
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Save the double in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@return true on success, false otherwise
*/
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;
}

///Save the double in the message
/**	@param[out] ds : message to be written
* 	@param data : data to be saved in the message
* 	@param nbElement : number of element of the data
* 	@return true on success, false otherwise
*/
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;
}

///Load a std::string from a message
/**	@param[out] ds : message iterator which contains std::string
* 	@param data : std::string to be loaded
* 	@return true on success, false otherwise
*/
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;
}


///Save a std::string into a message
/**	@param[out] ds : message iterator to be written
* 	@param data : std::string to be saved
* 	@return true on success, false otherwise
*/
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;
}



Generated by: GCOVR (Version 4.2)