#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-01-18/DAQDataFormats/cxx/include/RawDAQData.h"

Inheritance diagram for daqdataformats::RawDAQData:

Public Member Functions
virtual	~RawDAQData ()

virtual void	copy (const RawDAQData &)
	Deep copy from the DAQDataFormat. More...

virtual void	copy (const void *buffer)
	Shallow copy from the external buffer. More...

void *	readData (const void *buffer)
	Shallow copy constructor. More...

void *	readData (const void *buffer, const uint32_t size_of_data)
	Read from the buffer if the size of data is known. More...

virtual readDataStatus	readData (const int fd)
	From the File descriptor. More...

void *	writeData (const void *buffer) const
	Write Data to target memory location. Return is the address of the end of the write. NULL on error. More...

ssize_t	writeData (const int fd) const
	Write Data to target file descriptor. Return is the number of bytes written. -1 on error. More...

uint32_t	calculateCheckSum (const uint32_t skip_last_words) const

void *	getBuffer () const

bool	setBufferSource (const void *)
	We are not going to overload these funtions, so no need to declare them virtual. More...

bool	resetBufferSource ()

virtual bool	clear ()
	reset _Buffer to point to InternalBuffer More...

bool	reset ()
	Reset. More...

bool	isInternalBuffer () const

void	init ()

void	print (std::ostream &os=std::cout) const
	Method for printing the content of the Buffer. More...

void	print (std::string &output_string) const
	print into the string More...

uint32_t	sizeofdata () const
	Sizeof method for the current data block. Returns the size of the data block in 32bit words. More...

virtual bool	addCheckSum ()
	Add the CRC into the end of fBuffer. CRC of all but the last words of the _Buffer. More...

Protected Member Functions
	RawDAQData ()
	Default Constructor. More...

	RawDAQData (version_t)

	RawDAQData (version_t, sizeofdata_t)

	RawDAQData (version_t, bool use_setBufferSourceUnknownVersion)

	RawDAQData (version_t, bool use_setBufferSourceUnknownVersion, sizeofdata_t)

	RawDAQData (init_t)

	RawDAQData (version_t, init_t)

	RawDAQData (version_t, init_t, sizeofdata_t)

	RawDAQData (version_t, init_t, sizeofdata_t, setBufferSource_t)

	RawDAQData (version_t, init_t, sizeofdata_t, setBufferSource_t, print_t, readData_t)

	RawDAQData (const RawDAQData &)
	Deep copy. More...

void *	readDataGeneral (const void *buffer)
	General ReadData method when the sizeofdata is known. More...

virtual version_t	figureOutTheVersion (const void *buffer) const =0

bool	checkBufferInternalness ()
	If the buffer should be internal, check it's pointers and reassign them. More...

virtual bool	setFunctionPointers ()=0

void *	setBufferSourceGeneral (RawDAQData &, const void *)
	Set BufferSource of the input DataFormat and return pointer to the position right after the end of its buffer. More...

bool	setBufferSourceUnknownVersion (const void *)

bool	reserveInternalBuffer (const uint32_t size_of_data)
	Reserve space for the internal buffer to some predetermined size. More...

bool	addToInternalBuffer (const uint32_t size_of_data_to_add)
	Add Zeros to internal buffer. More...

bool	resizeInternalBuffer (const uint32_t size_of_data)
	Resize the internal buffer. More...

uint32_t	boolToUint32_t (const bool number) const

bool	uint32_tToBool (const uint32_t number) const

void	printGeneral (std::ostream &os=std::cout) const

void	printBuffer (std::ostream &os=std::cout, const bool print_offset=true,const bool print_ascii=true,const bool print_buffer_address=false,const bool print_internal_buffer=false,const bool print_size_of_data=false,const std::string separation_between_lines="\n",const uint32_t cols=4) const

void	printWord (const uint32_t iword, const bool is_bynary_printing, std::ostream &os=std::cout) const
	Print word from Buffer. More...

void	printWordBinary (const uint32_t word, std::ostream &os=std::cout) const
	! Print the i-th word of _Buffer, is_bynary_printing: true = bynary, false = HEX More...

void	printWordHex (const uint32_t word, std::ostream &os=std::cout) const

void	printBinary (const void *buffer0, const uint32_t size, std::ostream &os=std::cout) const

void	printHex (const void *buffer0, const uint32_t size, std::ostream &os=std::cout) const

void	printUnknownVersion (std::ostream &out_stream=std::cout) const

void *	readDataGeneral (const void *buffer, const uint32_t size_of_data_to_read)
	Generic readData methods. More...

void *	readDataGeneral (const void *buffer, const uint32_t size_of_data_to_read, const uint32_t buffer_start_position)

bool	functionIsNotAllowed (const std::string function="", const std::string message="") const
	One can call this function from another function, which usage is not allowed (for a particular version). More...

void	defaultConstructorFixedSize ()

void	defaultConstructorFixedSize (init_t)

void	defaultConstructorFloatingSize ()

void	defaultConstructorFloatingSize (init_t)

void *	readDataUnknownVersion (const void *buffer)
	Read data from the unknown version. More...

bool	isVersionUnknown () const
	is current _version unknown? More...

bool	isVersionUnknown (const version_t version) const
	is input version unknown? More...

uint64_t	getUint64_t (uint32_t low_word, uint32_t hi_word) const
	Get uint64_t from low and hi word. More...

bool	getLoAndHi (uint64_t input_data, uint32_t &output_low_word, uint32_t &output_hi_word) const

bool	setUint64_t (uint64_t value, DELEGATE(RawDAQData, function_set_low_word, bool, uint32_t),)

std::string	generateExceptionForWrongVersion (version_t maximum_version) const
	Generating exception message as the version of DAQDataFormat is greater than the maximum allowed. More...

void	lastOperationsInDeepCopy (const RawDAQData &copy_in)
	Need to perform these operations in Deep Copy constructor. More...

	Init_t (_function_init)
	Some common function pointers used in each DAQDataFormats class. More...

	Sizeofdata_t (_function_sizeofdata)

	Print_t (_function_print)

	ReadData_t (_function_readData)

	SetBufferSource_t (_function_setBufferSource)

	EXECUTE_ON_DEBUG (std::string _dataFormatClassName)
	These variables are only for Debugging purposes. More...

	EXECUTE_ON_DEBUG (std::string _dataFormatConstructor)

Protected Attributes
void *	_Buffer
	All data formats need to have _Buffer and a Data structure. _Buffer will be common. More...

std::vector< uint32_t >	_InternalBuffer

bool	_shouldBufferBeInternal
	Auxillary variable that holds whether the buffer should be external or internal. More...

version_t	_version
	DataFormat Version. More...

Private Member Functions
void	defaultConstructorGeneral (resetBufferSource_t)

void	defaultConstructorGeneral (init_t, resetBufferSource_t)

Friends
class	novadaq::datalogger::DataBlockReader

Detailed Description

Definition at line 84 of file RawDAQData.h.

Constructor & Destructor Documentation

daqdataformats::RawDAQData::RawDAQData ( )

protected

Default Constructor.

Definition at line 14 of file RawDAQData.cpp.

