RawConfigurationNameV0.cpp

Go to the documentation of this file.

#include "DAQDataFormats/RawConfigurationNameV0.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                RawConfigurationName
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE rawconfname
#include "DAQDataFormats/DataFormatLast.inc"

namespace daqdataformats{
namespace VERSION_NAMESPACE{

//------------------------------------------------------------------------------
// Default constructor
RawConfigurationName::RawConfigurationName(const version_t version):
            RawDAQData(version, true, (sizeofdata_t) &RawConfigurationName::getPredefinedSize)
            ,ZEROOUT_GET_AND_SET(Version)
            ,ZEROOUT_GET_AND_SET(Size)
            ,ZEROOUT_GET(HeaderSize)
            ,ZEROOUT_GET_AND_SET(Name)
            ,ZEROOUT_GET_AND_SET(Char1)
            ,ZEROOUT_GET_AND_SET(Char2)
            ,ZEROOUT_GET_AND_SET(Char3)
            ,ZEROOUT_GET_AND_SET(Char4)
{ }

//------------------------------------------------------------------------------
RawConfigurationName::RawConfigurationName(const RawConfigurationName& copyin):
             RawDAQData(copyin)
            ,DEEPCOPY_GET_AND_SET(Version)
            ,DEEPCOPY_GET_AND_SET(Size)
            ,DEEPCOPY_GET(HeaderSize)
            ,DEEPCOPY_GET_AND_SET(Name)
            ,DEEPCOPY_GET_AND_SET(Char1)
            ,DEEPCOPY_GET_AND_SET(Char2)
            ,DEEPCOPY_GET_AND_SET(Char3)
            ,DEEPCOPY_GET_AND_SET(Char4)
{ }

RawConfigurationName::~RawConfigurationName(){}

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

//------------------------------------------------------------------------------
uint32_t RawConfigurationName::getHeaderSize() const {return rawconfname::WORD_Char;}

//------------------------------------------------------------------------------
// Setters
uint32_t RawConfigurationName::setName(const std::string& name){

    /// If empty name, set the Data size to the size of header and return
    if(name.size() == 0){
        RETURN_FUNCTION(setSize)(EXECUTE_FUNCTION(getHeaderSize)());
    }

    /// There are 4 bytes in word
    /// size of the name block in words
    const uint32_t size             = (name.size() - 1) / 4 + 1;

    const uint32_t total_block_size = size + EXECUTE_FUNCTION(getHeaderSize)();

    PRINT_ON_DEBUG("Setting to: "<<name<<" size="<<total_block_size);

    /// Go ahead and set the name size
    EXECUTE_FUNCTION(setSize)(total_block_size);

    PRINT_ON_DEBUG("Size now ="<<EXECUTE_FUNCTION(sizeofdata)());

    /// If buffer is internal, resize it
    if(_shouldBufferBeInternal){
        resizeInternalBuffer(total_block_size);
        checkBufferInternalness();
    }

    /// counter for the char
    uint32_t ichar = 0;

    /// Fill the Namespace fields
    for(uint32_t iword         = 0; iword < size     ; ++iword){
    for(uint32_t ichar_in_word = 0; ichar_in_word < 4; ++ichar_in_word){
        /// If current char is still one of the characters of the string
        /// that we are setting it to, read it
        /// Otherwise, make it zero.
        uint32_t letter = 0;
        if(ichar < name.size())
            letter = name[ichar];
        
        /// set the char
        switch(ichar_in_word){
            case 0: EXECUTE_FUNCTION(setChar1)(letter, iword); break;
            case 1: EXECUTE_FUNCTION(setChar2)(letter, iword); break;
            case 2: EXECUTE_FUNCTION(setChar3)(letter, iword); break;
            case 3: EXECUTE_FUNCTION(setChar4)(letter, iword); break;
        }// end of cases

        ++ichar;
    }}/// end of loops
    
    return size;
}
//------------------------------------------------------------------------------
// Setters for Chars
bool RawConfigurationName::setChar1(const uint32_t letter, const uint32_t word_number){
    uint32_t* pointer = &(RAWBUFF32[word_number + rawconfname::WORD_Char]);   
    BITFIELDSET(*pointer, letter, rawconfname::MASK_Char1, rawconfname::SHIFT_Char1);
    return true;
}
bool RawConfigurationName::setChar2(const uint32_t letter, const uint32_t word_number){
    uint32_t* pointer = &(RAWBUFF32[word_number + rawconfname::WORD_Char]);
    BITFIELDSET(*pointer, letter, rawconfname::MASK_Char2, rawconfname::SHIFT_Char2);
    return true;
}
bool RawConfigurationName::setChar3(const uint32_t letter, const uint32_t word_number){
    uint32_t* pointer = &(RAWBUFF32[word_number + rawconfname::WORD_Char]);
    BITFIELDSET(*pointer, letter, rawconfname::MASK_Char3, rawconfname::SHIFT_Char3);
    return true;
}
bool RawConfigurationName::setChar4(const uint32_t letter, const uint32_t word_number){
    uint32_t* pointer = &(RAWBUFF32[word_number + rawconfname::WORD_Char]);
    BITFIELDSET(*pointer, letter, rawconfname::MASK_Char4, rawconfname::SHIFT_Char4);
    return true;
}

//------------------------------------------------------------------------------
// Getters
uint32_t RawConfigurationName::getName(std::string& name) const{
    name.clear();

    /// size of data minus header
    const uint32_t size_of_data = EXECUTE_FUNCTION(sizeofdata)() - EXECUTE_FUNCTION(getHeaderSize)();

    /// Fill the Namespace fields
    for(uint32_t iword = 0         ; iword < size_of_data ; ++iword){
    for(uint32_t ichar_in_word = 0 ; ichar_in_word < 4    ; ++ichar_in_word){

        uint32_t current_char = 0;

        if      (ichar_in_word == 0 )
            current_char = EXECUTE_FUNCTION(getChar1)(iword);
        else if (ichar_in_word == 1 )
            current_char = EXECUTE_FUNCTION(getChar2)(iword);
        else if (ichar_in_word == 2 )
            current_char = EXECUTE_FUNCTION(getChar3)(iword);
        else if (ichar_in_word == 3 )
            current_char = EXECUTE_FUNCTION(getChar4)(iword);

        if(current_char > 0)
            name += (char)current_char;

    }}// end of loops over word and char

    return name.size();
}

//------------------------------------------------------------------------------
// Getters for Chars
uint32_t RawConfigurationName::getChar1(const uint32_t word_number) const {
    const uint32_t* pointer = &(RAWBUFF32[word_number + rawconfname::WORD_Char]);
    return BITFIELDGET(*pointer, rawconfname::MASK_Char1, rawconfname::SHIFT_Char1);

}
uint32_t RawConfigurationName::getChar2(const uint32_t word_number) const {
    const uint32_t* pointer = &(RAWBUFF32[word_number + rawconfname::WORD_Char]);
    return BITFIELDGET(*pointer, rawconfname::MASK_Char2, rawconfname::SHIFT_Char2);

}
uint32_t RawConfigurationName::getChar3(const uint32_t word_number) const {
    const uint32_t* pointer = &(RAWBUFF32[word_number + rawconfname::WORD_Char]);
    return BITFIELDGET(*pointer, rawconfname::MASK_Char3, rawconfname::SHIFT_Char3);

}
uint32_t RawConfigurationName::getChar4(const uint32_t word_number) const {
    const uint32_t* pointer = &(RAWBUFF32[word_number + rawconfname::WORD_Char]);
    return BITFIELDGET(*pointer, rawconfname::MASK_Char4, rawconfname::SHIFT_Char4);
}


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

