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


//Warning : this file has been generated automatically by the phoenix_hdf5 program
//You can find it at https://gitlab.in2p3.fr/CTA-LAPP/PHOENIX_LIBS/PhoenixHDF5
//Do NOT modify it


#include <string.h>
#include <sstream>
#include "RawHdf5_hdf5.h"

///Initialise the generated table of data
/**	@param tab : table of data
 * 	@param offset : offset of the value to read
*/
void initGeneratedTableRawHdf5(RawHdf5 & tab, size_t offset = 0lu){
	for(size_t i(0lu); i < tab.getNbEntries(); ++i){
		if(tab.getIsEnableSignal()){
			float * ptrSignal = tab.getSignal(i);
			for(size_t NAME_RAWHDF5_SIGNAL_0Idx(0lu); NAME_RAWHDF5_SIGNAL_0Idx < RAWHDF5_SIGNAL_0; ++NAME_RAWHDF5_SIGNAL_0Idx){
				ptrSignal[NAME_RAWHDF5_SIGNAL_0Idx] = (float)((i + offset)*RAWHDF5_SIGNAL_0 + NAME_RAWHDF5_SIGNAL_0Idx);
			}
		}
	}
}

///Check the generated table of data
/**	@param tab : table of data
 * 	@param offset : offset of the value to read
 * 	@return true on success, false otherwise
*/
bool checkGeneratedTableRawHdf5(RawHdf5 & tab, size_t offset = 0lu){
	bool b(true);
	for(size_t i(0lu); i < tab.getNbEntries(); ++i){
		if(tab.getIsEnableSignal()){
			float * ptrSignal = tab.getSignal(i);
			for(size_t NAME_RAWHDF5_SIGNAL_0Idx(0lu); NAME_RAWHDF5_SIGNAL_0Idx < RAWHDF5_SIGNAL_0; ++NAME_RAWHDF5_SIGNAL_0Idx){
				b &= ptrSignal[NAME_RAWHDF5_SIGNAL_0Idx] == (float)((i + offset)*RAWHDF5_SIGNAL_0 + NAME_RAWHDF5_SIGNAL_0Idx);
			}
		}
	}
	std::cout << "checkGeneratedTableRawHdf5 : b = " << b << std::endl;
	return b;
}

///Check the generated table of data
/**	@param tab : table of data
 * 	@param offset : offset of the value to read
 * 	@return true on success, false otherwise
*/
bool checkGeneratedTableRawHdf5Const(const RawHdf5 & tab, size_t offset = 0lu){
	bool b(true);
	for(size_t i(0lu); i < tab.getNbEntries(); ++i){
		if(tab.getIsEnableSignal()){
			const float * ptrSignal = tab.getSignal(i);
			for(size_t NAME_RAWHDF5_SIGNAL_0Idx(0lu); NAME_RAWHDF5_SIGNAL_0Idx < RAWHDF5_SIGNAL_0; ++NAME_RAWHDF5_SIGNAL_0Idx){
				b &= ptrSignal[NAME_RAWHDF5_SIGNAL_0Idx] == (float)((i + offset)*RAWHDF5_SIGNAL_0 + NAME_RAWHDF5_SIGNAL_0Idx);
			}
		}
	}
	std::cout << "checkGeneratedTableRawHdf5 : b = " << b << std::endl;
	return b;
}

///Check the generated table of data
/**	@param tab : table of data
 * 	@param offset : offset of the value to read
 * 	@return true on success, false otherwise
*/
bool checkGeneratedTableBlockRawHdf5(RawHdf5H5 & tab, size_t offset = 0lu){
	bool b(true);
	for(size_t i(0lu); i < tab.getBlockSize(); ++i){
		if(tab.getIsEnableSignal()){
			float * ptrSignal = tab.getSignal(i);
			for(size_t NAME_RAWHDF5_SIGNAL_0Idx(0lu); NAME_RAWHDF5_SIGNAL_0Idx < RAWHDF5_SIGNAL_0; ++NAME_RAWHDF5_SIGNAL_0Idx){
				b &= ptrSignal[NAME_RAWHDF5_SIGNAL_0Idx] == (float)((i + offset)*RAWHDF5_SIGNAL_0 + NAME_RAWHDF5_SIGNAL_0Idx);
			}
		}
	}
	std::cout << "checkGeneratedTableBlockRawHdf5 : b = " << b << std::endl;
	return b;
}

///Test to copy (customize version) data with RawHdf5
/**	@param tabOut[out] : copied RawHdf5
 * 	@param tabIn : RawHdf5 to be copied
*/
void testCopyCustomTmpFunctionRawHdf5(RawHdf5 & tabOut, RawHdf5 & tabIn){
	tabOut.resize(tabIn.getNbEntries());
	for(size_t i(0lu); i < tabIn.getNbEntries(); ++i){
		float* signal;
		tabIn.getRow(i, signal);
		tabOut.setRow(i, signal);
	}
}