Referenced by RawDAQData().

                       :
      _Buffer                  (NULL)
     ,_shouldBufferBeInternal  (false)
     ,_version(rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
     ,_function_init           (&RawDAQData::init)
     ,_function_sizeofdata     (NULL)
     ,_function_print          (&RawDAQData::printUnknownVersion)
     ,_function_readData       (&RawDAQData::readDataUnknownVersion)
     ,_function_setBufferSource(&RawDAQData::setBufferSource)
 { }

daqdataformats::RawDAQData::RawDAQData ( version_t version )

protected

Definition at line 26 of file RawDAQData.cpp.

                                              :
      _Buffer                  (NULL)
     ,_shouldBufferBeInternal  (false)
     ,_version                 (version)
     ,_function_init           (&RawDAQData::init)
     ,_function_sizeofdata     (NULL)
     ,_function_print          (&RawDAQData::printUnknownVersion)
     ,_function_readData       (&RawDAQData::readDataUnknownVersion)
     ,_function_setBufferSource(&RawDAQData::setBufferSource)
 { }

daqdataformats::RawDAQData::RawDAQData	(	version_t	,
		sizeofdata_t
	)

protected

daqdataformats::RawDAQData::RawDAQData	(	version_t	version,
		bool	use_setBufferSourceUnknownVersion
	)

protected

Definition at line 37 of file RawDAQData.cpp.

References _Buffer, _shouldBufferBeInternal, _version, daqdataformats::rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION, init(), init_t, Init_t(), gammaraytel::pr, print_t, Print_t(), printUnknownVersion(), RawDAQData(), readData_t, ReadData_t(), readDataGeneral(), readDataUnknownVersion(), setBufferSource(), setBufferSource_t, SetBufferSource_t(), setBufferSourceUnknownVersion(), sizeofdata_t, and Sizeofdata_t().

                                                     :
      _Buffer                  (NULL)
     ,_shouldBufferBeInternal  (false)
     ,_version                 (version)
     ,_function_init           (&RawDAQData::init)
     ,_function_sizeofdata     (NULL)
     ,_function_print          (&RawDAQData::printUnknownVersion)
     ,_function_readData       (&RawDAQData::readDataUnknownVersion)
     ,_function_setBufferSource(&RawDAQData::setBufferSourceUnknownVersion)
 { }

daqdataformats::RawDAQData::RawDAQData	(	version_t	,
		bool	use_setBufferSourceUnknownVersion,
		sizeofdata_t
	)

protected

daqdataformats::RawDAQData::RawDAQData ( init_t )

protected

daqdataformats::RawDAQData::RawDAQData	(	version_t	,
		init_t
	)

protected

daqdataformats::RawDAQData::RawDAQData	(	version_t	,
		init_t	,
		sizeofdata_t
	)

protected

daqdataformats::RawDAQData::RawDAQData	(	version_t	,
		init_t	,
		sizeofdata_t	,
		setBufferSource_t
	)

protected

daqdataformats::RawDAQData::RawDAQData	(	version_t	,
		init_t	,
		sizeofdata_t	,
		setBufferSource_t	,
		print_t	,
		readData_t
	)

protected

daqdataformats::RawDAQData::RawDAQData ( const RawDAQData & copy_in )

protected

Deep copy.

Definition at line 139 of file RawDAQData.cpp.

                                                 :
      _Buffer                  (NULL)
     ,_InternalBuffer          (copy_in._InternalBuffer)
     ,_shouldBufferBeInternal  (copy_in._shouldBufferBeInternal)
     ,_version                 (copy_in._version)
     ,_function_init           (copy_in._function_init)
     ,_function_sizeofdata     (copy_in._function_sizeofdata)
     ,_function_print          (copy_in._function_print)
     ,_function_readData       (copy_in._function_readData)
     ,_function_setBufferSource(copy_in._function_setBufferSource)
 { }

daqdataformats::RawDAQData::~RawDAQData ( )

virtual

Definition at line 169 of file RawDAQData.cpp.

169 { }

Member Function Documentation

bool daqdataformats::RawDAQData::addCheckSum ( )

virtual

Add the CRC into the end of fBuffer. CRC of all but the last words of the _Buffer.

Calculate CRC for the buffer, skipping the last word

Do the swab

Write the CRC at the last word of the Buffer

Definition at line 550 of file RawDAQData.cpp.

References _InternalBuffer, calculateCheckSum(), EXECUTE_FUNCTION, isInternalBuffer(), RAWBUFF32, sizeofdata(), and SWAB32.

Referenced by daqdataformats::RawMilliSlice::close().

                              {
 
     /// Calculate CRC for the buffer, skipping the last word
     uint32_t crc = calculateCheckSum(1);
 
     /// Do the swab
     crc = SWAB32(crc);
 
     const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();
 
     if(isInternalBuffer() && _InternalBuffer.size() < size_of_data){
             _InternalBuffer.push_back(crc);
     }
     else {
             /// Write the CRC at the last word of the Buffer
             RAWBUFF32[size_of_data - 1] = crc;
     }
 
     return true;
 }// end of RawDAQData::addCheckSum()

bool daqdataformats::RawDAQData::addToInternalBuffer ( const uint32_t size_of_data_to_add )

protected

Add Zeros to internal buffer.

Definition at line 284 of file RawDAQData.cpp.

References _InternalBuffer, and MECModelEnuComparisons::i.

Referenced by daqdataformats::RawMilliSliceIndex::addIndex().

                                                                {
     for(uint32_t i = 0; i < size_of_data; ++i)
         _InternalBuffer.push_back(0);
 
     return true;
 }

uint32_t daqdataformats::RawDAQData::boolToUint32_t ( const bool number ) const

inlineprotected

Conversions from bool to int and backwards We are not going to overload it, so no need to declare virtual

Definition at line 190 of file RawDAQData.h.

190 { return ((number) ? 1 : 0); }

uint32_t daqdataformats::RawDAQData::calculateCheckSum ( const uint32_t skip_last_words ) const

Calculate CRC of _Buffer (after skipping last skip_last_words words) using CRC32c algorythm with 0x8F6E37A0 polynomial. Usually use skip_last_words=1 as the _Buffer has an CRC in the end If on calculates with skip_last_words=0 (with CRC at the end), it should calculate to Zero (Property of Check Sum)

Definition at line 541 of file RawDAQData.cpp.

References _Buffer, EXECUTE_FUNCTION, daqdataformats::NOvACheckSum::getInstance(), daqdataformats::NOvACheckSum::processCRC(), and sizeofdata().

Referenced by addCheckSum(), RawMilliSliceTests::testCalculateCheckSum(), RawMilliSliceTests::testCalculateCheckSumCorrupt(), and daqdataformats::MilliSliceUnitTest::testMilliSliceCRC().

                                                                            {
 
     NOvACheckSum* CheckSum = NOvACheckSum::getInstance();
 
     return CheckSum->processCRC(_Buffer, EXECUTE_FUNCTION(sizeofdata)() - skip_last_words);
 }// end of calculateCheckSum

bool daqdataformats::RawDAQData::checkBufferInternalness ( )

protected

If the buffer should be internal, check it's pointers and reassign them.

Definition at line 612 of file RawDAQData.cpp.

References _shouldBufferBeInternal, isInternalBuffer(), and resetBufferSource().

Referenced by daqdataformats::RawMilliSlice::addData(), daqdataformats::RawMicroSlice::addData(), daqdataformats::RawMilliSliceIndex::addIndex(), daqdataformats::RawMilliSliceIndex::close(), daqdataformats::RawMilliSlice::close(), daqdataformats::RawMilliSliceIndex::readData(), daqdataformats::RawMilliSlice::readDataFromBuffer(), and daqdataformats::RawMicroSlice::readDataFromBuffer().

                                         {
 
     if(_shouldBufferBeInternal && !isInternalBuffer())
         return resetBufferSource();
 
     return true;
 }

bool daqdataformats::RawDAQData::clear ( )

virtual

reset _Buffer to point to InternalBuffer

Clear Internal Buffer

If buffer is internal, need to use assign, because vector may not have been initialized

Loop over the buffer and zero it The buffer could be either internal or external

Reimplemented in daqdataformats::RawMilliSlice.

Definition at line 573 of file RawDAQData.cpp.

References _InternalBuffer, EXECUTE_FUNCTION, MECModelEnuComparisons::i, isInternalBuffer(), PRINT_ON_DEBUG, RAWBUFF32, and sizeofdata().

Referenced by daqdataformats::RawMilliSlice::clear(), daqdataformats::RawMilliSliceHeader::init(), reset(), and daqdataformats::VERSION_NAMESPACE::RawDataBlock::~RawDataBlock().

                       {
 
   PRINT_ON_DEBUG(__PRETTY_FUNCTION__);
 
         const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();
 
         /// If buffer is internal, need to use assign, because vector may not have been initialized
         if(isInternalBuffer()){
             _InternalBuffer.assign(size_of_data, 0);
         }
         else{
             /// Loop over the buffer and zero it
             /// The buffer could be either internal or external
             for(uint32_t i = 0; i < size_of_data; ++i)
                 RAWBUFF32[i] = 0;
         }
 
   PRINT_ON_DEBUG("end of"<<__PRETTY_FUNCTION__);
 
         return true;
 } // end of clear

void daqdataformats::RawDAQData::copy ( const RawDAQData & copy_in )

virtual

Deep copy from the DAQDataFormat.

Get version

Copy the entire internal buffer

Set function pointers

Definition at line 830 of file RawDAQData.cpp.

References _InternalBuffer, _version, lastOperationsInDeepCopy(), and setFunctionPointers().

Referenced by daqdataformats::RawDCMChan::RawDCMChan(), daqdataformats::RawMicroSlice::RawMicroSlice(), daqdataformats::RawMilliSlice::RawMilliSlice(), daqdataformats::RawMilliSliceHeader::RawMilliSliceHeader(), daqdataformats::RawMilliSliceIndex::RawMilliSliceIndex(), daqdataformats::RawMilliSliceIndexHeader::RawMilliSliceIndexHeader(), and daqdataformats::RawTimingMarker::RawTimingMarker().

                                               {
 
     /// Get version
     _version        = copy_in._version;
 
     /// Copy the entire internal buffer
     _InternalBuffer = copy_in._InternalBuffer;
 
     /// Set function pointers
     setFunctionPointers();
 
     lastOperationsInDeepCopy(copy_in);
 }// end of copy(const RawDAQData& copy_in)

void daqdataformats::RawDAQData::copy ( const void * buffer )

virtual

Shallow copy from the external buffer.

If input version is -1, then we don't really know what version it is and will try to read it

figure out the version

At this point version should be known

Now, need to define functions

Also, we don't initialize internal buffer, because the pointer is set to the external buffer

Definition at line 846 of file RawDAQData.cpp.

References _Buffer, _version, om::cout, EXECUTE_FUNCTION, EXECUTE_ON_DEBUG(), figureOutTheVersion(), isVersionUnknown(), PRINT_ON_DEBUG, setBufferSource(), and setFunctionPointers().

                                                 {
     /// If input version is -1, then we don't really know what version it is and will try to read it
     if(isVersionUnknown()){
       PRINT_ON_DEBUG(__PRETTY_FUNCTION__ <<"version unknown");
         /// figure out the version
         _version = figureOutTheVersion(external_buffer);
     }
 
     /// At this point version should be known
     PRINT_ON_DEBUG(__PRETTY_FUNCTION__ <<"Picked up version "<<_version);
     /// Now, need to define functions
     setFunctionPointers();
 
     PRINT_ON_DEBUG(__PRETTY_FUNCTION__ << "  32 (about to do setBufferSource)");
     EXECUTE_ON_DEBUG(if(!_function_setBufferSource)std::cout<<"sbf is not binded\n");
     // Now set the pointer to the external buffer
     EXECUTE_FUNCTION(setBufferSource)(external_buffer);
     //setBufferSource(external_buffer);
     PRINT_ON_DEBUG(__PRETTY_FUNCTION__ << "  4");
 
     EXECUTE_ON_DEBUG(if(_Buffer != external_buffer)
                         std::cout<<"Something is wrong in RawDAQData::copy";
                      else
                         std::cout<<"From RawDAQData::copy Buffer is set to "<<_Buffer<<"\n"
                     );
 
     // Don't need to initialize any other fields,
     // because supposedly they should have been initialized before (by somebody else)
 
     /// Also, we don't initialize internal buffer, because the pointer is set to the external buffer
 
 }// end of copy(const void* external_buffer)

void daqdataformats::RawDAQData::defaultConstructorFixedSize ( )

protected

General routines for the default constructor of main class for fixed size data formats, like RawNanoSliceHeader, Timing marker etc. (they can be different from version to version though) But the difference is that we want to clear out the internal buffer for them, whereas for floating data formats don't need to have that, since the data may be overwritten anyways

Definition at line 625 of file RawDAQData.cpp.

References defaultConstructorGeneral(), Init_t(), reset(), and resetBufferSource_t.

Referenced by daqdataformats::RawDCMChan::RawDCMChan(), daqdataformats::RawMilliSliceHeader::RawMilliSliceHeader(), daqdataformats::RawMilliSliceIndexHeader::RawMilliSliceIndexHeader(), and daqdataformats::RawTimingMarker::RawTimingMarker().

                                             {
     defaultConstructorGeneral((resetBufferSource_t)&RawDAQData::reset);
 }// end of defaultConstructorFixedSize(version_t)

void daqdataformats::RawDAQData::defaultConstructorFixedSize ( init_t )

protected

void daqdataformats::RawDAQData::defaultConstructorFloatingSize ( )

protected

General routines for the default constructor of main class for floating size data formats, like RawNanoSlice, RawEvent etc. We don't need to initialize internal buffer

Definition at line 642 of file RawDAQData.cpp.

References _Buffer, _InternalBuffer, _version, om::cout, defaultConstructorGeneral(), EXECUTE_FUNCTION, EXECUTE_GENERAL_FUNCTION, EXECUTE_ON_DEBUG(), init(), Init_t(), isVersionUnknown(), PRINT_ON_DEBUG, resetBufferSource(), ResetBufferSource_t, resetBufferSource_t, resizeInternalBuffer(), setFunctionPointers(), gen_hdf5record::size, and sizeofdata().

Referenced by daqdataformats::RawMicroSlice::RawMicroSlice(), daqdataformats::RawMilliSlice::RawMilliSlice(), and daqdataformats::RawMilliSliceIndex::RawMilliSliceIndex().

                                                {
     defaultConstructorGeneral((resetBufferSource_t)&RawDAQData::resetBufferSource);
 }// end of defaultConstructorFloatingSize(version_t)

void daqdataformats::RawDAQData::defaultConstructorFloatingSize ( init_t )

protected

void daqdataformats::RawDAQData::defaultConstructorGeneral ( resetBufferSource_t )

private

Default constructor methods with custom reset_buffer_source method so that one can use resetBufferSource or clear

Referenced by defaultConstructorFixedSize(), and defaultConstructorFloatingSize().

void daqdataformats::RawDAQData::defaultConstructorGeneral	(	init_t	,
		resetBufferSource_t
	)

private

daqdataformats::RawDAQData::EXECUTE_ON_DEBUG ( std::string _dataFormatClassName )

protected

These variables are only for Debugging purposes.

Referenced by copy(), defaultConstructorFloatingSize(), readDataGeneral(), and reset().

daqdataformats::RawDAQData::EXECUTE_ON_DEBUG ( std::string _dataFormatConstructor )

protected

virtual version_t daqdataformats::RawDAQData::figureOutTheVersion ( const void * buffer ) const

protectedpure virtual

Method which returns the version of the DataFormat given the pointer to the buffer It has to be implemented for all DataFormats.

Implemented in daqdataformats::RawMilliSliceHeader, daqdataformats::RawMicroSlice, daqdataformats::RawMilliSlice, daqdataformats::RawTimingMarker, daqdataformats::RawMilliSliceIndex, daqdataformats::RawDCMChan, and daqdataformats::RawMilliSliceIndexHeader.

Referenced by copy(), readDataUnknownVersion(), and setBufferSourceUnknownVersion().

bool daqdataformats::RawDAQData::functionIsNotAllowed	(	const std::string	function = `""`,
		const std::string	message = `""`
	)		const

protected

One can call this function from another function, which usage is not allowed (for a particular version).

The output message string

Generate the exception

Definition at line 962 of file RawDAQData.cpp.

References _version, gen_hdf5record::size, and string.

                                                                                              {
 
     /// The output message string
     std::string output_message;
 
     if(function.size() > 0){
         output_message = "\nFunction " + function + " ";
     }
     else{
         output_message = "Operation ";
     }
 
     output_message.append(" is Not allowed");
     output_message.append(" for version " + boost::lexical_cast<std::string>(_version));
     output_message.append(".");
 
     if(message.size() > 0)
         output_message += " " + message;
 
     /// Generate the exception
     throw daqdataformats::DataFormatException((const std::string)output_message);
 
     return false;
 }

std::string daqdataformats::RawDAQData::generateExceptionForWrongVersion ( version_t maximum_version ) const

protected

Generating exception message as the version of DAQDataFormat is greater than the maximum allowed.

Definition at line 950 of file RawDAQData.cpp.

References _version, lem_server::msg, and string.

                                                                                             {
 
     std::string msg =  "The version of the DataFormat is too high! ";
                 msg += "The version is " + boost::lexical_cast<std::string>(_version)
                     +  ". Whereas the maximum version allowed is " + boost::lexical_cast<std::string>(maximum_version);
 
     return msg;
 }// end of generateExceptionForWrongVersion

void* daqdataformats::RawDAQData::getBuffer ( ) const

inline

Get method for the pointer to the internal buffers We are not going to overload it, so no need to declare virtual

Definition at line 131 of file RawDAQData.h.

References clear.

Referenced by mcdatadaq::BufferNodeSimulator::addMilliSlice(), daqdataformats::MilliSliceUnitTest::basicFieldGetAndSetChecks(), daqdataformats::MicroBlockUnitTest::basicFieldGetAndSetChecksForGivenVersion(), daqdataformats::RawMilliSliceIndex::close(), daqdataformats::RawMilliSlice::close(), daqdataformats::MilliSliceConstructor::fillDataFormat(), daqdataformats::CURRENT_FIELDS_SUB_NAMESPACE::MicroBlockConstructor::fillDataFormat(), daqdataformats::DataBlockConstructor::fillDataFormat(), daqdataformats::CURRENT_FIELDS_SUB_NAMESPACE::MicroBlockConstructor::getEmptyDataFormat(), daqdataformats::RawMilliSlice::setFloatingMicroSlice(), RawMilliSliceTests::testCalculateCheckSumCorrupt(), and mcdatadaq::Configuration::writeToFile().

131 { return _Buffer; }; /* This is evil. You shouldn't expose the buffer point. However, we allow it. */

daqdataformats::RawDAQData::_Buffer

void * _Buffer

All data formats need to have _Buffer and a Data structure. _Buffer will be common.

Definition: RawDAQData.h:276

bool daqdataformats::RawDAQData::getLoAndHi	(	uint64_t	input_data,
		uint32_t &	output_low_word,
		uint32_t &	output_hi_word
	)		const

protected

Definition at line 910 of file RawDAQData.cpp.

Referenced by daqdataformats::RawTimingMarker::setTime(), daqdataformats::RawMilliSliceHeader::setTimeStart(), and setUint64_t().

                                                                                                               {
      out_low_word = input_data & 0xffffffff;
      out_hi_word  = input_data >> 32;
      return true;
 }// end of getLoAndHi

uint64_t daqdataformats::RawDAQData::getUint64_t	(	uint32_t	low_word,
		uint32_t	hi_word
	)		const

protected

Get uint64_t from low and hi word.

Definition at line 908 of file RawDAQData.cpp.

Referenced by daqdataformats::RawTimingMarker::getTime(), and daqdataformats::RawMilliSliceHeader::getTimeStart().

908 { return (uint64_t) high<<32 | low;}

void daqdataformats::RawDAQData::init ( )

inline

Functions that need to be defined in each class Initialize DAQDataFormats class

Definition at line 145 of file RawDAQData.h.

References om::cout, print, and string.

Referenced by demo.App::__init__(), testem0.App::__init__(), Lesson1.App::__init__(), ExN03.App::__init__(), defaultConstructorFloatingSize(), daqdataformats::RawMilliSliceIndex::init(), daqdataformats::RawMicroSlice::init(), and RawDAQData().

145 {};

daqdataformats::RawDAQData::Init_t ( _function_init )

protected

Some common function pointers used in each DAQDataFormats class.

Referenced by defaultConstructorFixedSize(), defaultConstructorFloatingSize(), and RawDAQData().

bool daqdataformats::RawDAQData::isInternalBuffer ( ) const

inline

Is buffer internal We are not going to overload it, so no need to declare virtual

Definition at line 141 of file RawDAQData.h.

Referenced by addCheckSum(), checkBufferInternalness(), clear(), daqdataformats::RawMilliSlice::close(), daqdataformats::RawMilliSlice::init(), lastOperationsInDeepCopy(), printBuffer(), daqdataformats::RawMilliSlice::readData(), readDataGeneral(), readDataUnknownVersion(), daqdataformats::RawMilliSlice::setBufferSource(), daqdataformats::RawMilliSliceIndex::setBufferSource(), and daqdataformats::RawMicroSlice::setBufferSource().

141 { return (_Buffer == (void*)(&_InternalBuffer[0])); }

daqdataformats::RawDAQData::_Buffer

void * _Buffer

All data formats need to have _Buffer and a Data structure. _Buffer will be common.

Definition: RawDAQData.h:276

daqdataformats::RawDAQData::_InternalBuffer

std::vector< uint32_t > _InternalBuffer

Definition: RawDAQData.h:283

bool daqdataformats::RawDAQData::isVersionUnknown ( ) const

inlineprotected

is current _version unknown?

Definition at line 240 of file RawDAQData.h.

References samweb_client.client::_version, and isVersionUnknown().

Referenced by copy(), defaultConstructorFloatingSize(), and isVersionUnknown().

240 { return isVersionUnknown(_version);}

daqdataformats::RawDAQData::_version

version_t _version

DataFormat Version.

Definition: RawDAQData.h:289

daqdataformats::RawDAQData::isVersionUnknown

bool isVersionUnknown() const

is current _version unknown?

Definition: RawDAQData.h:240

bool daqdataformats::RawDAQData::isVersionUnknown ( const version_t version ) const

inlineprotected

is input version unknown?

Definition at line 242 of file RawDAQData.h.

References daqdataformats::rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION, DELEGATE, init_t, resetBufferSource_t, and string.

242 { return (version == rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION);}

version

const XML_Char * version

Definition: expat.h:187

daqdataformats::rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION

static const version_t DAQDATAFORMAT_UNKNOWN_VERSION

Definition: RawDAQData.h:81

void daqdataformats::RawDAQData::lastOperationsInDeepCopy ( const RawDAQData & copy_in )

protected

Need to perform these operations in Deep Copy constructor.

If buffer is null, nothing to do

Definition at line 151 of file RawDAQData.cpp.

References _Buffer, EXECUTE_FUNCTION, isInternalBuffer(), PRINT_ON_DEBUG, resetBufferSource(), and setBufferSource().

Referenced by copy(), daqdataformats::RawDCMChan::RawDCMChan(), daqdataformats::RawMicroSlice::RawMicroSlice(), daqdataformats::RawMilliSlice::RawMilliSlice(), daqdataformats::RawMilliSliceHeader::RawMilliSliceHeader(), daqdataformats::RawMilliSliceIndex::RawMilliSliceIndex(), daqdataformats::RawMilliSliceIndexHeader::RawMilliSliceIndexHeader(), and daqdataformats::RawTimingMarker::RawTimingMarker().

                                                                   {
 
     /// If buffer is null, nothing to do
     if(copy_in._Buffer == NULL) return;
     
     // Setup the main buffer pointer
     // If the copy_in's buffer is external, point to that external memory
     if(copy_in.isInternalBuffer()) {
         resetBufferSource();
     }
     else{
       PRINT_ON_DEBUG("From RawDAQData::copy. Buffer is External. Using setBufferSource.");
         EXECUTE_FUNCTION(setBufferSource)(copy_in._Buffer);
     }
 }

void daqdataformats::RawDAQData::print ( std::ostream & os = std::cout ) const

Method for printing the content of the Buffer.

Definition at line 500 of file RawDAQData.cpp.

References RETURN_FUNCTION.

Referenced by daqdataformats::RawDAQDataUnitTest::compareDataFormats(), daqdataformats::RawDAQDataUnitTest::getDifferenceBetweenStrings(), daqdataformats::RawDAQDataUnitTest::isPrintDataFormatUnknownVersion(), daqdataformats::operator<<(), daqdataformats::VERSION_NAMESPACE::RawMicroBlock::print(), daqdataformats::RawMilliSliceIndex::print(), print(), daqdataformats::RawMilliSlice::printStandard(), and daqdataformats::RawMicroSlice::printStandard().

500 {RETURN_FUNCTION(print)(os);}

RETURN_FUNCTION

#define RETURN_FUNCTION(FULLFUNCTIONNAME)

Definition: Macros.h:57

daqdataformats::RawDAQData::print

void print(std::ostream &os=std::cout) const

Method for printing the content of the Buffer.

Definition: RawDAQData.cpp:500

void daqdataformats::RawDAQData::print ( std::string & output_string ) const

print into the string

Some temporary stream

perform standard print into the stream

Get the string out of the stream

Definition at line 503 of file RawDAQData.cpp.

References EXECUTE_FUNCTION, print(), and submit_syst::str.

                                                     {
 
     /// Some temporary stream
     std::ostringstream str;
     /// perform standard print into the stream
     EXECUTE_FUNCTION(print)(str);
     /// Get the string out of the stream
     output_string = str.str();
 
 }

daqdataformats::RawDAQData::Print_t ( _function_print )

protected

Referenced by RawDAQData().

void daqdataformats::RawDAQData::printBinary	(	const void *	buffer0,
		const uint32_t	size,
		std::ostream &	os = `std::cout`
	)		const

protected

Definition at line 478 of file RawDAQData.cpp.

References printWordBinary(), and gen_hdf5record::size.

                                                                                                    {
 
     const uint32_t* buffer = (uint32_t*)buffer0;
     for(uint32_t iword = 0; iword < size; ++iword){
 //        out_stream<<"Address "<<&buffer[iword]<<"   ";
         printWordBinary(buffer[iword], out_stream);
     }// end of loop over buffer
 }

void daqdataformats::RawDAQData::printBuffer	(	std::ostream &	os = `std::cout`,
		const bool	print_offset = `true`,
		const bool	print_ascii = `true`,
		const bool	print_buffer_address = `false`,
		const bool	print_internal_buffer = `false`,
		const bool	print_size_of_data = `false`,
		const std::string	separation_between_lines = `"\n"`,
		const uint32_t	cols = `4`
	)		const

protected

Displays the data _Buffer Customazible for debugging purpose

If we havn't printed buffer address, need to print Internal Buffer address

Print whether the buffer is internal/external

print size

Size of data

Current pointer to a word

This is only for ascii buffer printing

Loop over buffer

Write the data word in hex

At the end of the line write the line in ASCII with suppression of non printing characters

printing the ascii for the word

Loop over 4 characters of the line

print the character

At the end of the line, put separation symbol

Definition at line 330 of file RawDAQData.cpp.

References _Buffer, _InternalBuffer, cols, allTimeWatchdog::endl, EXECUTE_FUNCTION, novadaq::HexUtils::format(), MECModelEnuComparisons::i, isInternalBuffer(), calib::j, and sizeofdata().

Referenced by daqdataformats::RawMicroSlice::printStandard().

                                     {
 
   // print Buffer address
   if(print_buffer_address){
 
       uint32_t* buf = (uint32_t*)_Buffer;
       out_stream<<"Buffer address is "<<buf<<std::endl;
   }
 
   // print internal buffer info
   if(print_internal_buffer){
       if(_InternalBuffer.size() > 0){
             /// If we havn't printed buffer address, need to print Internal Buffer address
             if(!print_buffer_address || !isInternalBuffer())
                 out_stream<<"Internal Buffer address "<<&_InternalBuffer[0]<<". ";
 
             /// Print whether the buffer is internal/external
             if(isInternalBuffer())
                 out_stream<<"Using Internal Buffer.";
             else
                 out_stream<<"Using External Buffer.";
 
             /// print size
             out_stream<<" The size of the internal buffer is "<<_InternalBuffer.size()<<std::endl;
       }
       else{
             out_stream<<"Internal Buffer size is ZERO"<<std::endl;
       }// end of checking if the size of internal buffer is nonzero
 
   }// end of printing internal buffer info
 
   /// Size of data
   const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();
 
   if(print_size_of_data)
     out_stream<<"Size of data = "<<size_of_data<<std::endl;
 
   /// Current pointer to a word
   uint32_t* data_buffer       = (uint32_t*)_Buffer;
 
   /// This is only for ascii buffer printing
   char* ascii_buffer          = (char*)_Buffer;
 
   /// Loop over buffer
   for(uint32_t i = 0; i < size_of_data; ++i){
 
     // At the start of the line write the address offset
     if((print_offset && !(i % cols))){
       out_stream<<boost::format("[Offset=%08x bytes] \t")%(uint32_t)((data_buffer-(uint32_t*)_Buffer)*sizeof(uint32_t));
     }
 
     /// Write the data word in hex
     out_stream<<boost::format("0x%08x\t")%*data_buffer;
 
     /// At the end of the line write the line in ASCII with suppression of
     /// non printing characters
     if((i + 1) % cols == 0 || i == size_of_data-1){
 
       /// printing the ascii for the word
       if(print_ascii){
 
         uint32_t nsymbols = cols;
 
         if(i == size_of_data-1){
             nsymbols = size_of_data % cols;
             if(nsymbols == 0)
                 nsymbols = cols;
         }
 
         if(size_of_data / cols){
             for(uint32_t itab = 0; itab < cols - nsymbols; ++itab)
                 out_stream<<"                ";
         }
         
         out_stream<<"(ASCII=";
 
         /// Loop over 4 characters of the line
         for(uint32_t j = 0; j < sizeof(uint32_t) * nsymbols; ++j){
             
             /// print the character
             if( (*ascii_buffer < 32) || (*ascii_buffer > 126)){
                 out_stream<<".";
             }else{
                 out_stream<<boost::format("%c") % (*ascii_buffer);
             }// end of print the character
 
             ++ascii_buffer;
         }// end of loop over charachters
         
         out_stream<<")";
       }// end of printing ASCII
 
       /// At the end of the line, put separation symbol
       out_stream<<separation_between_lines;
     }// end of if the end of the line
 
     ++data_buffer;
   }// end of loop over buffer
 
 }// end of RawDAQData::printBuffer()

void daqdataformats::RawDAQData::printGeneral ( std::ostream & os = std::cout ) const

protected

Print methods Generic print

Definition at line 516 of file RawDAQData.cpp.

References allTimeWatchdog::endl, EXECUTE_FUNCTION, MECModelEnuComparisons::i, printWord(), and sizeofdata().

                                                              {
     
     const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();
 
     output_stream<<"----------General printing of a DAQDataFormat member-----------size="<<size_of_data<<std::endl;
     output_stream<<std::endl<<"nRAW:";
     for(uint32_t i = 0; i < size_of_data; ++i){
             output_stream<<" ";
             printWord(i, false, output_stream);
     }
 
     output_stream<<"\nRAW:";
     for(uint32_t i = 0; i < size_of_data; ++i){
             if(i > 0)output_stream<<"    ";
             printWord(i, true, output_stream);
             output_stream<<std::endl;
     }
 }// end of RawDAQData::printGeneral()

void daqdataformats::RawDAQData::printHex	(	const void *	buffer0,
		const uint32_t	size,
		std::ostream &	os = `std::cout`
	)		const

protected

Definition at line 488 of file RawDAQData.cpp.

References allTimeWatchdog::endl, printWordHex(), and gen_hdf5record::size.

                                                                                                    {
 
     const uint32_t* buffer = (uint32_t*)buffer0;
     for(uint32_t iword = 0; iword < size; ++iword){
 //        out_stream<<"Address "<<&buffer[iword]<<"   ";
         printWordHex(buffer[iword], out_stream);
         out_stream<<std::endl;
     }// end of loop over buffer
 }

void daqdataformats::RawDAQData::printUnknownVersion ( std::ostream & out_stream = std::cout ) const

inlineprotected

Definition at line 213 of file RawDAQData.h.

References allTimeWatchdog::endl, init_t, datagram_client::message, and string.

Referenced by RawDAQData().

213 { out_stream<<"DAQDataFormat is of unknown version"<<std::endl;}

allTimeWatchdog.endl

string endl

Definition: allTimeWatchdog.py:25

void daqdataformats::RawDAQData::printWord	(	const uint32_t	iword,
		const bool	is_bynary_printing,
		std::ostream &	os = `std::cout`
	)		const

protected

Print word from Buffer.

Check if we want to print in a bynary mode

Definition at line 440 of file RawDAQData.cpp.

References printWordBinary(), printWordHex(), RAWBUFF32, and SWAB32.

Referenced by daqdataformats::RawMilliSliceIndex::print(), daqdataformats::RawDCMChan::print(), printGeneral(), daqdataformats::RawTimingMarker::printStandard(), daqdataformats::RawMilliSlice::printStandard(), and daqdataformats::RawMilliSliceHeader::printStandard().

                                                                                                              {
 
     const uint32_t rawbuf = RAWBUFF32[iword];
     const uint32_t value  = SWAB32(rawbuf);
 
     /// Check if we want to print in a bynary mode
     if(is_bynary_printing){
         printWordBinary(value, out_stream);
     } else {
         //Else print in hex mode
         printWordHex(value, out_stream);
     }// end of if(is_bynary_printing)
 
 }//end of void printWord

void daqdataformats::RawDAQData::printWordBinary	(	const uint32_t	word,
		std::ostream &	os = `std::cout`
	)		const

protected

! Print the i-th word of _Buffer, is_bynary_printing: true = bynary, false = HEX

Definition at line 456 of file RawDAQData.cpp.

References allTimeWatchdog::endl, and MECModelEnuComparisons::i.

Referenced by printBinary(), and printWord().

                                                                                    {
 
         uint32_t value_copy = value;
 
         const int      SHIFT = 8 * sizeof( unsigned ) - 1;
         const unsigned MASK  = 1 << SHIFT;
 
         for ( int i = 1; i <= SHIFT + 1; i++ ){
                 out_stream << (  value_copy & MASK ? '1' : '0' );
                 value_copy <<= 1;
 
                 if ( i % 8 == 0 ) out_stream << ' ';
                 }
         out_stream<<std::endl;
 }

void daqdataformats::RawDAQData::printWordHex	(	const uint32_t	word,
		std::ostream &	os = `std::cout`
	)		const

protected

Definition at line 473 of file RawDAQData.cpp.

References novadaq::HexUtils::format().

Referenced by printHex(), and printWord().

                                                                                   {
         out_stream<<boost::format("0x%08x")% value;
 }

void * daqdataformats::RawDAQData::readData ( const void * buffer )

Shallow copy constructor.

Definition at line 181 of file RawDAQData.cpp.

References RETURN_FUNCTION.

                                             {
     RETURN_FUNCTION(readData)(buffer);
 }

void* daqdataformats::RawDAQData::readData	(	const void *	buffer,
		const uint32_t	size_of_data
	)

inline

Read from the buffer if the size of data is known.

Definition at line 114 of file RawDAQData.h.

References fd.

Referenced by PandAna.core.core.loader::Go().

114 {return readDataGeneral(buffer, size_of_data);}

daqdataformats::RawDAQData::readDataGeneral

void * readDataGeneral(const void *buffer)

General ReadData method when the sizeofdata is known.

Definition: RawDAQData.cpp:186

xml_schema::buffer

::xsd::cxx::tree::buffer< char > buffer

Definition: Database.h:179

readDataStatus daqdataformats::RawDAQData::readData ( const int fd )

virtual

From the File descriptor.

Reimplemented in daqdataformats::RawMicroSlice, and daqdataformats::RawMilliSlice.

Definition at line 255 of file RawDAQData.cpp.

References _Buffer, EXECUTE_FUNCTION, daqdataformats::rds_complete, daqdataformats::rds_error, daqdataformats::rds_incomplete, sizeofdata(), and ss.

Referenced by PandAna.core.core.loader::Go().

                                                {
 
   if(fd < 0)                                         return rds_error;
 
   const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();
 
   const ssize_t  ss = read(fd, _Buffer, (size_t)size_of_data*sizeof(uint32_t));
 
   if (ss == -1 || ss == 0)                           return rds_error;
 
   if ((uint32_t)ss == size_of_data*sizeof(uint32_t)) return rds_complete;
   else                                               return rds_incomplete;
 }

daqdataformats::RawDAQData::ReadData_t ( _function_readData )

protected

Referenced by RawDAQData().

void * daqdataformats::RawDAQData::readDataGeneral ( const void * buffer )

protected

General ReadData method when the sizeofdata is known.

Definition at line 186 of file RawDAQData.cpp.

References EXECUTE_FUNCTION, and sizeofdata().

                                                    {
     return readDataGeneral(buffer, EXECUTE_FUNCTION(sizeofdata)(), 0);
 }

void * daqdataformats::RawDAQData::readDataGeneral	(	const void *	buffer,
		const uint32_t	size_of_data_to_read
	)

protected

Generic readData methods.

Adding stuff to buffer.

Definition at line 191 of file RawDAQData.cpp.

References _InternalBuffer, EXECUTE_FUNCTION, PRINT_ON_DEBUG, readDataGeneral(), and sizeofdata().

                                                                                              {
 
   PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<"size of data "<<sizeofdata());
   PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<_InternalBuffer.size());
     
     return readDataGeneral(buffer_void, size_of_data_to_read, EXECUTE_FUNCTION(sizeofdata)());
 }

