RawDAQData.cpp

Go to the documentation of this file.

#include "DAQDataFormats/RawDAQData.h"
#include "DAQDataFormats/BitFields.h"
#include "DAQDataFormats/NOvACheckSum.h"
#include <DAQDataFormats/Macros.h> // most classes will use this
#include <DAQDataFormats/DataFormatException.h>

#include <boost/lexical_cast.hpp>
#include <boost/format.hpp>

namespace daqdataformats{

//------------------------------------------------------------------------------
// Addition to the default constructor
RawDAQData::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)
{ }

//------------------------------------------------------------------------------
RawDAQData::RawDAQData(const version_t version):
     _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)
{ }
//------------------------------------------------------------------------------
RawDAQData::RawDAQData (const version_t version, bool):
     _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)
{ }
//------------------------------------------------------------------------------
RawDAQData::RawDAQData (const version_t version, Sizeofdata_t(sz)):
     _Buffer                  (NULL)
    ,_shouldBufferBeInternal  (false)
    ,_version                 (version)
    ,_function_init           (&RawDAQData::init)
    ,_function_sizeofdata     ((sizeofdata_t)sz)
    ,_function_print          (&RawDAQData::printUnknownVersion)
    ,_function_readData       (&RawDAQData::readDataGeneral)
    ,_function_setBufferSource(&RawDAQData::setBufferSource)
{ }
//------------------------------------------------------------------------------
RawDAQData::RawDAQData (const version_t version, bool, Sizeofdata_t(sz)):
     _Buffer                  (NULL)
    ,_shouldBufferBeInternal  (false)
    ,_version                 (version)
    ,_function_init           (&RawDAQData::init)
    ,_function_sizeofdata     ((sizeofdata_t)sz)
    ,_function_print          (&RawDAQData::printUnknownVersion)
    ,_function_readData       (&RawDAQData::readDataUnknownVersion)
    ,_function_setBufferSource(&RawDAQData::setBufferSourceUnknownVersion)
{ }
//------------------------------------------------------------------------------
RawDAQData::RawDAQData (Init_t(init_function_pointer [[gnu::unused]])):
     _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)
{ }

//------------------------------------------------------------------------------
RawDAQData::RawDAQData (const version_t version, Init_t(init_function_pointer)):
     _Buffer                  (NULL)
    ,_shouldBufferBeInternal  (false)
    ,_version                 (version)
    ,_function_init           ((init_t)init_function_pointer)
    ,_function_sizeofdata     (NULL)
    ,_function_print          (&RawDAQData::printUnknownVersion)
    ,_function_readData       (&RawDAQData::readDataUnknownVersion)
    ,_function_setBufferSource(&RawDAQData::setBufferSource)
{ }
//------------------------------------------------------------------------------
RawDAQData::RawDAQData (const version_t version, 
                        Init_t(init_function_pointer),
                        Sizeofdata_t(sz)):
     _Buffer                  (NULL)
    ,_shouldBufferBeInternal  (false)
    ,_version                 (version)
    ,_function_init           ((init_t)init_function_pointer)
    ,_function_sizeofdata     ((sizeofdata_t)sz)
    ,_function_print          (&RawDAQData::printUnknownVersion)
    ,_function_readData       (&RawDAQData::readDataUnknownVersion)
    ,_function_setBufferSource(&RawDAQData::setBufferSource)
{ }

//------------------------------------------------------------------------------
RawDAQData::RawDAQData (const version_t version,
                        Init_t(init_function_pointer),
                        Sizeofdata_t(sz),
                        SetBufferSource_t(bs)):
     _Buffer                  (NULL)
    ,_shouldBufferBeInternal  (false)
    ,_version                 (version)
    ,_function_init           ((init_t)init_function_pointer)
    ,_function_sizeofdata     ((sizeofdata_t)sz)
    ,_function_print          (&RawDAQData::printUnknownVersion)
    ,_function_readData       (&RawDAQData::readDataUnknownVersion)
    ,_function_setBufferSource((setBufferSource_t)bs)
{ }

//------------------------------------------------------------------------------
RawDAQData::RawDAQData (const version_t version,
                        Init_t(init_function_pointer),
                        Sizeofdata_t(sz),
                        SetBufferSource_t(bs),
                        Print_t(pr),
                        ReadData_t(rd)):
     _Buffer                  (NULL)
    ,_shouldBufferBeInternal  (false)
    ,_version                 (version)
    ,_function_init           ((init_t)init_function_pointer)
    ,_function_sizeofdata     ((sizeofdata_t)sz)
    ,_function_print          ((print_t)pr)
    ,_function_readData       ((readData_t)rd)
    ,_function_setBufferSource((setBufferSource_t)bs)
{ }