///Test to copy (customize version) data with RawHdf5
/**	@param tabOut[out] : copied RawHdf5
 * 	@param tabIn : RawHdf5 to be copied
*/
void testCopyCustomTmpFunctionRawHdf5Const(RawHdf5 & tabOut, const RawHdf5 & tabIn){
	tabOut.resize(tabIn.getNbEntries());
	for(size_t i(0lu); i < tabIn.getNbEntries(); ++i){
		const float* signal;
		tabIn.getRow(i, signal);
		tabOut.setRow(i, signal);
	}
}

///Test to copy (customize version) data with RawHdf5
/**	@return true on success, false otherwise
*/
bool testCopyCustomTmpRawHdf5(){
	RawHdf5 table, tableCopy, tableCopyConst;
	size_t nbRow(10lu);
	table.resize(nbRow);
	initGeneratedTableRawHdf5(table);
	bool b(true);
	b &= checkGeneratedTableRawHdf5Const(table);
	b &= checkGeneratedTableRawHdf5(table);
	testCopyCustomTmpFunctionRawHdf5(tableCopy, table);
	testCopyCustomTmpFunctionRawHdf5Const(tableCopyConst, table);
	b &= checkGeneratedTableRawHdf5Const(tableCopy);
	b &= checkGeneratedTableRawHdf5(tableCopy);
	std::cout << "testCopyCustomTmpRawHdf5 : b = " << b << std::endl;
	return b;
}

///Test to copy data with RawHdf5
/**	@param fileName : name of the file to be written
 * 	@param isEnableSignal : True to enable the signal column, false to disable it
 * 	@return true on success, false otherwise
*/
bool testCopyTmpRawHdf5(bool isEnableSignal){
	RawHdf5 table;
	size_t nbRow(10lu);
	table.setIsEnable(isEnableSignal);	//Enable some columns
	table.resize(nbRow);
	bool b(true);
	
	b &= table.getIsEnableSignal() == isEnableSignal;
	initGeneratedTableRawHdf5(table);
	b &= checkGeneratedTableRawHdf5Const(table);
	b &= checkGeneratedTableRawHdf5(table);
	RawHdf5 tableCopyConstructor(table), tableEqual, tableClone;
	tableEqual = table;
	tableClone.clone(table);
	b &= checkGeneratedTableRawHdf5Const(tableCopyConstructor);
	b &= checkGeneratedTableRawHdf5(tableCopyConstructor);
	b &= checkGeneratedTableRawHdf5Const(tableEqual);
	b &= checkGeneratedTableRawHdf5(tableEqual);
	b &= checkGeneratedTableRawHdf5Const(tableClone);
	b &= checkGeneratedTableRawHdf5(tableClone);
	table.resize(nbRow);
	table.resize(0lu);
	tableEqual.resize(0lu);
	tableClone.resize(nbRow);
	tableClone.resize(0lu);
	std::cout << "testCopyTmpRawHdf5 : b = " << b << std::endl;
	return b;
}

///Test to write data with RawHdf5H5
/**	@param fileName : name of the file to be written
 * 	@param isEnableSignal : True to enable the signal column, false to disable it
 * 	@return true on success, false otherwise
*/
bool testWriteDataRawHdf5(const std::string & fileName, bool isEnableSignal){
	RawHdf5H5 table;
	size_t nbRow(10lu);
	table.setIsEnable(isEnableSignal);	//Enable some columns
	table.resize(nbRow);
	bool b(true);
	
	b &= table.getIsEnableSignal() == isEnableSignal;
	initGeneratedTableRawHdf5(table);
	b &= checkGeneratedTableRawHdf5Const(table);
	b &= checkGeneratedTableRawHdf5(table);
	//And write our table directly in it
	table.write(fileName);
	table.softResize(nbRow/2lu);
	table.softResize(nbRow*2lu);
	table.softResize(nbRow - 2lu);
	table.setTableName("RawHdf5");
	std::cout << "ph5_backendTestWriteDataRawHdf5 : b = " << b << std::endl;
	return b;
}