void * daqdataformats::RawDAQData::readDataGeneral	(	const void *	buffer,
		const uint32_t	size_of_data_to_read,
		const uint32_t	buffer_start_position
	)

protected

If it's negative, then nothing to assign

At first, we are going to be assigning things

Push back the rest

Since, it's the external buffer, then we are going to assign

Definition at line 200 of file RawDAQData.cpp.

References _InternalBuffer, om::cout, EXECUTE_ON_DEBUG(), exit(), MECModelEnuComparisons::i, isInternalBuffer(), std::min(), PRINT_ON_DEBUG, and RAWBUFF32.

                                                                                                                                    {
 
   PRINT_ON_DEBUG(__PRETTY_FUNCTION__);
 
   const uint32_t* buffer = (const uint32_t*)buffer_void;
 
   if(buffer == 0){return 0;}
 
 
   if(isInternalBuffer()){
                     {
       PRINT_ON_DEBUG  ("Internal buffer");
                     }
 
         int32_t words_to_assign = int32_t(_InternalBuffer.size()) - int32_t(buffer_start_position);
                     {
       PRINT_ON_DEBUG  ("Size="<<_InternalBuffer.size()<<"   buffer_start_pos="<<buffer_start_position<<" size_of_data_to_read="<<size_of_data_to_read);
       PRINT_ON_DEBUG  ("Words to assign1="<<words_to_assign);
       EXECUTE_ON_DEBUG(if(words_to_assign < 0) {std::cout<<"FROM "<<__PRETTY_FUNCTION__<<"words_to_assign is negative("<<words_to_assign<<"). SOMETHING MUST BE WRONG\n";exit(1);});
                     }
         /// If it's negative, then nothing to assign
         if(words_to_assign > 0)
             words_to_assign = std::min(int32_t(size_of_data_to_read), words_to_assign);
         else
             words_to_assign = 0;
 
                     {
       PRINT_ON_DEBUG  ("Words to assign2="<<words_to_assign);
                     }
         uint32_t i = 0;
         ///At first, we are going to be assigning things
         for(; i < uint32_t(words_to_assign); ++i ){
             RAWBUFF32[buffer_start_position + i] = buffer[i];
         }
 
         /// Push back the rest
         for(; i < size_of_data_to_read; ++i ){
             _InternalBuffer.push_back(buffer[i]);;
         }
   }
   else {
         /// Since, it's the external buffer, then we are going to assign
         for(uint32_t i = 0; i < size_of_data_to_read; ++i ){
             RAWBUFF32[buffer_start_position + i] = buffer[i];
         }
 
   }// end if buffer is internal or external
 
   // Return the address of the buffer advanced by 1 word;
   return (void*)(buffer + size_of_data_to_read);
 }