    os<<boost::format("\n---RawConfigurationName----------------------------------------------------size=%u\n") % sizeofdata();

    printBuffer(os,true,true,false,false,false,"\n",1);
    
    std::string name;
    EXECUTE_FUNCTION(getName)(name);
    os<<"Name = \""<<name<<"\"\n";

}

//------------------------------------------------------------------------------
// Size of the _Buffer in words
uint32_t RawConfigurationName::sizeofdata()const { return getSize();}


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

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

   _function_sizeofdata = (sizeofdata_t) &RawConfigurationName::sizeofdata;
   return true;
}


//------------------------------------------------------------------------------
// This is a general method to read the microslice from millislice_buffer to _Buffer
void* RawConfigurationName::readData(const void* buffer){
    const uint32_t header_size = EXECUTE_FUNCTION(getHeaderSize)();

    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 0");
    /// Read the header and unpack it to find out the size of the RawConfigurationName
    void* buffer_new = readDataGeneral(buffer, header_size, 0);

    /// No need to check for internalness here, because we always have at least a header

    PRINT_ON_DEBUG(__PRETTY_FUNCTION__<<" 1");
    /// Now, read the rest of the millislice
    buffer_new       = readDataGeneral(buffer_new, sizeofdata() - header_size, header_size);

    checkBufferInternalness();

    return buffer_new;

 }// end of readData(void*)

}}// end of namespaces