//------------------------------------------------------------------------------
RawDAQData::RawDAQData (const RawDAQData& copy_in):
     _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)
{ }
//------------------------------------------------------------------------------
void RawDAQData::lastOperationsInDeepCopy(const RawDAQData& copy_in){

    /// 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);
    }
}

//------------------------------------------------------------------------------
// Addition to the default destructor
RawDAQData::~RawDAQData(){ }

//------------------------------------------------------------------------------
// General I/O Methods
// These methods rely on the _Buffer pointer to the general data
// buffer being set by the class, and there being an implimentation
// of the sizeofdata() method.
// 
// These methods can be reimplimented by individual classes if their
// I/O is more complicated
// Method to write the data out to a file descriptor
//------------------------------------------------------------------------------
void* RawDAQData::readData(const void* buffer){
    RETURN_FUNCTION(readData)(buffer);
}

// Method to read the data in from a raw buffer when size_of_data is known
void* RawDAQData::readDataGeneral(const void* buffer){
    return readDataGeneral(buffer, EXECUTE_FUNCTION(sizeofdata)(), 0);
}
//------------------------------------------------------------------------------
/// Adding stuff to buffer
void* RawDAQData::readDataGeneral(const void* buffer_void, const uint32_t size_of_data_to_read){

  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* RawDAQData::readDataGeneral(const void* buffer_void, const uint32_t size_of_data_to_read, const uint32_t buffer_start_position){

  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);
}



//------------------------------------------------------------------------------
readDataStatus RawDAQData::readData(const int fd){

  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;
}


//------------------------------------------------------------------------------
bool RawDAQData::reserveInternalBuffer(const uint32_t size_of_data){

    /// 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 RawDAQData::addToInternalBuffer(const uint32_t size_of_data){
    for(uint32_t i = 0; i < size_of_data; ++i)
        _InternalBuffer.push_back(0);

    return true;
}

//------------------------------------------------------------------------------
bool RawDAQData::resizeInternalBuffer(const uint32_t size_of_data){

    if(_InternalBuffer.size() < size_of_data)
        _InternalBuffer.resize(size_of_data);

    return true;
}

//------------------------------------------------------------------------------
// Method to write the data out to a raw buffer
void* RawDAQData::writeData(const void* buffer) const {

  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)

//------------------------------------------------------------------------------
// Method to write the data out to a file descriptor
ssize_t RawDAQData::writeData(const int fd) const {
    if(fd>0){
    return write(fd, _Buffer, (size_t)EXECUTE_FUNCTION(sizeofdata)()*sizeof(uint32_t));
  }else{
    return -1;
  }
}// end of RawDAQData::writeData(int fd)


