/***************************************
	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.h"

///Constructor of the class RawHdf5
RawHdf5::RawHdf5(){
	initialisationRawHdf5();
}

///Copy constructor of the class RawHdf5
/**	@param other : RawHdf5 to be copied
*/
RawHdf5::RawHdf5(const RawHdf5 & other){
	initialisationRawHdf5();
	copyRawHdf5(other);
}

///Destructor of the class RawHdf5
RawHdf5::~RawHdf5(){
	clear();
}

///Equal operator of the class RawHdf5
/**	@param other : RawHdf5 to be copied
 * 	@return copied RawHdf5
*/
RawHdf5 & RawHdf5::operator = (const RawHdf5 & other){
	copyRawHdf5(other);
	return *this;
}

///Clone the columns of other in the current RawHdf5 without copy
/**	@param other : RawHdf5 to be cloned
*/
void RawHdf5::clone(RawHdf5 & other){
	p__isOwnData = false;
	p__nbRow = other.p__nbRow;
	p__nbReservedRow = other.p__nbReservedRow;
	//Let's copy proper attributes of the RawHdf5
	//Let's clone the columns
	p_signal = other.p_signal;
	p__isEnableSignal = other.p__isEnableSignal;
}

///Get the total number of rows in the current Table RawHdf5
/**	@return total number of rows
*/
size_t RawHdf5::getNbEntries() const{
	return p__nbRow;
}

///Resize the table RawHdf5
/*	@param nbRow : new number of rows of the Table
*/
void RawHdf5::resize(size_t nbRow){
	if(nbRow == p__nbRow || !p__isOwnData){return;}	//Nothing to do
	clear();
	allocate(nbRow);
}

///Soft Resize of the table RawHdf5
/*	@param nbRow : new number of rows of the Table (if already allocated)
 * 	The soft resize is used to reduce the number of rows of the current table
*/
void RawHdf5::softResize(size_t nbRow){
	if(nbRow < p__nbReservedRow){
		p__nbRow = nbRow;
	}
}

///Enable/Disable for all columns
/**	@param isEnableSignal : True to enable the signal column, false to disable it
*/
void RawHdf5::setIsEnable(bool isEnableSignal){
	setIsEnableSignal(isEnableSignal);
}

///Enable/Disable the signal column
/**	@param isEnableSignal : true to enable the signal column, false to disable it
*/
void RawHdf5::setIsEnableSignal(bool isEnableSignal){
	p__isEnableSignal = isEnableSignal;
}

///Get is the signal column is Enable or Disable
/**	@return true to enable the signal column, false to disable it
*/
bool RawHdf5::getIsEnableSignal() const{
	return p__isEnableSignal;
}

///Clear the table RawHdf5 (delete all column)
void RawHdf5::clear(){
	if(p_signal != NULL && p__isOwnData){delete [] p_signal;p_signal = NULL;}
}

///Set a full row of the table RawHdf5
/**	@param i : index of the row to be set
 * 	@param signal : attribute to be set
*/
void RawHdf5::setRow(size_t i, const float * signal){
	setSignal(i, signal);
}

///Get a full row of the table RawHdf5 (without tensor copy, only with pointer)
/**	@param i : index of the row to get its values
 * 	@param[out] signal : attribute to be get
*/
void RawHdf5::getRow(size_t i, float *& signal){
	signal = getSignal(i);
}

///Get a full row of the table RawHdf5 (without tensor copy, only with pointer)
/**	@param i : index of the row to get its values
 * 	@param[out] signal : attribute to be get
*/
void RawHdf5::getRow(size_t i, const float *& signal) const{
	signal = getSignal(i);
}

///Set the attribute signal (column signal)
/**	@param i : index of the row to be used
 * 	@param tabVal : table of value to be copied
*/
void RawHdf5::setSignal(size_t i, const float * tabVal){
	size_t sizeRow(RAWHDF5_SIGNAL_0);
	memcpy(p_signal + i*sizeRow, tabVal, sizeRow*sizeof(float));
}

///Get the full column of the attribute signal (column signal)
/**	@return pointer of the full column
*/
const float * RawHdf5::getSignalFull() const{
	return p_signal;
}

///Get the full column of the attribute signal (column signal)
/**	@return pointer of the full column
*/
float * RawHdf5::getSignalFull(){
	return p_signal;
}

///Get the tensor i of the attribute signal (column signal)
/**	@param i : index of the row to be used
 * 	@return pointer to the corresponding tensor
*/
const float * RawHdf5::getSignal(size_t i) const{
	return p_signal + i*RAWHDF5_SIGNAL_0;
}

///Get the tensor i of the attribute signal (column signal)
/**	@param i : index of the row to be used
 * 	@return pointer to the corresponding tensor
*/
float * RawHdf5::getSignal(size_t i){
	return p_signal + i*RAWHDF5_SIGNAL_0;
}

///Initialises the table RawHdf5
void RawHdf5::initialisationRawHdf5(){
	p__isOwnData = true;
	p__nbRow = 0lu;
	p__nbReservedRow = 0lu;
	p_signal = NULL;
	p__isEnableSignal = true;
}

///Allocate the table RawHdf5 (delete all column)
/**	@param nbRow : new number of rows of the Table
*/
void RawHdf5::allocate(size_t nbRow){
	p__isOwnData = true;
	p__nbRow = nbRow;
	p__nbReservedRow = p__nbRow;
	if(p__nbRow == 0lu){
		clear();
		return;
	}
	allocateColumn(p_signal, p__nbRow*RAWHDF5_SIGNAL_0, p__isEnableSignal);
}

///Copy function of the class RawHdf5
/**	@param other : RawHdf5 to be copied
*/
void RawHdf5::copyRawHdf5(const RawHdf5 & other){
	//Let's copy proper attributes of the RawHdf5
	//Let's allocate columns of RawHdf5
	allocate(other.p__nbRow);	//Let's allocate properly everything
	//Let's copy columns of RawHdf5
	copyColumn(p_signal, p__isEnableSignal, other.p_signal, p__nbRow*RAWHDF5_SIGNAL_0, other.p__isEnableSignal);
}