void * daqdataformats::RawDAQData::readDataUnknownVersion ( const void * buffer )

protected

Read data from the unknown version.

Read data from the unknown version Reading data to the format with unknown version can only happen when the buffer is set to internal source, because if it was set to external source, then we already figured out the version from it and wouldn't call this method After reading the data, the DataFormat is fully initialized

get the version

Now that we know the version, initialize function pointers, including readData

Resize internal buffer

Reset buffer source, so that we can construct other things (like headers and such)

Don't need to initialize the fields (use init()) because we are going to read new values from the buffer anyways... Like now

Definition at line 805 of file RawDAQData.cpp.

References _version, EXECUTE_FUNCTION, figureOutTheVersion(), isInternalBuffer(), PRINT_ON_DEBUG, readData(), resetBufferSource(), resizeInternalBuffer(), RETURN_FUNCTION, setFunctionPointers(), and sizeofdata().

Referenced by RawDAQData().

                                                           {
 
     PRINT_ON_DEBUG(__PRETTY_FUNCTION__);
     /// get the version
     _version = figureOutTheVersion(buffer);
 
     /// Now that we know the version, initialize function pointers,
     /// including readData
     setFunctionPointers();
 
     /// Resize internal buffer
     if(isInternalBuffer()){
         resizeInternalBuffer(EXECUTE_FUNCTION(sizeofdata)());
 
         /// Reset buffer source, so that we can construct other things (like headers and such)
         resetBufferSource();
     }// end of if isInternalBuffer
 
     /// Don't need to initialize the fields (use init()) because we are going to read new values from the buffer anyways...
     /// Like now
     RETURN_FUNCTION(readData)(buffer);
 }// end of readDataUnknownVersion