//------------------------------------------------------------------------------
void RawDAQData::printBuffer(std::ostream&     out_stream
                            ,const bool        print_offset             /* Print offset from the address of the _Buffer */
                            ,const bool        print_ascii              /* Print ASCII of the content of the Buffer */
                            ,const bool        print_buffer_address     /* Print Buffer Address */
                            ,const bool        print_internal_buffer    /* Print Internal Buffer Info */
                            ,const bool        print_size_of_data       /* Print Size Of Data */
                            ,const std::string separation_between_lines /* Separation symbol between lines */
                            ,const uint32_t    cols                     /* Number of columns in a line */
                            ) const {

  // 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 RawDAQData::printWord (const uint32_t iword, const bool is_bynary_printing, std::ostream& out_stream) const {

    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 RawDAQData::printWordBinary(const uint32_t value, std::ostream& out_stream) const {

        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 RawDAQData::printWordHex   (const uint32_t value, std::ostream& out_stream) const{
        out_stream<<boost::format("0x%08x")% value;
}

//------------------------------------------------------------------------------
void RawDAQData::printBinary (const void* buffer0, const uint32_t size, std::ostream& out_stream) const{

    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 RawDAQData::printHex    (const void* buffer0, const uint32_t size, std::ostream& out_stream) const{

    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 RawDAQData::print(std::ostream& os) const {RETURN_FUNCTION(print)(os);}

//------------------------------------------------------------------------------
void RawDAQData::print(std::string& output_string) const{

    /// 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();

}

//------------------------------------------------------------------------------
// General printing of a DAQDataFormat member. Should be overloaded.
void RawDAQData::printGeneral(std::ostream& output_stream) const {
    
    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()

//------------------------------------------------------------------------------
// Calculate Check Sum (CRC) for _Buffer.
// skip_last_words = number of words from the end to skip.
// Usually use just 0 or 1. 0 - to calculate CRC of the whole _Buffer.
// 0 to caclulate the CRC for the whole _Buffer
// 1 is usually used to append CRC to the _Buffer block
uint32_t RawDAQData::calculateCheckSum(const uint32_t skip_last_words) const {

    NOvACheckSum* CheckSum = NOvACheckSum::getInstance();

    return CheckSum->processCRC(_Buffer, EXECUTE_FUNCTION(sizeofdata)() - skip_last_words);
}// end of calculateCheckSum

//------------------------------------------------------------------------------
// Add the CRC into the end of fBuffer. CRC of all but the last words of the _Buffer
bool RawDAQData::addCheckSum() {

    /// 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()

//------------------------------------------------------------------------------
// Clears all data in the buffer
bool RawDAQData::clear(){

  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

//------------------------------------------------------------------------------
bool RawDAQData::reset(){
  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 RawDAQData::resetBufferSource() {
  PRINT_ON_DEBUG(__PRETTY_FUNCTION__);

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

//------------------------------------------------------------------------------
bool RawDAQData::checkBufferInternalness(){

    if(_shouldBufferBeInternal && !isInternalBuffer())
        return resetBufferSource();

    return true;
}

//------------------------------------------------------------------------------
// 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
void RawDAQData::defaultConstructorFixedSize(){
    defaultConstructorGeneral((resetBufferSource_t)&RawDAQData::reset);
}// end of defaultConstructorFixedSize(version_t)

//------------------------------------------------------------------------------
// 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
void RawDAQData::defaultConstructorFixedSize(Init_t(init_function_pointer)){
    defaultConstructorGeneral(init_function_pointer, (resetBufferSource_t)&RawDAQData::reset);
}// end of defaultConstructorFixedSize(version_t, boost::function<void()>&)

//------------------------------------------------------------------------------
// 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
void RawDAQData::defaultConstructorFloatingSize(){
    defaultConstructorGeneral((resetBufferSource_t)&RawDAQData::resetBufferSource);
}// end of defaultConstructorFloatingSize(version_t)

//------------------------------------------------------------------------------
// 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
void RawDAQData::defaultConstructorFloatingSize(Init_t(init_function_pointer)){
    defaultConstructorGeneral(init_function_pointer, (resetBufferSource_t)&RawDAQData::resetBufferSource);
}// end of defaultConstructorFloatingSize(version_t, boost::function<void()>&)

//------------------------------------------------------------------------------
/// General routines for the default constructor of main class
void RawDAQData::defaultConstructorGeneral(ResetBufferSource_t(reset_buffer_source)){
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 0 (Beginning)");

    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<". _version is set to "<<_version);

    /// Now, need to set all function pointers

    /// If version is unknown, then we can't do the following:
    ///   1. initialize internal buffer because we don't know the size
    ///   2. set buffer to the internal buffer, because internal buffer is 0
    ///   3. initialize fields of the class, because we don't know which ones
    /// Anyways, if we know the version, then go ahead and do all those steps
    if(isVersionUnknown()){
            PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 2 (Version is unknown)");
        /// Since the version is unknown, we want to at least set the buffer to internal
        /// Initialize the internal buffer to size 1
        resizeInternalBuffer(1);
            PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 3 (after resizing InternalBuffer, before assigning _Buffer pointer)");

        /// Set buffer to the internal buffer
        /// Everything else is uninitialized
        _Buffer = &(_InternalBuffer[0]);
            PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 4 (after assigning _Buffer pointer)");
    }
    else {
        /// Version is known
        /// Set all Function pointers
        setFunctionPointers();
            {
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 5 (after setting Function pointers)");
            PRINT_ON_DEBUG   ("sizeofdata_function_pointer="<<_function_sizeofdata);
            PRINT_ON_DEBUG   ("init_function_pointer="<<_function_init);
            EXECUTE_ON_DEBUG (uint32_t size0 = EXECUTE_FUNCTION(sizeofdata)());
            PRINT_ON_DEBUG   ("size after setting FunctionPointers = "<<size0);
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 6 (about to do resizeBuffer)");
            EXECUTE_ON_DEBUG (uint32_t size = EXECUTE_FUNCTION(sizeofdata)());
            PRINT_ON_DEBUG   ("size = "<<size);
            }

        /// Initialize internal buffer
        /// We do know that it's internal buffer, because defaultConstructorGeneral is used for internal buffer only
        resizeInternalBuffer(EXECUTE_FUNCTION(sizeofdata)());
            {
            PRINT_ON_DEBUG   ("Internal Buffer size = "<<_InternalBuffer.size());
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 7 (about to call reset_buffer_source)");
            }

        /// Set buffer to the internal buffer. May be clearing buffer as well
        EXECUTE_GENERAL_FUNCTION(reset_buffer_source)();
            {
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 8 (about to init)");
            PRINT_ON_DEBUG   ("Internal Buffer size = "<<_InternalBuffer.size());
            PRINT_ON_DEBUG   ("size = "<<EXECUTE_FUNCTION(sizeofdata)());
        EXECUTE_ON_DEBUG (if(EXECUTE_FUNCTION(sizeofdata)() != _InternalBuffer.size()) std::cout<<"SOMETHING MAY BE WRONG!!!\n");
            PRINT_ON_DEBUG   ("initing");
            }

        /// Do initializations
        EXECUTE_FUNCTION(init)();
            {
            PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 9 (about to exit)");
            PRINT_ON_DEBUG("size of data:"<<EXECUTE_FUNCTION(sizeofdata)());
            PRINT_ON_DEBUG("size of internal buffer:"<<_InternalBuffer.size());
            }

    }// end of checking whether version is unknown


    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 10 (exiting)");
}// end of defaultConstructorGeneral(const ResetBufferSource_t)


//------------------------------------------------------------------------------
/// General routines for the default constructor of main class with a given init function pointer
void RawDAQData::defaultConstructorGeneral(  Init_t             (init_function_pointer)
                                           , ResetBufferSource_t(reset_buffer_source)
                                          )
{
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 0 (Beginning)");
    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<". _version is set to "<<_version);

    /// Now, need to set all function pointers
    /// If version is unknown, then we can't do the following:
    ///   1. initialize internal buffer because we don't know the size
    ///   2. set buffer to the internal buffer, because internal buffer is 0
    ///   3. initialize fields of the class, because we don't know which ones
    /// Anyways, if we know the version, then go ahead and do all those steps
    if(isVersionUnknown()){
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 2 (Version i unknown)");
        /// Since the version is unknown, we want to at least set the buffer to internal
        /// Initialize the internal buffer to size 1
        resizeInternalBuffer(1);
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 3 (after resizing InternalBuffer, before assigning _Buffer pointer)");

        /// Set buffer to the internal buffer
        /// Everything else is uninitialized
        _Buffer = &(_InternalBuffer[0]);
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 4 (after assigning _Buffer pointer)");
    }
    else {
        /// Version is known
        /// Set all function pointers
        setFunctionPointers();
            {
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 5 (after setting Function pointers)");
            EXECUTE_ON_DEBUG (uint32_t size0 = EXECUTE_FUNCTION(sizeofdata)());
            PRINT_ON_DEBUG   ("size after setting FunctionPointers = "<<size0);
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 6 (about to do resizeBuffer)");
            EXECUTE_ON_DEBUG (uint32_t size = EXECUTE_FUNCTION(sizeofdata)());
            PRINT_ON_DEBUG   ("size = "<<size);
            }

        /// Initialize internal buffer
        /// We do know that it's internal buffer, because defaultConstructorGeneral is used for internal buffer only
        resizeInternalBuffer(EXECUTE_FUNCTION(sizeofdata)());
            {
            PRINT_ON_DEBUG   ("Internal Buffer size = "<<_InternalBuffer.size());
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 7 (about to call reset_buffer_source)");
            }

        /// Set buffer to the internal buffer. May be clearing buffer as well
        EXECUTE_GENERAL_FUNCTION(reset_buffer_source)();
            {
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 8 (about to init)");
            PRINT_ON_DEBUG   ("Internal Buffer size = "<<_InternalBuffer.size());
            PRINT_ON_DEBUG   ("size = "<<EXECUTE_FUNCTION(sizeofdata)());
        EXECUTE_ON_DEBUG (if(EXECUTE_FUNCTION(sizeofdata)() != _InternalBuffer.size()) std::cout<<"SOMETHING MAY BE WRONG!!!\n");
            PRINT_ON_DEBUG   ("initing");
            }

        /// Execute ::init() or whatever else is binded
        EXECUTE_GENERAL_FUNCTION(init_function_pointer)();
            {
            PRINT_ON_DEBUG   (__PRETTY_FUNCTION__<<" 9 (about to exit)");
            PRINT_ON_DEBUG   ("size of data:"<<EXECUTE_FUNCTION(sizeofdata)());
            PRINT_ON_DEBUG   ("size of internal buffer:"<<_InternalBuffer.size());
            }

    }// end of checking whether version is unknown

    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 10 (exiting)");
}// end of defaultConstructorGeneral(const Init_t, const ResetBufferSource_t)

//------------------------------------------------------------------------------
/// 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
void* RawDAQData::readDataUnknownVersion(const void* buffer){

    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

//------------------------------------------------------------------------------
// Deep Copy Method
void RawDAQData::copy(const RawDAQData& copy_in){

    /// 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)

//------------------------------------------------------------------------------
// Shallow Copy Method
void RawDAQData::copy(const void* external_buffer){
    /// 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)

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

//------------------------------------------------------------------------------
// Set the bufferSource and return pointer to the beginning of the next block
void* RawDAQData::setBufferSourceGeneral(RawDAQData& dataformat, const void* pointer){
    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  RawDAQData::setBufferSourceUnknownVersion(const void* pointer){
    /// 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)

//------------------------------------------------------------------------------
uint64_t RawDAQData::getUint64_t(const uint32_t low, const uint32_t high) const { return (uint64_t) high<<32 | low;}
//------------------------------------------------------------------------------
bool     RawDAQData::getLoAndHi(const uint64_t input_data, uint32_t& out_low_word, uint32_t& out_hi_word) const {
     out_low_word = input_data & 0xffffffff;
     out_hi_word  = input_data >> 32;
     return true;
}// end of getLoAndHi

/*
//------------------------------------------------------------------------------
uint64_t RawDAQData::getUint64_t(  const DELEGATE_0PAR(RawDAQData, function_get_low_word, uint32_t)
                                 , const DELEGATE_0PAR(RawDAQData, function_get_hi_word , uint32_t)
                                ) const{
    //const DELEGATE_1PAR(RawDAQData, function_set_low_word, bool, uint32_t);
    //(((const RawDAQData *)this)->*function_get_low_word)();

    //EXECUTE_GENERAL_FUNCTION(function_set_low_word)(1);
    //(this->*function_set_low_word)(1);
    
    //EXECUTE_GENERAL_FUNCTION(function_get_low_word)();
      uint32_t low  = (uint32_t)EXECUTE_GENERAL_FUNCTION(function_get_low_word)();
      //const uint32_t high = EXECUTE_GENERAL_FUNCTION(function_get_hi_word )();

    uint32_t low, high;
      return getUint64_t(low, high);
}
*/

//------------------------------------------------------------------------------
bool    RawDAQData::setUint64_t(const uint64_t value,
                                DELEGATE(RawDAQData, function_set_low_word, bool, uint32_t),
                                DELEGATE(RawDAQData, function_set_hi_word , bool, uint32_t)
                               ){
      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

//------------------------------------------------------------------------------
// Generating exception as the version of DAQDataFormat is greater than the maximum allowed
std::string RawDAQData::generateExceptionForWrongVersion(const version_t maximum_version) const {

    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


//------------------------------------------------------------------------------
// Generating exception as the version of DAQDataFormat is greater than the maximum allowed
bool RawDAQData::functionIsNotAllowed(const std::string function, const std::string message) const {

    /// 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;
}



//------------------------------------------------------------------------------
uint32_t RawDAQData::sizeofdata() const {RETURN_FUNCTION(sizeofdata)();}

//------------------------------------------------------------------------------
uint32_t calculateShiftFromAGivenMask (const uint32_t mask) {

    /// check that mask is not zero
    if(mask == 0x0) return 0;

    /// find the number of first non-zero bit
    uint32_t ibit = 0;
    for(; ibit < 32; ++ibit){

        /// check if the bit is non-zero
        if(mask & (0x1 << ibit)) return ibit;

    }// end of loop over bits

    return ibit;
}// end of calculateShiftFromAGivenMask

//------------------------------------------------------------------------------
/// implement << operator
std::ostream& operator << (std::ostream& os, const daqdataformats::RawDAQData& dataformat) {
    //dataformat.printFromFunctionPointer(os);
    dataformat.print(os);
    return os;
}// end of << operator

}// end of namespace daqdataformats