In This Package:

TemporalObjectVector.h

Go to the documentation of this file.

#ifndef DATAUTILITIES_TEMPORALOBJECTVECTOR_H
#define DATAUTILITIES_TEMPORALOBJECTVECTOR_H


// Include files
#include "GaudiKernel/ObjectVector.h"
#include "Event/ITemporal.h"

template <class TYPE>
class TemporalObjectVector : public ObjectVector<TYPE>, 
                             virtual public DayaBay::ITemporal
{
 public:

  TemporalObjectVector() : m_earliest(TimeStamp::GetEOT()),
    m_latest(TimeStamp::GetBOT()) {}
  
  virtual ~TemporalObjectVector() {}
  
  virtual std::ostream& fillStream(std::ostream& s) const;
  
  virtual const TimeStamp& earliest() const;
  
  void setEarliest(const TimeStamp& value);
  
  const TimeStamp& latest() const;
  
  void setLatest(const TimeStamp& value);
  
  virtual long add(ContainedObject* pObject);
  
#ifndef _WIN32
  static void* operator new ( size_t size )
    {
      return ( sizeof(TemporalObjectVector) == size ? 
               boost::singleton_pool<TemporalObjectVector, sizeof(TemporalObjectVector)>::malloc() :
               ::operator new(size) );
    }
  
  static void* operator new ( size_t size, void* pObj )
    {
      return ::operator new (size,pObj);
    }
  
  static void operator delete ( void* p )
    {
      boost::singleton_pool<TemporalObjectVector, sizeof(TemporalObjectVector)>::is_from(p) ?
        boost::singleton_pool<TemporalObjectVector, sizeof(TemporalObjectVector)>::free(p) :
        ::operator delete(p);
    }
  
  static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
#endif
 protected:
  
 private:
  
  TimeStamp m_earliest; 
  TimeStamp m_latest;   
  
}; // class TemporalObjectVector

template <class TYPE>
std::ostream& TemporalObjectVector<TYPE>::fillStream(std::ostream& s) const
{
  DayaBay::ITemporal::fillStream(s);
  s << "{ " << "earliest :      " << m_earliest << std::endl
            << "latest :        " << m_latest << std::endl << " }";
  return s;
}


template <class TYPE>
const TimeStamp& TemporalObjectVector<TYPE>::earliest() const 
{
  return m_earliest;
}

template <class TYPE>
void TemporalObjectVector<TYPE>::setEarliest(const TimeStamp& value) 
{
  m_earliest = value;
}

template <class TYPE>
const TimeStamp& TemporalObjectVector<TYPE>::latest() const 
{
  return m_latest;
}

template <class TYPE>
void TemporalObjectVector<TYPE>::setLatest(const TimeStamp& value) 
{
  m_latest = value;
}

template <class TYPE>
long TemporalObjectVector<TYPE>::add(ContainedObject* pObject)
{
  try {
    long result = ObjectVector<TYPE>::add(pObject);
    if (-1 == result) {
      return result;
    }

    ITemporal* temporal = dynamic_cast<ITemporal*>(pObject);
    if (0 != temporal) {
      if (temporal->earliest() < earliest()) {
        setEarliest(temporal->earliest());
      }
      if (temporal->latest() > latest()) {
        setLatest(temporal->latest());
      }
    }

    return result;
  }
  catch (...) {
  }
  return -1;
}

#endif    // DATAUTILITIES_TEMPORALOBJECTVECTOR_H

---