bool daqdataformats::RawDAQData::reserveInternalBuffer ( const uint32_t size_of_data )

protected

Reserve space for the internal buffer to some predetermined size.

We use vector::reserve instead of vector::resize, because resize not only reserves things, it initializes them to zero value. We don't have to do that, because we may overwrite things.

Definition at line 271 of file RawDAQData.cpp.

References _InternalBuffer.

Referenced by daqdataformats::RawMicroSlice::RawMicroSlice(), daqdataformats::RawMilliSlice::RawMilliSlice(), and daqdataformats::RawMilliSliceIndex::RawMilliSliceIndex().

                                                                  {
 
     /// We use vector::reserve instead of vector::resize,
     /// because resize not only reserves things,
     /// it initializes them to zero value.
     /// We don't have to do that, because we may overwrite things.
     if(_InternalBuffer.capacity() < size_of_data)
         _InternalBuffer.reserve(size_of_data);
 
     return true;
 }

bool daqdataformats::RawDAQData::reset ( )

Reset.

Definition at line 596 of file RawDAQData.cpp.

References clear(), om::cout, EXECUTE_ON_DEBUG(), PRINT_ON_DEBUG, and resetBufferSource().

Referenced by defaultConstructorFixedSize().

                       {
   PRINT_ON_DEBUG(__PRETTY_FUNCTION__);
         resetBufferSource();
   EXECUTE_ON_DEBUG(clear(); std::cout<<"End of "<<__PRETTY_FUNCTION__<<"\n"; return true);
         return clear();
 }// end of reset

