RawDataBlockV0.cpp

Go to the documentation of this file.

#include "DAQDataFormats/RawDataBlockV0.h"
#include "DAQDataFormats/RawDataBlock.h"
#include "DAQDataFormats/RawMilliSliceHeader.h"
#include "DAQDataFormats/DataFormatException.h"

#include <sys/time.h>           // gettimeofday
#include <stdarg.h>             // va_start
#include <stdio.h>              // printf

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

/// It is requred to
///   1. include DAQDataFormats/DataFormatFirst.inc
///   2. define CURRENT_CLASS
///   3.    define CURRENT_CLASS_VERSION for version of the class
///      OR define LAST_CLASS_VERSION    for the main structure of the class
///   4. (optional) define CURRENT_FIELDS_SUB_NAMESPACE
///   5. include DAQDataFormats/DataFormatLast.inc
/// before the declaration of the DataFormat version class in the header.
#include "DAQDataFormats/DataFormatFirst.inc"
#define  CURRENT_CLASS                RawDataBlock
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE rawnano
#include "DAQDataFormats/DataFormatLast.inc"

namespace daqdataformats{
namespace VERSION_NAMESPACE{
//------------------------------------------------------------------------------
// Default constructor
RawDataBlock::RawDataBlock(const version_t version, const uint32_t tlvl):
     RawDAQData(version, true, (sizeofdata_t) &RawDataBlock::getPredeterminedSize)
    ,_function_readDataFromFileDescriptor(&RawDataBlock::readDataUnknownVersion)
    ,ZEROOUT_FUNCTION(close)
    ,ZEROOUT_FUNCTION(setFloatingMicroBlockToBufferSource)
    ,ZEROOUT_FUNCTION(clear)
    ,ZEROOUT_FUNCTION(softclear)
    ,ZEROOUT_FUNCTION(getVersion)
    ,ZEROOUT_FUNCTION(getMarker)
    ,ZEROOUT_FUNCTION(getTrigNumLo)
    ,ZEROOUT_FUNCTION(getTrigNumHi)
    ,ZEROOUT_FUNCTION(getTrigNum)
    ,ZEROOUT_FUNCTION(getNumMicroBlocks)
    ,ZEROOUT_FUNCTION(getBuffId)
    ,ZEROOUT_FUNCTION(getDataSize)
    ,ZEROOUT_FUNCTION(getMonteCarloFlag)
    ,ZEROOUT_FUNCTION(isCRCCalculationUsed)
    ,ZEROOUT_FUNCTION(isConnectionInitialization)
    ,ZEROOUT_FUNCTION(isCloseConnection)
    ,ZEROOUT_FUNCTION(isMissingData)
    ,ZEROOUT_FUNCTION(setFloatingMicroBlock)
    ,ZEROOUT_FUNCTION(getCRC)
    ,ZEROOUT_FUNCTION(setTrigNumLo)
    ,ZEROOUT_FUNCTION(setTrigNumHi)
    ,ZEROOUT_FUNCTION(setTrigNum)
    ,ZEROOUT_FUNCTION(setBuffId)
    ,ZEROOUT_FUNCTION(setConnectionInitialization)
    ,ZEROOUT_FUNCTION(setMonteCarloFlag)
    ,ZEROOUT_FUNCTION(setCloseConnection)
    ,ZEROOUT_FUNCTION(setMissingData)
    ,ZEROOUT_FUNCTION(addMicroBlock1)
    ,ZEROOUT_FUNCTION(addMicroBlock2)
    ,ZEROOUT_FUNCTION(addMicroBlock3)
    ,ZEROOUT_FUNCTION(addMicroBlock4)
    ,_Header                             (NULL)
    ,_FloatingMicroBlock                 (NULL)
    ,_FloatingMicroBlockNumber           (-1)
    ,_microBlockVersion                  (rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
    ,_tlvl                               (tlvl)
    ,_fd_read_bytes                      (0)
{}
//------------------------------------------------------------------------------
RawDataBlock::RawDataBlock(const RawDataBlock& copyin):
     RawDAQData(copyin)
    ,DEEPCOPY_FUNCTION(readDataFromFileDescriptor)
    ,DEEPCOPY_FUNCTION(close)
    ,DEEPCOPY_FUNCTION(setFloatingMicroBlockToBufferSource)
    ,DEEPCOPY_FUNCTION(clear)
    ,DEEPCOPY_FUNCTION(softclear)
    ,DEEPCOPY_FUNCTION(getVersion)
    ,DEEPCOPY_FUNCTION(getMarker)
    ,DEEPCOPY_FUNCTION(getTrigNumLo)
    ,DEEPCOPY_FUNCTION(getTrigNumHi)
    ,DEEPCOPY_FUNCTION(getTrigNum)
    ,DEEPCOPY_FUNCTION(getNumMicroBlocks)
    ,DEEPCOPY_FUNCTION(getBuffId)
    ,DEEPCOPY_FUNCTION(getDataSize)
    ,DEEPCOPY_FUNCTION(getMonteCarloFlag)
    ,DEEPCOPY_FUNCTION(isCRCCalculationUsed)
    ,DEEPCOPY_FUNCTION(isConnectionInitialization)
    ,DEEPCOPY_FUNCTION(isCloseConnection)
    ,DEEPCOPY_FUNCTION(isMissingData)
    ,DEEPCOPY_FUNCTION(setFloatingMicroBlock)
    ,DEEPCOPY_FUNCTION(getCRC)
    ,DEEPCOPY_FUNCTION(setTrigNumLo)
    ,DEEPCOPY_FUNCTION(setTrigNumHi)
    ,DEEPCOPY_FUNCTION(setTrigNum)
    ,DEEPCOPY_FUNCTION(setBuffId)
    ,DEEPCOPY_FUNCTION(setConnectionInitialization)
    ,DEEPCOPY_FUNCTION(setMonteCarloFlag)
    ,DEEPCOPY_FUNCTION(setCloseConnection)
    ,DEEPCOPY_FUNCTION(setMissingData)
    ,DEEPCOPY_FUNCTION(addMicroBlock1)
    ,DEEPCOPY_FUNCTION(addMicroBlock2)
    ,DEEPCOPY_FUNCTION(addMicroBlock3)
    ,DEEPCOPY_FUNCTION(addMicroBlock4)
    ,_Header                   (NULL)
    ,_FloatingMicroBlock       (NULL)
    ,_FloatingMicroBlockNumber (-1)
    ,_microBlockVersion        (copyin._microBlockVersion)
    ,_tlvl                     (copyin._tlvl)
    ,_fd_read_bytes            (copyin._fd_read_bytes)
{ }

//------------------------------------------------------------------------------
// Destructor
RawDataBlock::~RawDataBlock(){
    if(_Header)             delete _Header;
    if(_FloatingMicroBlock) delete _FloatingMicroBlock;
}

//------------------------------------------------------------------------------
bool RawDataBlock::clear(){
    _fd_read_bytes = 0;
    return RawDAQData::clear();
}

//------------------------------------------------------------------------------
bool RawDataBlock::softclear(){
    _fd_read_bytes = 0;
    return true;
}

//------------------------------------------------------------------------------
// General initialization
void RawDataBlock::init(){

    /// This is needed for the formats with variable size
    /// If buffer is internal, need to resize it
    if(_shouldBufferBeInternal){
        resizeInternalBuffer(_Header->sizeofdata() + 1);
        /// Check pointers after each read or resize buffer
        checkBufferInternalness();
    }

    _Header->init();
    
    /// Initialize _FloatingMicroBlockNumber
    _FloatingMicroBlockNumber = -1;
}

//------------------------------------------------------------------------------
// Add a MicroBlock into the DataBlock
bool RawDataBlock::addMicroBlock1(const void* microblock_buffer, const bool check_mc_flag){

  PRINT_ON_DEBUG("In "<<__PRETTY_FUNCTION__<<"  0. Version "<<_microBlockVersion);

    /// Construct a temporary nanoslice with external buffer
    const daqdataformats::RawMicroBlock tmp_microblock(microblock_buffer, _microBlockVersion);

    PRINT_ON_DEBUG("In "<<__PRETTY_FUNCTION__<<"  1");

    /// Check the MicroBlock version
    if(_microBlockVersion == rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION){
        _microBlockVersion = tmp_microblock.getHeader()->getVersion();
    }// end of checking the MicroBlock version

    PRINT_ON_DEBUG("In "<<__PRETTY_FUNCTION__<<"  2");
    PRINT_ON_DEBUG("About to add "<<tmp_microblock.sizeofdata()<<" words");

    RETURN_FUNCTION(addMicroBlock2)(microblock_buffer, tmp_microblock.sizeofdata(), check_mc_flag);
}

//------------------------------------------------------------------------------
// Add a MicroBlock of a given size into the DataBlock
bool RawDataBlock::addMicroBlock2(const void* microblock_buffer, const uint32_t microblock_size, const bool check_mc_flag){

  PRINT_ON_DEBUG("In "<<__PRETTY_FUNCTION__<<"  0");

  PRINT_ON_DEBUG("Size of internal buffer before reading "<<_InternalBuffer.size());


    /// Before reading, we need to adjust the size of the DataBlock
    /// Cannot rely on the size adjustment from readDataGeneral, because we don't read CRC from microblock
    const uint32_t new_sizeofdata = EXECUTE_FUNCTION(sizeofdata)() + microblock_size;

    /// If buffer is internal, we need to adjust its size
    if(_shouldBufferBeInternal) {
        /// Microblock size is the size of the header and the microslice

        /// Add the microblock size
        resizeInternalBuffer(new_sizeofdata);

        /// Check pointers after each read or resize buffer
        checkBufferInternalness();
    }// end of adjusting the internal buffer size
    
    /// Read the MicroBlock to the _Buffer starting from the previous position
    /// -1 because of CRC
    readDataGeneral(microblock_buffer, microblock_size, EXECUTE_FUNCTION(sizeofdata)() - 1);
    /// Check pointers after each read or resize buffer
    checkBufferInternalness();

    PRINT_ON_DEBUG("Size of internal buffer after reading "<<_InternalBuffer.size());

    /// Change the DataBlock header appropriately
    _Header->setDataSize(new_sizeofdata);
    _Header->advanceNumMicroBlocks();

    /// Check if the MicroSlice in the MicroBlock is MC generated
    /// If it is, set the appropriate DataBlock MC flag
    if(check_mc_flag){
        daqdataformats::RawMicroBlock tmp_microblock(microblock_buffer, _microBlockVersion);
        setMonteCarloFlag(tmp_microblock.getMicroSlice()->getMonteCarloFlag());
    }

    return true;
}
//------------------------------------------------------------------------------
/// Add the MicroBlock to _Buffer by passing the references of
/// the MilliSlice and the MicroSlice. MilliSlice is the one that contains the MicroSlice.
bool RawDataBlock::addMicroBlock3(const void*     millislice_buffer
                                 ,const void*     microslice_buffer
                                 ,const version_t microblock_version
                                 ,const bool      check_mc_flag
                                 )
{
        const daqdataformats::RawMicroSliceHeader tmp_microslice_header(microslice_buffer, rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION);

        EXECUTE_FUNCTION(addMicroBlock4)(millislice_buffer, microslice_buffer, tmp_microslice_header.getMicroSliceSize(), microblock_version, check_mc_flag);
        return true;
}

//------------------------------------------------------------------------------
/// Add the MicroBlock to _Buffer by passing the references of
/// the MilliSlice and the MicroSlice of a known size.
/// MilliSlice is the one that contains the MicroSlice.
bool RawDataBlock::addMicroBlock4(const void* millislice_buffer, const void* microslice_buffer, const uint32_t microslice_size, const version_t microblock_version, const bool check_mc_flag){

    _microBlockVersion       = microblock_version;

    /// Size of the MicroBlock that we are adding
    /// Start with the microslice size
    uint32_t microblock_size = microslice_size;

    /// Now, add microBlock Header size to it.
    /// If floating Microblock already exists, get its header size.
    if(_FloatingMicroBlock){
            microblock_size += _FloatingMicroBlock->getHeader()->sizeofdata();
    }
    else{
            /// Need to figure out the header size for a given version
            const daqdataformats::RawMicroBlockHeader tmp_header(_microBlockVersion);
            microblock_size += tmp_header.sizeofdata();
    }

    const uint32_t new_sizeofdata = EXECUTE_FUNCTION(sizeofdata)() + microblock_size;

    /// If buffer is internal, we need to adjust its size
    if(_shouldBufferBeInternal) {
        /// Microblock size is the size of the header and the microslice
        
        /// Add the microblock size
        resizeInternalBuffer(new_sizeofdata);

        /// Check pointers after each read or resize buffer
        checkBufferInternalness();
    }// end of adjusting the internal buffer size

    const uint32_t current_number_of_microblocks = EXECUTE_FUNCTION(getNumMicroBlocks)();

    /// Setup the DataBlock header by adding the size and the number of MicroBlocks in the DataBlock
    /// Need to have DataSize setup before setting FloatingMicroBlock
    /// This is because there is a check for going outside sizeofdata, so it's going to fail otherwise.
    _Header->setDataSize(new_sizeofdata);
    _Header->setNumMicroBlocks(current_number_of_microblocks + 1);

    /// Set the floating microblock
    EXECUTE_FUNCTION(setFloatingMicroBlock)(current_number_of_microblocks);

    /// Need to initialize the header version and such
    _FloatingMicroBlock->getHeader()->init();

    /// Read the MicroBlockHeader and the MicroSlice
    _FloatingMicroBlock->setMicroBlockHeader(millislice_buffer);
    _FloatingMicroBlock->setMicroSlice(microslice_buffer);
    /// Check if the MicroSlice in the MicroBlock is MC generated
    /// If it is, set the appropriate DataBlock MC flag
    if(check_mc_flag){
        setMonteCarloFlag(_FloatingMicroBlock->getMicroSlice()->getMonteCarloFlag());
    }// end of checking MC flag

    return true;

}

//------------------------------------------------------------------------------
// Closing the DataBlock by adding the CRC and increasing the DataBlock size by one (CRC).
bool RawDataBlock::close(const bool produce_crc){

    /// Add CRC at the very end of _Buffer
    if(produce_crc){
        _Header->setCRCCalculationUsed(true);
        /// Must be the last operation
        addCheckSum();
    }
    
    return true;
}


//------------------------------------------------------------------------------
//Getters

      uint32_t            RawDataBlock::getVersion()                 const { return _Header->getVersion();}
      uint32_t            RawDataBlock::getMarker()                  const { return _Header->getMarker();}
      uint32_t            RawDataBlock::getTrigNumLo()               const { return _Header->getTrigNumLo();}
      uint32_t            RawDataBlock::getTrigNumHi()               const { return _Header->getTrigNumHi();}
      uint64_t            RawDataBlock::getTrigNum()                 const { return _Header->getTrigNum();}
      uint16_t            RawDataBlock::getNumMicroBlocks()          const { return _Header->getNumMicroBlocks();}
      uint16_t            RawDataBlock::getBuffId()                  const { return _Header->getBuffId(); }
      uint32_t            RawDataBlock::getDataSize()                const { return _Header->getDataSize();}
      bool                RawDataBlock::getMonteCarloFlag()          const { return _Header->getMonteCarloFlag();}
      bool                RawDataBlock::isCRCCalculationUsed()       const { return _Header->isCRCCalculationUsed();}
      bool                RawDataBlock::isConnectionInitialization() const { return _Header->isConnectionInitialization();}
      bool                RawDataBlock::isCloseConnection()          const { return _Header->isCloseConnection();}
      bool                RawDataBlock::isMissingData()              const { return _Header->isMissingData();}

//------------------------------------------------------------------------------
//Setters
      bool RawDataBlock::setTrigNumLo                (const uint32_t tr)  { return _Header->setTrigNumLo(tr);}
      bool RawDataBlock::setTrigNumHi                (const uint32_t tr)  { return _Header->setTrigNumHi(tr);}
      bool RawDataBlock::setTrigNum                  (const uint64_t tr)  { return _Header->setTrigNum(tr);}
      bool RawDataBlock::setBuffId                   (const uint16_t b)   { return _Header->setBuffId(b);}
      bool RawDataBlock::setMonteCarloFlag           (const bool ft)      { return _Header->setMonteCarloFlag(ft);}
      bool RawDataBlock::setConnectionInitialization (const bool ft)      { return _Header->setConnectionInitialization(ft);}
      bool RawDataBlock::setCloseConnection          (const bool ft)      { return _Header->setCloseConnection(ft);}
      bool RawDataBlock::setMissingData              (const bool ft)      { return _Header->setMissingData(ft);}

//------------------------------------------------------------------------------
bool RawDataBlock::setBufferSource(const void* pointer){

  PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<"version = "<<_version);

        /// Set the Buffer and its header pointers
        const uint32_t* old_buffer  = (uint32_t*)_Buffer;
        _Buffer                     = (void*)pointer;
        _shouldBufferBeInternal     = isInternalBuffer();

        /// If Header is already defined, then set its buffer source
        /// Otherwise, need to construct it
        if(_Header){
            _Header->setBufferSource(pointer);
            
            /// It's possible that Floating Microblock was already constructed.
            /// If so, need to reassign its pointer
            if(_FloatingMicroBlockNumber > -1){

                /// See how many Microblocks in the new buffer.
                /// If it's greater, then make the floating MicroBlock non-valid.
                if(_FloatingMicroBlockNumber > _Header->getNumMicroBlocks()){
                    _FloatingMicroBlockNumber = -1;
                    return true;
                }// end of checking number of microblocks

                /// New Floating MicroBlock pointer
                const uint32_t* floating_microblock_pointer =((uint32_t*)_Buffer) + ((uint32_t*)_FloatingMicroBlock->getBuffer() - old_buffer);
                RETURN_FUNCTION(setFloatingMicroBlockToBufferSource)(floating_microblock_pointer);
            }// end of setting new floating MicroBlock pointer

            return true;
        }

        PRINT_ON_DEBUG("Setting Header "<<"version = "<<_version);
        _Header = new daqdataformats::RawDataBlockHeader(_Buffer, _version); ///< version of the DataBlockSliceHeader equals the version of the DataBlockSlice

        _function_sizeofdata = (sizeofdata_t) &version0::RawDataBlock::sizeofdata;

        return true;
}

//------------------------------------------------------------------------------
bool RawDataBlock::setFloatingMicroBlockToBufferSource(const void* internal_buffer_pointer) const {

        /// If it exists, just set its buffer
        if(_FloatingMicroBlock)
            return _FloatingMicroBlock->setBufferSource(internal_buffer_pointer);

        /// Otherwise, create new Floating MicroSlice pointing to the buffer
        _FloatingMicroBlock = new daqdataformats::RawMicroBlock(internal_buffer_pointer, _microBlockVersion);

        return true;
}
      
//------------------------------------------------------------------------------
bool RawDataBlock::setFloatingMicroBlock (const uint32_t imicro) const {

        /// If it's already the same, nothing needs to be done
        if((int)imicro == _FloatingMicroBlockNumber)
            return true;

        /// Pointer that we are going to use
        uint32_t* pointer = NULL;

        /// If microslice number is greater than current floating Microslice number, then no need
        /// to loop over all MicroSlices, just start from the current floating MicroSlice
        if((int)imicro > _FloatingMicroBlockNumber && _FloatingMicroBlockNumber > -1){
            pointer = (uint32_t*)_FloatingMicroBlock->getBuffer();
        }
        else{
            /// Otherwise, start from scratch
            /// First point to the first MicroSlice
            pointer = (uint32_t*)&RAWBUFF32[datablockheader::DATABLOCKHEADER_SIZE];

            /// Set floating MicroSlice to pointer
            /// If it doesn't exist, create it
            EXECUTE_FUNCTION(setFloatingMicroBlockToBufferSource)(pointer);
            _FloatingMicroBlockNumber = 0;
        }// end of setting the first floating MicroSlice

        
        /// Pointer to the end of the buffer for checks
        const uint32_t* end_of_buffer_pointer = &RAWBUFF32[EXECUTE_FUNCTION(sizeofdata)()];

        /// Start loop over microslices
        for(; _FloatingMicroBlockNumber < (int)imicro; ++_FloatingMicroBlockNumber){
            pointer += _FloatingMicroBlock->sizeofdata();

            /// Check if the pointer is not valid
            if (pointer >= end_of_buffer_pointer) return false;

            _FloatingMicroBlock->setBufferSource(pointer);
        }// end of loop over microslices

        return true;
}


//------------------------------------------------------------------------------
// Read an entire DataBlock from datablock_buffer into _Buffer
void* RawDataBlock::readData(const void* datablock_buffer){

    //Read the header and unpack it
    void* datablock_buffer_new = readDataGeneral(datablock_buffer, datablockheader::DATABLOCKHEADER_SIZE, 0);

    /// Check pointers after each read or resize buffer
    checkBufferInternalness();

    // read the rest of 
    datablock_buffer_new = readDataGeneral(datablock_buffer_new, EXECUTE_FUNCTION(sizeofdata)() - datablockheader::DATABLOCKHEADER_SIZE, datablockheader::DATABLOCKHEADER_SIZE);

    /// Check pointers after each read or resize buffer
    checkBufferInternalness();

    return datablock_buffer_new;
}

// Method to read data in to a file descriptor
// The assumption is that the read will not block because a poll or select
// (in the case that the fd is a socket) has determined that data is ready.
// (Of course, the fd is always "ready" if the fd is associate with a file
// on disk).  But no assumption is made that a 2nd rseead will not block, so
// only one read (within this readData routine) is every done. The caller
// is responsible for doing the necessary number of readData calls to get a
// "complete" object. 
readDataStatus RawDataBlock::readDataFromFileDescriptor(const int fd)
{
    
    if (fd >= 0)
    {
        if (isInternalBuffer())
        {   
            size_t bytes_to_read = 0;


            if (_fd_read_bytes < datablockheader::DATABLOCKHEADER_SIZE*sizeof(uint32_t))
            {   const size_t min_words = datablockheader::DATABLOCKHEADER_SIZE;
                const size_t min_bytes = min_words*sizeof (uint32_t);

                if (_InternalBuffer.size() < min_words)
                {
                   _InternalBuffer.resize(min_words);
                   resetBufferSource();
                }

                bytes_to_read = min_bytes - _fd_read_bytes;
            }
            else
            {   uint32_t ss=EXECUTE_FUNCTION(sizeofdata)();
                // check before using size
                if (   (!_Header->checkMarker())
                    || (ss           > 0x400000/*arbitrary val*/) )
                {   return rds_error;
                }
                if (_InternalBuffer.size() < (size_t)ss)
                {   _InternalBuffer.resize( ss );
                   resetBufferSource();
                }
                bytes_to_read = (size_t)ss*sizeof(uint32_t) - _fd_read_bytes;
            }

            const ssize_t ss = read(fd, (char*)_Buffer+_fd_read_bytes, bytes_to_read );
            if (ss==-1)
            {   perror("read");
                return rds_error;
            }
            else if (ss==0)
            {   tprintf( 5, "connection closed\n" );
                return rds_error;
            }

            _fd_read_bytes += ss;
            if (ss != (int)bytes_to_read)
            {   return rds_incomplete;
            }

            const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();

            // at this point, the header should have been read in and the
            // size from within can be examined.
            // check for reasonableness
            if (   (!_Header->checkMarker())
                || (size_of_data > 0x400000/*arbitrary val*/) )
            {   return rds_error;
            }

            if (((size_t)size_of_data*sizeof (uint32_t)) == _fd_read_bytes)
                return rds_complete;
            return rds_incomplete;
        }
        else
        {
            // assume there is enough space???
            return RawDAQData::readData(fd);
        }
    }
    return rds_error;
}

//------------------------------------------------------------------------------
readDataStatus RawDataBlock::readDataUnknownVersion(const int fd)
{
    if (fd >= 0)
    {
        if (isInternalBuffer())
        {   
            size_t bytes_to_read;

            /// See if we already read the header
            /// Identifying the size of the bytes to read
            if (_fd_read_bytes < datablockheader::DATABLOCKHEADER_SIZE*sizeof(uint32_t))
            {   const size_t min_words = datablockheader::DATABLOCKHEADER_SIZE;
                const size_t min_bytes = min_words*sizeof (uint32_t);

                if (_InternalBuffer.size() < min_words)
                {
                   _InternalBuffer.resize(min_words);
                   _Buffer = (void*)(&_InternalBuffer[0]);
                }

                bytes_to_read = min_bytes - _fd_read_bytes;
            }
            else
            {   const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();
                // check before using size
                if (   (!_Header->checkMarker())
                    || (size_of_data  > 0x400000/*arbitrary val*/) )
                {   return rds_error;
                }
                if (_InternalBuffer.size() < (size_t)size_of_data)
                {   _InternalBuffer.resize(size_of_data);
                   _Buffer = (void*)(&_InternalBuffer[0]);
                }
                bytes_to_read = (size_t)size_of_data*sizeof(uint32_t) - _fd_read_bytes;
            }

            const ssize_t ss = read(fd, (char*)_Buffer+_fd_read_bytes, bytes_to_read );
            if (ss==-1)
            {   perror("read");
                return rds_error;
            }
            else if (ss==0)
            {   tprintf( 5, "connection closed\n" );
                return rds_error;
            }

            _fd_read_bytes += ss;
            if (ss != (int)bytes_to_read)
            {   return rds_incomplete;
            }

            // at this point, the header should have been read in and the
            // size from within can be examined.
            // check for reasonableness

            _version = figureOutTheVersion(_Buffer);

            /// Now that we know the version, initialize function pointers
            setFunctionPointers();

            /// Need to construct all Headers and stuff
            resetBufferSource();

            /// Now need to adjust the internal buffer size
            const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();
            resizeInternalBuffer(size_of_data);

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

            if (   (!_Header->checkMarker())
                || (size_of_data > 0x400000/*arbitrary val*/) )
            {   return rds_error;
            }

            if (((size_t)size_of_data*sizeof (uint32_t)) == _fd_read_bytes)
                return rds_complete;
            return rds_incomplete;
        }
        else
        {
            // assume there is enough space???
            return RawDAQData::readData(fd);
        }
    }
    return rds_error;
}

//------------------------------------------------------------------------------
uint32_t RawDataBlock::getCRC() const{

    if(!isCRCCalculationUsed()) return 0;

    return RAWBUFF32[EXECUTE_FUNCTION(sizeofdata)() - 1];
}

//------------------------------------------------------------------------------
// Print the DataBlock structure
void RawDataBlock::print(std::ostream& os) const {

    const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)();

