CondMultChanCollection.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef DBDATAOBJECTS_CONDMULTCHANCOLLECTION_H
# define DBDATAOBJECTS_CONDMULTCHANCOLLECTION_H 
 
//<<<<<< INCLUDES                                                       >>>>>>
 
#include "AthenaPoolUtilities/CondMultChanCollImpl.h"
#include "AthContainers/DataVector.h"
#include "AthenaKernel/IOVRange.h"
#include <vector>

 
template <typename T>
class CondMultChanCollection : public DataVector<T>
{
public:
 
    typedef unsigned int                           ChanNum;
    typedef std::vector<ChanNum>                   ChanVec;
    typedef std::vector<IOVRange>                  IOVVec;
    typedef typename ChanVec::const_iterator       chan_const_iterator;
    typedef typename ChanVec::iterator             chan_iterator;
    typedef typename ChanVec::size_type            chan_size_type;
    typedef typename IOVVec::const_iterator        iov_const_iterator;
    typedef typename IOVVec::iterator              iov_iterator;
    typedef typename IOVVec::size_type             iov_size_type;
    
    CondMultChanCollection();

    chan_const_iterator         chan_begin() const;
    chan_const_iterator         chan_end  () const;
    
    chan_size_type              chan_size() const;
    
    iov_const_iterator          iov_begin() const;
    iov_const_iterator          iov_end  () const;
    
    iov_size_type               iov_size() const;

    IOVRange                    minRange() const;

    bool                        hasUniqueIOV() const;

    void                        add(ChanNum chanNum);

    void                        add(const IOVRange& range);

    void                        addNewStop(const IOVTime& stop);

    virtual StatusCode          initialize();

    void                        resetChannelNumbers();

    CondMultChanCollImpl*       implementation();
 
private:
 
    CondMultChanCollImpl  m_impl;
};
 
//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
//<<<<<< INLINE MEMBER FUNCTIONS                                        >>>>>>
 
 
template <typename T>
inline
CondMultChanCollection<T>::CondMultChanCollection()
    :
    DataVector<T>::DataVector()
{}

template <typename T>
inline 
typename CondMultChanCollection<T>::chan_const_iterator
CondMultChanCollection<T>::chan_begin() const
{
    return (m_impl.chan_begin());
}
 
template <typename T>
inline 
typename CondMultChanCollection<T>::chan_const_iterator 
CondMultChanCollection<T>::chan_end  () const
{
    return (m_impl.chan_end());
}

template <typename T>
inline 
typename CondMultChanCollection<T>::chan_size_type
CondMultChanCollection<T>::chan_size() const
{
    return (m_impl.chan_size());
}
 

template <typename T>
inline 
typename CondMultChanCollection<T>::iov_const_iterator
CondMultChanCollection<T>::iov_begin() const
{
    return (m_impl.iov_begin());
}
 
template <typename T>
inline 
typename CondMultChanCollection<T>::iov_const_iterator
CondMultChanCollection<T>::iov_end  () const
{
    return (m_impl.iov_end());
}
    
template <typename T>
inline 
typename CondMultChanCollection<T>::iov_size_type 
CondMultChanCollection<T>::iov_size() const
{
    return (m_impl.iov_size());
}

template <typename T>
inline 
IOVRange
CondMultChanCollection<T>::minRange() const
{
    return (m_impl.minRange());
}

template <typename T>
inline 
bool
CondMultChanCollection<T>::hasUniqueIOV() const
{
    return (m_impl.hasUniqueIOV());
}

template <typename T>
inline 
void                    
CondMultChanCollection<T>::add(ChanNum chanNum)
{
    m_impl.add(chanNum);
}

template <typename T>
inline 
void                    
CondMultChanCollection<T>::add(const IOVRange& range)
{
    m_impl.add(range);
}

template <typename T>
inline 
void                    
CondMultChanCollection<T>::addNewStop(const IOVTime& stop)
{
    m_impl.addNewStop(stop);
}

template <typename T>
inline 
StatusCode 
CondMultChanCollection<T>::initialize() 
{
    return (StatusCode::SUCCESS);
}

template <typename T>
inline 
void 
CondMultChanCollection<T>::resetChannelNumbers()
{
    m_impl.resetChannelNumbers();
}

template <typename T>
inline 
CondMultChanCollImpl*
CondMultChanCollection<T>::implementation()
{
    return &m_impl;
}
 
 
 
#endif // DBDATAOBJECTS_CONDMULTCHANCOLLECTION_H