bool daqdataformats::RawDAQData::resetBufferSource ( )

Definition at line 605 of file RawDAQData.cpp.

References _InternalBuffer, PRINT_ON_DEBUG, RETURN_FUNCTION, and setBufferSource().

Referenced by checkBufferInternalness(), defaultConstructorFloatingSize(), lastOperationsInDeepCopy(), daqdataformats::RawMilliSlice::readData(), readDataUnknownVersion(), and reset().

                                    {
   PRINT_ON_DEBUG(__PRETTY_FUNCTION__);
 
     RETURN_FUNCTION(setBufferSource)(&_InternalBuffer[0]);
 } //  end of reset _Buffer to point to InternalBuffer

bool daqdataformats::RawDAQData::resizeInternalBuffer ( const uint32_t size_of_data )

protected

Resize the internal buffer.

Definition at line 292 of file RawDAQData.cpp.

References _InternalBuffer.

Referenced by defaultConstructorFloatingSize(), daqdataformats::RawMicroSlice::init(), daqdataformats::RawMicroSlice::RawMicroSlice(), daqdataformats::RawMicroSlice::readData(), and readDataUnknownVersion().

                                                                 {
 
     if(_InternalBuffer.size() < size_of_data)
         _InternalBuffer.resize(size_of_data);
 
     return true;
 }