    os<<boost::format("\n---RawDataBlock----------------------------------------------------(size=%u, version=%u)\n")
            % size_of_data % _version;

    printBuffer(os);

    _Header->print(os);

    for(uint32_t i = 0; i < size_of_data; ++i){
            os<<" ";
            printWord(i, false, os);
            os<<"\n";
    }


    const uint32_t num_microblocks = _Header->getNumMicroBlocks();
    os<<"Number of MicroBlocks = "<<num_microblocks<<std::endl;
    if(num_microblocks){
        daqdataformats::RawDataBlock datablock_copy(_Buffer, _version, 0);

        /// Print all MicroBlocks
        for(uint32_t imicroblock = 0; imicroblock <num_microblocks ; ++imicroblock){
             if(!datablock_copy.setFloatingMicroBlock(imicroblock)){
                    const std::string error_message = "Some failure during setFloatingMicroBlock number "
                                                    + boost::lexical_cast<std::string>(imicroblock)
                                                    + ". Total number of microblocks = "
                                                    + boost::lexical_cast<std::string>(num_microblocks)
                                                    + "\n";
                    os<<error_message;
                    GENERATE_DATAFORMAT_EXCEPTION(error_message);
                    return;
             }

             //os<<"Micro "<<imicroblock<<" MicroBuff="<<datablock_copy.getBuffer()<<"\n";
             datablock_copy.getFloatingMicroBlock()->print(os);
        }// end of looping over microblocks
    }

    if(isCRCCalculationUsed())os<<"---  CRC = "<<getCRC()<<"\n";

}

//------------------------------------------------------------------------------
void RawDataBlock::tprintf( unsigned lvl, const char *fmt, ... )
{   if (lvl > 31) lvl=31;
    if (_tlvl & (1<<lvl))
    {   timeval         tv;
        char            str[80];
        time_t          local;
        const char*     indent="                                ";//32 spaces
        va_list         ap;
        va_start( ap, fmt);
        gettimeofday( &tv, NULL );
        local = tv.tv_sec;
        strftime( str, sizeof(str), "%T", localtime(&local) );
        printf( "%s.%06ld%s", str, (long)tv.tv_usec, &indent[31-lvl] );
        vprintf( fmt, ap );
    }
}   // tprintf


}} // end of namespaces