In This Package:

UserDataHeader.cc

Go to the documentation of this file.

#include "Event/UserDataHeader.h"

#include <iostream>
using namespace std;

DayaBay::UserDataHeader* DayaBay::UserDataHeader::create()
{
    return new UserDataHeader;
}

DayaBay::UserDataHeader::~UserDataHeader()
{
    // cerr << "Destroying UserDataHeader (" << (void*)this << ") "
    //      << "#" << this->execNumber() << " @" << this->timeStamp().AsString() 
    //      << endl;

  // Destructor
  this->clearData();
}

void DayaBay::UserDataHeader::clearData()
{
  for (size_t ind=0; ind<m_data.size(); ++ind) {
    delete m_data[ind];
    m_data[ind]=0;
  }
  m_data.clear();
}

std::ostream& DayaBay::UserDataHeader::fillStream(std::ostream& s) const
{
    HeaderObject::fillStream(s);

    s << "{" << std::endl;
    s << "user-defined data :   [";
    for (size_t ind=0; ind<m_data.size(); ++ind) {
        s << " " << m_data[ind];
    }
    s << " ]" << std::endl;
    s << "}" << std::endl;

    return s;
}


void DayaBay::UserDataHeader::setInt(const std::string& name, 
                                     const int& value)
{
    DayaBay::UserData* data = this->get(name);
    if( !data ) { 
        // If data field doesn't exist, create it
        m_data.push_back( new DayaBay::UserInt(name, value) );
        return;
    }
    if(data->type() != DayaBay::UserData::Int){
        // Error! Wrong data type   // <-- passive-aggressive comment
        return;
    }
    // If data field exists, reset value
    (dynamic_cast<DayaBay::UserInt*>(data))->setValue( value );
}

void DayaBay::UserDataHeader::setIntArray(const std::string& name, 
                                          const std::vector<int>& value)
{
    DayaBay::UserData* data = this->get(name);
    if(!data ){ 
        // If data field doesn't exist, create it
        m_data.push_back( new DayaBay::UserIntArray(name, value) );
        return;
    }
    if(data->type() != DayaBay::UserData::IntArray){
        // Error! Wrong data type
        return;
    }
    // If data field exists, reset value
    (dynamic_cast<UserIntArray*>(data))->setValue( value );
}


void DayaBay::UserDataHeader::setFloat(const std::string& name, 
                                       const float& value)
{
    DayaBay::UserData* data = this->get(name);
    if( !data ){ 
        // If data field doesn't exist, create it
        m_data.push_back( new DayaBay::UserFloat(name, value) );
        return;
    }
    if(data->type() != DayaBay::UserData::Float){
        // Error! Wrong data type
        return;
    }
    // If data field exists, reset value
    (dynamic_cast<DayaBay::UserFloat*>(data))->setValue( value );
}

void DayaBay::UserDataHeader::setFloatArray(const std::string& name, 
                                            const std::vector<float>& value)
{
    DayaBay::UserData* data = this->get(name);
    if(!data ){ 
        // If data field doesn't exist, create it
        m_data.push_back( new DayaBay::UserFloatArray(name, value) );
        return;
    }
    if(data->type() != DayaBay::UserData::FloatArray){
        // Error! Wrong data type
        return;
    }
    // If data field exists, reset value
    (dynamic_cast<UserFloatArray*>(data))->setValue( value );
}

int DayaBay::UserDataHeader::getInt(const std::string& name, int def)
{
    DayaBay::UserData* data = this->get(name);

    if (!data) { return def; }
    if (data->type() != DayaBay::UserData::Int) { return def; }

    return (dynamic_cast<DayaBay::UserInt*>(data))->value();
}

std::vector<int> DayaBay::UserDataHeader::getIntArray(const std::string& name)
{
    DayaBay::UserData* data = this->get(name);

    if (!data) { return std::vector<int>(); }
    if (data->type() != DayaBay::UserData::IntArray) { 
        return std::vector<int>(); 
    }

    return (dynamic_cast<DayaBay::UserIntArray*>(data))->value();
}

float DayaBay::UserDataHeader::getFloat(const std::string& name, float def)
{
    DayaBay::UserData* data = this->get(name);

    if (!data) { return def; }
    if (data->type() != DayaBay::UserData::Float) { return def; }

    return (dynamic_cast<DayaBay::UserFloat*>(data))->value();
}

std::vector<float> DayaBay::UserDataHeader::getFloatArray(const std::string& name)
{
    DayaBay::UserData* data = this->get(name);

    if (!data) { return std::vector<float>(); }
    if (data->type() != DayaBay::UserData::FloatArray) { 
        return std::vector<float>(); 
    }

    return (dynamic_cast<DayaBay::UserFloatArray*>(data))->value();
}

---