bool daqdataformats::RawDAQData::setBufferSource ( const void * pointer )

We are not going to overload these funtions, so no need to declare them virtual.

Set The Buffer pointer to a given location.

Definition at line 880 of file RawDAQData.cpp.

References _Buffer, and PRINT_ON_DEBUG.

Referenced by copy(), lastOperationsInDeepCopy(), RawDAQData(), resetBufferSource(), daqdataformats::RawMilliSlice::setBufferSource(), daqdataformats::RawMilliSliceIndex::setBufferSource(), daqdataformats::VERSION_NAMESPACE::RawMicroBlockHeader::setBufferSource(), daqdataformats::RawMicroSlice::setBufferSource(), setBufferSourceGeneral(), and setBufferSourceUnknownVersion().

                                                    {
   PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Setting to "<<pointer);
         _Buffer = (void*)pointer;
         return true;
 }// end of setBufferSource

daqdataformats::RawDAQData::SetBufferSource_t ( _function_setBufferSource )

protected

Referenced by RawDAQData().

void * daqdataformats::RawDAQData::setBufferSourceGeneral	(	RawDAQData &	dataformat,
		const void *	pointer
	)

protected

Set BufferSource of the input DataFormat and return pointer to the position right after the end of its buffer.

Definition at line 888 of file RawDAQData.cpp.

References PRINT_ON_DEBUG, setBufferSource(), and sizeofdata().

                                                                                    {
     dataformat.setBufferSource(pointer);
     const uint32_t* next_block_pointer = ((uint32_t*)(pointer)) + dataformat.sizeofdata();
     PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" Size of data="<<dataformat.sizeofdata()<<". Next pointer will be"<<next_block_pointer);
     return (void*)next_block_pointer;
 }// end of setBufferSourceGeneral(RawDAQData& dataformat, const void* pointer)

