RawConfigurationSystemIDV0.cpp

Go to the documentation of this file.

#include "DAQDataFormats/RawConfigurationSystemIDV0.h"
#include "DAQDataFormats/RawConfigurationName.h"
#include "DAQDataFormats/BitFields.h"
#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                RawConfigurationSystemID
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE rawconfsysid
#include "DAQDataFormats/DataFormatLast.inc"

namespace daqdataformats{
namespace VERSION_NAMESPACE{

//------------------------------------------------------------------------------
// Default constructor
RawConfigurationSystemID::RawConfigurationSystemID(const version_t version):
            RawDAQData(version, true, (sizeofdata_t) &RawConfigurationSystemID::getPredefinedSize)
            ,ZEROOUT_GET_AND_SET(Version)
            ,ZEROOUT_GET_AND_SET(DAQSystemID)
            ,ZEROOUT_GET_AND_SET(DAQSubSystemID)
            ,ZEROOUT_GET_AND_SET(VersionName)
            ,ZEROOUT_FUNCTION(getHeaderSize)
            ,_versionName(NULL)
            ,_configurationName_version(rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION)
{}

RawConfigurationSystemID::RawConfigurationSystemID (const RawConfigurationSystemID& copyin):
            RawDAQData(copyin)
            ,DEEPCOPY_GET_AND_SET(Version)
            ,DEEPCOPY_GET_AND_SET(DAQSystemID)
            ,DEEPCOPY_GET_AND_SET(DAQSubSystemID)
            ,DEEPCOPY_GET_AND_SET(VersionName)
            ,DEEPCOPY_FUNCTION(getHeaderSize)
            ,_versionName(NULL)
            ,_configurationName_version(copyin._configurationName_version)

{ }

//------------------------------------------------------------------------------
// Destructor
RawConfigurationSystemID::~RawConfigurationSystemID() { }

//------------------------------------------------------------------------------
// Initialization of data members
void RawConfigurationSystemID::init(){
    EXECUTE_FUNCTION(setVersion)(_version);
}

//------------------------------------------------------------------------------
// Printing the RawConfigurationSystemID structure
void RawConfigurationSystemID::print(std::ostream& os) const{

    //printBuffer(os,true,true,true,true,true);
    //if(_versionName)_versionName->print(os);


    os<<boost::format("\n---RawConfigurationSystemID---------------------------------------------Version =%u, Size is %u words\n")
            % getVersion()% sizeofdata();

    printBuffer(os);


    os<<boost::format("DAQSystemID=%u "       ) % EXECUTE_FUNCTION(getDAQSystemID)();
    os<<boost::format("DAQSubSystemID=%u "    ) % EXECUTE_FUNCTION(getDAQSubSystemID)();

    if(_versionName){
        std::string version_name;
        EXECUTE_FUNCTION(getVersionName)(version_name);
        os<<boost::format("DAQSystemVersion=\"%s\"") % version_name.c_str();
    }

    os<<"\n";

}

//------------------------------------------------------------------------------
uint32_t RawConfigurationSystemID::getHeaderSize() const {return rawconfsysid::HEADER_SIZE;}

//------------------------------------------------------------------------------
uint32_t RawConfigurationSystemID::getVersionName(      std::string& str) const {return _versionName->getName(str);}
uint32_t RawConfigurationSystemID::setVersionName(const std::string& str)       {

   if(_shouldBufferBeInternal){

       const uint32_t new_size = EXECUTE_FUNCTION(getHeaderSize)() 
                               + _versionName->getHeaderSize()
                               + (str.size()/4 + 1);

       resizeInternalBuffer(new_size);

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


    return _versionName->setName(str);
}

//------------------------------------------------------------------------------
// Size of the RawConfigurationSystemID _Buffer in words
uint32_t RawConfigurationSystemID::sizeofdata() const { return EXECUTE_FUNCTION(getHeaderSize)() + _versionName->sizeofdata();}


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

   _Buffer                 = (void*)pointer;
   _shouldBufferBeInternal = isInternalBuffer();

   const uint32_t* version_name_pointer = (uint32_t*)(_Buffer) + EXECUTE_FUNCTION(getHeaderSize)();

   /// If _versionName is already defined, then set its buffer source
   /// Otherwise, need to construct it
   if(_versionName){
       return _versionName->setBufferSource(version_name_pointer);
   }

   if(_shouldBufferBeInternal){

       /// Figure out the minimum RawConfigurationName size
       const daqdataformats::RawConfigurationName confname_tmp(_configurationName_version);

       resizeInternalBuffer(EXECUTE_FUNCTION(getHeaderSize)() + confname_tmp.sizeofdata());

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

       _versionName = new daqdataformats::RawConfigurationName(version_name_pointer, _configurationName_version);

       /// Need to initialize to set the size.
       /// For internal buffers only and only if it's non-zero
       if(_versionName->sizeofdata() < _versionName->getHeaderSize())
            _versionName->init();
   }
   else{
       _versionName = new daqdataformats::RawConfigurationName(version_name_pointer, _configurationName_version);
   }


   _function_sizeofdata = (sizeofdata_t)&RawConfigurationSystemID::sizeofdata;

   return true;
}



//------------------------------------------------------------------------------
// This is a general method to read the microslice from millislice_buffer to _Buffer
void* RawConfigurationSystemID::readData(const void* buffer)
{
    /// Read SystemID header and Configuration Name header
    const uint32_t header_stuff = EXECUTE_FUNCTION(getHeaderSize)() + _versionName->getHeaderSize();

    void* buffer_new = readDataGeneral(buffer, header_stuff, 0);

    /// Now we know sizeofdata
    buffer_new = readDataGeneral(buffer_new, EXECUTE_FUNCTION(sizeofdata)() - header_stuff, header_stuff);
    /// Check pointers after each read or resize buffer
    checkBufferInternalness();

    return buffer_new;
}// end of readData(void*)


}}// end of namespaces