///Test to read data with RawHdf5H5
/**	@param fileName : name of the file to be read
 * 	@param isEnableSignal : True to enable the signal column, false to disable it
 * 	@return true on success, false otherwise
*/
bool testReadDataRawHdf5(const std::string & fileName, bool isEnableSignal){
	RawHdf5H5 table;
	table.setIsEnable(isEnableSignal);	//Enable some columns
	//And read the file
	table.read(fileName);
	bool b(true);
	b &= checkGeneratedTableRawHdf5Const(table);
	b &= checkGeneratedTableRawHdf5(table);
	//Let's check the copy and clone methods
	RawHdf5H5 tableCopyConstructor(table), tableEqual, tableClone;
	tableEqual = table;
	tableClone.clone(table);
	b &= checkGeneratedTableRawHdf5Const(tableCopyConstructor);
	b &= checkGeneratedTableRawHdf5(tableCopyConstructor);
	b &= checkGeneratedTableRawHdf5Const(tableEqual);
	b &= checkGeneratedTableRawHdf5(tableEqual);
	b &= checkGeneratedTableRawHdf5Const(tableClone);
	b &= checkGeneratedTableRawHdf5(tableClone);
	tableEqual.setTableName("Jeanine");
	std::cout << "ph5_backendTestReadDataRawHdf5 : b = " << b << std::endl;
	return b;
}

///Test to read data by block with RawHdf5H5
/**	@param fileName : name of the file to be read
 * 	@param offset : offset of the first row to be read
 * 	@param nbRow : number of rows to be read
 * 	@param isEnableSignal : True to enable the signal column, false to disable it
 * 	@return true on success, false otherwise
*/
bool testReadBlockDataRawHdf5(const std::string & fileName, size_t offset, size_t nbRow, bool isEnableSignal){
	RawHdf5H5 table;
	table.setIsEnable(isEnableSignal);	//Enable some columns
	//And read the file
	table.read(fileName, offset, nbRow);
	bool b(true);
	b &= checkGeneratedTableRawHdf5Const(table, offset);
	b &= checkGeneratedTableRawHdf5(table, offset);
	std::cout << "testReadBlockDataRawHdf5(offset = "<<offset<<", nbRow = "<<nbRow<<") : b = " << b << std::endl;
	return b;
}

///Test to read data by block and iterate on them with RawHdf5H5
/**	@param fileName : name of the file to be read
 * 	@param nbRow : number of rows to be read
 * 	@param isEnableSignal : True to enable the signal column, false to disable it
 * 	@return true on success, false otherwise
*/
bool testReadIterBlockDataRawHdf5(const std::string & fileName, size_t nbRow, bool isEnableSignal){
	RawHdf5H5 table;
	table.setIsEnable(isEnableSignal);	//Enable some columns
	//And read the file by block
	table.openDataSetBlock(fileName, nbRow);
	bool b(true);
	b &= table.getFullDataSetSize() != 0lu;
	size_t offset = table.getBlockOffset();
	while(table.iterateBlock()){
		b &= checkGeneratedTableBlockRawHdf5(table, offset);
		offset = table.getBlockOffset();
	}
	std::cout << "testReadIterBlockDataRawHdf5(offset = "<<offset<<", nbRow = "<<nbRow<<") : b = " << b << std::endl;
	return b;
}

///Test to read data by block and iterate on them with RawHdf5H5
/**
 * 	@param isEnableSignal : True to enable the signal column, false to disable it
 * 	@return true on success, false otherwise
*/
bool testColumnSelectionRawHdf5(bool isEnableSignal){
	bool b(true);
	b &= testCopyTmpRawHdf5(isEnableSignal);
	b &= testCopyCustomTmpRawHdf5();
	std::string fileName("baseConfig.h5");
	b &= testWriteDataRawHdf5(fileName, isEnableSignal);
	b &= testReadDataRawHdf5(fileName, isEnableSignal);
	b &= testReadBlockDataRawHdf5(fileName, 0lu, 10lu, isEnableSignal);
	b &= testReadBlockDataRawHdf5(fileName, 1lu, 5lu, isEnableSignal);
	b &= testReadBlockDataRawHdf5(fileName, 3lu, 4lu, isEnableSignal);
	b &= testReadBlockDataRawHdf5(fileName, 5lu, 5lu, isEnableSignal);
	b &= testReadBlockDataRawHdf5(fileName, 2lu, 8lu, isEnableSignal);
	b &= testReadIterBlockDataRawHdf5(fileName, 4lu, isEnableSignal);
	std::cout << "testColumnSelectionRawHdf5(isEnableSignal = " << isEnableSignal << ") : b = " << b << std::endl;
	return b;
}

bool mainCheckRawHdf5(){
	bool b(true);
	b &= testColumnSelectionRawHdf5(true);
	b &= testColumnSelectionRawHdf5(true);
	b &= testColumnSelectionRawHdf5(false);
	std::cout << "mainCheckRawHdf5 : b = " << b << std::endl;
	return b;
}

int main(){
	bool b(true);
b &= mainCheckRawHdf5();
	std::cout << "Final : b = " << b << std::endl;
	return b - 1;
}