bool daqdataformats::RawDAQData::setBufferSourceUnknownVersion ( const void * pointer )

protected

First, figure out version

Now, set Function pointers accordingly

Now, execute setBuffer Source

Definition at line 896 of file RawDAQData.cpp.

References _version, figureOutTheVersion(), RETURN_FUNCTION, setBufferSource(), and setFunctionPointers().

Referenced by RawDAQData().

                                                                   {
     /// First, figure out version
     _version = figureOutTheVersion(pointer);
 
     /// Now, set Function pointers accordingly
     setFunctionPointers();
 
     /// Now, execute setBuffer Source
     RETURN_FUNCTION(setBufferSource)(pointer);
 }// end of setBufferSourceUnknownVersion(const void* pointer)

virtual bool daqdataformats::RawDAQData::setFunctionPointers ( )

protectedpure virtual

Function where we set all function pointers. At this point we don't know it It is to be derived in the final user readable class

Implemented in daqdataformats::RawMilliSliceHeader, daqdataformats::RawMicroSlice, daqdataformats::RawMilliSlice, daqdataformats::RawMilliSliceIndex, daqdataformats::RawTimingMarker, daqdataformats::RawDCMChan, and daqdataformats::RawMilliSliceIndexHeader.

Referenced by copy(), defaultConstructorFloatingSize(), readDataUnknownVersion(), and setBufferSourceUnknownVersion().

bool daqdataformats::RawDAQData::setUint64_t	(	uint64_t	value,
		DELEGATE(RawDAQData, function_set_low_word, bool, uint32_t)
	)

protected

Definition at line 937 of file RawDAQData.cpp.

References DELEGATE, EXECUTE_GENERAL_FUNCTION, and getLoAndHi().

                                 {
       uint32_t low, high;
       getLoAndHi(value, low, high);
 
       EXECUTE_GENERAL_FUNCTION(function_set_low_word)(low);
       return EXECUTE_GENERAL_FUNCTION(function_set_hi_word)(high);
 }// end of setUint64_t

uint32_t daqdataformats::RawDAQData::sizeofdata ( ) const

Sizeof method for the current data block. Returns the size of the data block in 32bit words.

Definition at line 990 of file RawDAQData.cpp.

References RETURN_FUNCTION.

Referenced by addCheckSum(), calculateCheckSum(), clear(), defaultConstructorFloatingSize(), printBuffer(), printGeneral(), readData(), readDataGeneral(), readDataUnknownVersion(), daqdataformats::RawDAQDataUnitTest::resizeBufferToSizeOfDataFormats(), setBufferSourceGeneral(), writeData(), and mcdatadaq::Configuration::writeToFile().

990 {RETURN_FUNCTION(sizeofdata)();}

RETURN_FUNCTION

#define RETURN_FUNCTION(FULLFUNCTIONNAME)

Definition: Macros.h:57

daqdataformats::RawDAQData::sizeofdata

uint32_t sizeofdata() const

Sizeof method for the current data block. Returns the size of the data block in 32bit words...

Definition: RawDAQData.cpp:990

daqdataformats::RawDAQData::Sizeofdata_t ( _function_sizeofdata )

protected

Referenced by RawDAQData().

bool daqdataformats::RawDAQData::uint32_tToBool ( const uint32_t number ) const

inlineprotected

Definition at line 191 of file RawDAQData.h.

References cols, om::cout, gen_hdf5record::size, and string.

191 { return ((number) ? true : false); }

void * daqdataformats::RawDAQData::writeData ( const void * buffer ) const

Write Data to target memory location. Return is the address of the end of the write. NULL on error.

General write method that writes the raw formated data block to the target memory We are not going to overload it, so no need to declare virtual

Loop over words of the buffer

Definition at line 302 of file RawDAQData.cpp.

References EXECUTE_FUNCTION, MECModelEnuComparisons::i, RAWBUFF32, and sizeofdata().

                                                     {
 
   if(buffer == 0){return 0;}
 
   uint32_t* write_buffer  = (uint32_t*)buffer;
 
   const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();
   /// Loop over words of the buffer
   for(uint32_t i = 0; i < size_of_data; ++i){
     *write_buffer = RAWBUFF32[i];
     ++write_buffer;
   } // endfor
 
   return write_buffer;
 }// end of RawDAQData::writeData(void* buffer)

ssize_t daqdataformats::RawDAQData::writeData ( const int fd ) const

Write Data to target file descriptor. Return is the number of bytes written. -1 on error.

Definition at line 320 of file RawDAQData.cpp.

References _Buffer, EXECUTE_FUNCTION, sizeofdata(), and pclistAnalyser::write.

                                                 {
     if(fd>0){
     return write(fd, _Buffer, (size_t)EXECUTE_FUNCTION(sizeofdata)()*sizeof(uint32_t));
   }else{
     return -1;
   }
 }// end of RawDAQData::writeData(int fd)

Friends And Related Function Documentation

friend class novadaq::datalogger::DataBlockReader

friend

Definition at line 303 of file RawDAQData.h.

Member Data Documentation

void* daqdataformats::RawDAQData::_Buffer

protected

All data formats need to have _Buffer and a Data structure. _Buffer will be common.

The internal Buffer for each data format Generalized pointer to the buffer holding the packed data This pointer is used in performing generalized read/write calls and should be set during initialization

Definition at line 276 of file RawDAQData.h.

Referenced by calculateCheckSum(), copy(), defaultConstructorFloatingSize(), lastOperationsInDeepCopy(), printBuffer(), daqdataformats::RawMilliSlice::printStandard(), daqdataformats::RawMicroSlice::printStandard(), RawDAQData(), daqdataformats::RawMilliSlice::readData(), daqdataformats::RawMicroSlice::readData(), readData(), daqdataformats::RawMilliSlice::setBufferSource(), daqdataformats::RawMilliSliceIndex::setBufferSource(), daqdataformats::RawMicroSlice::setBufferSource(), setBufferSource(), and writeData().

std::vector<uint32_t> daqdataformats::RawDAQData::_InternalBuffer

protected

The internal buffer to hold data. Not always needed. A data format may have an external buffer.

Definition at line 283 of file RawDAQData.h.

Referenced by addCheckSum(), addToInternalBuffer(), clear(), daqdataformats::RawMilliSlice::close(), copy(), defaultConstructorFloatingSize(), daqdataformats::RawMilliSlice::init(), printBuffer(), daqdataformats::RawMilliSlice::readData(), readDataGeneral(), reserveInternalBuffer(), resetBufferSource(), and resizeInternalBuffer().

bool daqdataformats::RawDAQData::_shouldBufferBeInternal

protected

Auxillary variable that holds whether the buffer should be external or internal.

Definition at line 286 of file RawDAQData.h.

Referenced by daqdataformats::RawMilliSliceIndex::addIndex(), checkBufferInternalness(), daqdataformats::RawMicroSlice::init(), RawDAQData(), daqdataformats::RawMicroSlice::readData(), daqdataformats::RawMilliSlice::setBufferSource(), daqdataformats::RawMilliSliceIndex::setBufferSource(), and daqdataformats::RawMicroSlice::setBufferSource().

version_t daqdataformats::RawDAQData::_version

protected

DataFormat Version.

Definition at line 289 of file RawDAQData.h.

Referenced by copy(), defaultConstructorFloatingSize(), functionIsNotAllowed(), generateExceptionForWrongVersion(), RawDAQData(), readDataUnknownVersion(), and setBufferSourceUnknownVersion().

The documentation for this class was generated from the following files:

/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-01-18/DAQDataFormats/cxx/include/RawDAQData.h
/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-01-18/DAQDataFormats/cxx/src/RawDAQData.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation