In This Package:

HeaderObject.cc

Go to the documentation of this file.

#include "Event/HeaderObject.h"

DayaBay::HeaderObject::~HeaderObject()
{
    const DayaBay::IHeader         *pIHeader;
    const DayaBay::HeaderObject    *pHeaderObj;
    DayaBay::HeaderObject          *pNonConst;
    
    //inputHeaders may live in a different time frame
    //This will improve the robustness of the code.
    //pull method and I/O will need this.
    for(size_t ind=0;ind<m_inputHeaders.size();ind++) {
        pIHeader=m_inputHeaders[ind];
        try{
            pHeaderObj=dynamic_cast<const DayaBay::HeaderObject*>(pIHeader);
            pNonConst=const_cast<DayaBay::HeaderObject*>(pHeaderObj);
        }
        catch(...) {
            // output something
        }
        pNonConst->release();
    }
    m_inputHeaders.clear();
}

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

    s << "{ " 
      << "context :     " << m_context << std::endl
      << "execNumber :  " << m_execNumber << std::endl
      << "jobId :       " << m_jobId.uuid() << std::endl;

    s << "randomState : [";
    for (size_t ind=0; ind<m_randomState.size(); ++ind) {
        s << " " << m_randomState[ind];
    }
    s << " ]" << std::endl;

    size_t siz = m_inputHeaders.size();
    s << "inputHeaders :\t" << siz << ": [\n";
    for (size_t ind=0; ind<siz; ++ind) {
        m_inputHeaders[ind]->fillStream(s);
    }
    s << "\n]\n}";
    return s;
}

const TimeStamp& DayaBay::HeaderObject::timeStamp() const
{
    return m_context.GetTimeStamp();
}

void DayaBay::HeaderObject::setTimeStamp(const TimeStamp& ts)
{
    m_context.SetTimeStamp(ts);
}

void DayaBay::HeaderObject::setInputHeaders(const std::vector<const DayaBay::IHeader*>& iheaders)
{
    const DayaBay::IHeader         *pIHeader;
    const DayaBay::HeaderObject    *pHeaderObj;
    DayaBay::HeaderObject          *pNonConst;

    // release the old ones first if they exist
    for(size_t ind=0;ind<m_inputHeaders.size();ind++) {
        pIHeader=m_inputHeaders[ind];
        try{
            pHeaderObj=dynamic_cast<const DayaBay::HeaderObject*>(pIHeader);
            pNonConst=const_cast<DayaBay::HeaderObject*>(pHeaderObj);
        }
        catch(...) {
            // output something
        }
        pNonConst->release();
    }
    m_inputHeaders.clear();

    // then set the new one
    m_inputHeaders = iheaders;

    //inputHeaders may live in a different time frame
    //This will improve the robustness of the code. 
    //pull method and I/O will need this.
    for(size_t ind=0;ind<m_inputHeaders.size();ind++) {
        pIHeader=m_inputHeaders[ind];
        try{
            pHeaderObj=dynamic_cast<const DayaBay::HeaderObject*>(pIHeader);
            pNonConst=const_cast<DayaBay::HeaderObject*>(pHeaderObj);
        }
        catch(...){
            // output something
        }       
        pNonConst->addRef();
    }
}

void DayaBay::HeaderObject::addInputHeader(const DayaBay::IHeader* iheader)
{
    // Append this input header
    m_inputHeaders.push_back(iheader);

    // Add a reference to ensure this object is not prematurely deleted
    const DayaBay::HeaderObject    *pHeaderObj;
    DayaBay::HeaderObject          *pNonConst;
    try{
      pHeaderObj=dynamic_cast<const DayaBay::HeaderObject*>(iheader);
      pNonConst=const_cast<DayaBay::HeaderObject*>(pHeaderObj);
    }
    catch(...){
      // output something
    }       
    pNonConst->addRef();

}


const std::vector<const DayaBay::IHeader*> DayaBay::HeaderObject::findHeaders(const CLID& clid) const
{
  // This is for output
  std::vector<const DayaBay::IHeader*> iHeaders;
  // By default, nothing found
  iHeaders.clear();
  
  const DayaBay::IHeader* pIH;
  const DayaBay::HeaderObject* pHO;
  std::vector<const DayaBay::IHeader*> grandparents;
  std::vector<const DayaBay::IHeader*>::const_iterator cit;

  // Searching in the immediate parent level
  for( size_t ind=0; ind<m_inputHeaders.size(); ind++ ) {

    pIH = m_inputHeaders[ind];
    pHO = dynamic_cast< const DayaBay::HeaderObject* > (pIH);

    if( pHO->clID()==clid ) {
      // check for duplications
      cit = find( iHeaders.begin(), iHeaders.end(), pIH );
      if( cit==iHeaders.end() ) {
        // add it to output
        iHeaders.push_back(pIH);
      }
    }

    // Searching in the grandparents level
    grandparents = pHO->findHeaders( clid );

    for( size_t idx=0; idx<grandparents.size(); idx++ ) {
      pIH = grandparents[idx];
      // Check for duplications
      cit = find( iHeaders.begin(), iHeaders.end(), pIH );
      if( cit==iHeaders.end() ) {
        // Not find, then add it.
        iHeaders.push_back(pIH);
      }
    }
  }

  return iHeaders;
}

---