DataLinkVector.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EVENTCONTAINERS_DATALINKVECTOR_H
#define EVENTCONTAINERS_DATALINKVECTOR_H
 
#include "GaudiKernel/DataObject.h" 
#include <vector>
 
 
template < class DC >
class DataLinkVector :public DataObject 
{
public:
 
    typedef DC                      value_type;
    typedef DC*                     pointer;
    typedef const DC*               const_pointer;
    typedef DC&                     reference;
    typedef const DC&               const_reference;
 
    class DataHolder 
    {
    public:
        DataHolder();
 
        bool            hasData() const;
        
        const_pointer   operator->() const;
 
        operator        const_pointer () const { return this->getDataPtr(); }
 
        const_pointer   cptr() const;
 
        void            reset();
        
        void            setDataPtr(const DC* obj);
        
        pointer         getDataPtr() const;
        
    private:
 
        pointer         m_obj;
    };
        
 
    typedef DataHolder         DataLinkT;
    typedef DataLinkVector<DC> MyType;
 
    class Entry
    {
    public:
        Entry();
 
        Entry& operator = (const Entry& e);
 
        Entry*             previousEntry();
 
        DataLinkT&         dataLink();
 
        bool               ownObject() const;
 
        void               setPreviousEntry(Entry* entry);
        
        void               setDataLink    (const DataLinkT& link);
 
        void               setOwnObject(bool owns);
 
    private:
        Entry*    m_previousEntry;
        DataLinkT m_dataLink;
        // ownObject is true if this object should be deleted by DLV.
        // May be false if object is managed by a data pool
        bool      m_ownObject;
    }; 
    typedef std::vector<Entry> EntryVector;
    typedef typename EntryVector::iterator EntryVectorIt; 
 
    class iterator
    {
    public:
        iterator();
            
        bool operator != ( const iterator it ) const;
            
        bool operator == ( const iterator it ) const;
            
        iterator& operator = ( const iterator it );
            
        iterator& operator ++ ();
            
        iterator operator ++ ( int );
            
        DataLinkT& operator * ();
            
        DataLinkT* operator-> ();
            
        bool hasData();
 
    protected:
        friend class DataLinkVector<DC>;
 
        iterator( const MyType* dlv, 
                  EntryVectorIt it );
            
 
        void checkChain();
            
        EntryVector& entryVector();
 
        const MyType* m_dlv;
        EntryVectorIt m_it;
    };
 
    friend class iterator;
 
 
    DataLinkVector();
    
    ~DataLinkVector();
    
    void init( unsigned int nbr );
    
    iterator begin() const;
    
    iterator end() const;
    
    iterator find( IdentifierHash id ) const;
    
    bool setObjectOwnership(IdentifierHash idhash, bool flag);
    
    DataLinkT& operator [] ( int id );
 
    virtual void cleanup();
 
    int size() const;
    
protected:
 
    void chainEntry( Entry* e ) const;
        
    mutable EntryVector m_vect;
    mutable Entry* m_last;
};
 
 
template <class DC>
DataLinkVector<DC>::DataHolder::DataHolder()
        :
        m_obj(0)
{}
 
template <class DC>
bool
DataLinkVector<DC>::DataHolder::hasData() const
{
    return (m_obj != 0);
}
 
template <class DC>
typename DataLinkVector<DC>::const_pointer 
DataLinkVector<DC>::DataHolder::operator->() const 
{ 
    return this->getDataPtr(); 
}
 
template <class DC>
typename DataLinkVector<DC>::const_pointer 
DataLinkVector<DC>::DataHolder::cptr() const 
{ 
    return this->getDataPtr(); 
}
 
template <class DC>
void
DataLinkVector<DC>::DataHolder::reset()
{
    m_obj = 0;
}
        
template <class DC>
void
DataLinkVector<DC>::DataHolder::setDataPtr(const DC* obj)
{
    m_obj = const_cast<pointer>(obj);
}
 
template <class DC>
typename DataLinkVector<DC>::pointer 
DataLinkVector<DC>::DataHolder::getDataPtr() const
{
    return (m_obj);
}
 
template <class DC>
DataLinkVector<DC>::Entry::Entry()
        : 
        m_previousEntry(NULL), 
        m_ownObject(false)
{
    m_dataLink =  DataLinkT(); 
}
 
template <class DC>
typename DataLinkVector<DC>::Entry& 
DataLinkVector<DC>::Entry::operator = (const Entry& e){
    m_dataLink        = e.m_dataLink ;
    m_previousEntry   = e.m_previousEntry; 
    m_ownObject       = e.m_ownObject;
    return *this; 
}
 
template <class DC>
typename DataLinkVector<DC>::Entry*             
DataLinkVector<DC>::Entry::previousEntry() 
{
    return m_previousEntry;
}
 
template <class DC>
typename DataLinkVector<DC>::DataLinkT&   
DataLinkVector<DC>::Entry::dataLink() 
{
    return m_dataLink;
}
 
template <class DC>
bool               
DataLinkVector<DC>::Entry::ownObject() const
{
    return m_ownObject;
}
 
template <class DC>
void               
DataLinkVector<DC>::Entry::setPreviousEntry(Entry* entry)
{
    m_previousEntry = entry;
}
        
template <class DC>
void               
DataLinkVector<DC>::Entry::setDataLink    (const DataLinkT& link)
{
    m_dataLink = link;
}
 
template <class DC>
void               
DataLinkVector<DC>::Entry::setOwnObject(bool owns)
{
    m_ownObject = owns;
}
 
 
 
template <class DC>
DataLinkVector<DC>::iterator::iterator()
        : m_dlv(NULL) {}
 
 
template <class DC>
bool
DataLinkVector<DC>::iterator::operator != ( const iterator it ) const
{ return it.m_it != m_it; }
 
template <class DC>
bool 
DataLinkVector<DC>::iterator::operator == ( const iterator it ) const
{ return it.m_it == m_it; }
 
template <class DC>
typename DataLinkVector<DC>::iterator& 
DataLinkVector<DC>::iterator::operator = ( const iterator it ) 
{ m_dlv = it.m_dlv; m_it = it.m_it; return *this; }
 
template <class DC>
typename DataLinkVector<DC>::iterator& 
DataLinkVector<DC>::iterator::operator ++ () 
{ ++m_it; return *this; }
 
template <class DC>
typename DataLinkVector<DC>::iterator 
DataLinkVector<DC>::iterator::operator ++ ( int ) 
{ return iterator( m_dlv, m_it++ ); }
 
template <class DC>
typename DataLinkVector<DC>::DataLinkT& 
DataLinkVector<DC>::iterator::operator * () 
{ checkChain(); return m_it->dataLink(); }
 
template <class DC>
typename DataLinkVector<DC>::DataLinkT* 
DataLinkVector<DC>::iterator::operator-> () 
{ checkChain(); return &m_it->dataLink(); }
 
template <class DC>
bool 
DataLinkVector<DC>::iterator::hasData() 
{   
    // check if DL is valid, and cash the state
    checkChain(); // this entry has been touched.
    Entry& e      = *m_it; 
    bool DL_valid = e.dataLink().hasData(); 
    return DL_valid; 
}
 
template <class DC>
DataLinkVector<DC>::iterator::iterator( const MyType* dlv, 
                                        EntryVectorIt it )
        : m_dlv(dlv), m_it(it) {}  
 
// make sur entry is chained
// If not, add entry to the chain otherwise do nothing because
 
template <class DC>
void
DataLinkVector<DC>::iterator::checkChain()
{ if( m_it->previousEntry() == NULL ) m_dlv->chainEntry( &(*m_it) ) ;  }
 
// protected method for derived class to access m_vect
 
template <class DC>
typename DataLinkVector<DC>::EntryVector& 
DataLinkVector<DC>::iterator::entryVector() 
{
    return m_dlv->m_vect ; 
}
 
// Default constructor
template <class DC>
DataLinkVector<DC>::DataLinkVector() 
        : m_last(NULL) { }
 
// Default constructor
template <class DC>
DataLinkVector<DC>::~DataLinkVector() 
{
    this->cleanup();
}
 
// initialize vector with nbr DataLinks
template <class DC>
void
DataLinkVector<DC>::init( unsigned int nbr )
{
    // fill in vector of Entry
    m_vect.resize(nbr); 
}
 
// return iterator on m_previousEntry entry
template <class DC>
typename DataLinkVector<DC>::iterator
DataLinkVector<DC>::begin() const 
{ return iterator( this, m_vect.begin() ); }
 
// return iterator on after last entry
template <class DC>
typename DataLinkVector<DC>::iterator
DataLinkVector<DC>::end() const 
{ return iterator( this, m_vect.end()); }
 
// return iterator on the found entry or end() if out of range
template <class DC>
typename DataLinkVector<DC>::iterator
DataLinkVector<DC>::find( IdentifierHash id ) const 
{ return ( (id >= m_vect.size() )
           ?end():iterator(this,m_vect.begin()+id));}
 
// set object ownership
template <class DC>
bool
DataLinkVector<DC>::setObjectOwnership(IdentifierHash idhash, bool flag)
{
    if ( idhash >= m_vect.size() )
        return false;
    Entry& e = *(m_vect.begin()+idhash);
    e.setOwnObject(flag);
    return true;
}
    
// return reference on DataLink
// BEWARE: Doesn't check for boundary limits !
template <class DC>
typename DataLinkVector<DC>::DataLinkT&  
DataLinkVector<DC>::operator [] ( int id )
{ 
    Entry* e = &(m_vect[id]);
    if( !e->previousEntry() )
        chainEntry( e );
    return e->dataLink();
}
 
// cleans up the DataLinkVector
// goes trough all chained entries and call clear() method of DataLink
// and clear chain of course.
template <class DC>
void
DataLinkVector<DC>::cleanup()
{
    Entry *e;
    // assign last to e and check if it is not NULL
    if( (e = m_last) )
        {
            // for chained entries
            do {
                Entry * tmp = e->previousEntry();
                e->setPreviousEntry(NULL);  // clear chain pointer
                if (e->ownObject())     // delete object
                    delete (e->dataLink()).getDataPtr();
                e->dataLink().reset(); // reset keeps it in identified state.
                e->setOwnObject(false); // doesn't own object
                e = tmp;    // go to next entry
            } while( e != m_last ); // until we end where we started
            m_last = NULL;  // clear chain hook
        }
}
 
template <class DC>
int
DataLinkVector<DC>::size() const {
    return m_vect.size(); 
}
 
template <class DC>
void
DataLinkVector<DC>::chainEntry( Entry* e ) const 
{
    if( m_last == NULL ) {
        e->setPreviousEntry(e);
        m_last = e;
    }
    else {
        e->setPreviousEntry(m_last->previousEntry());
        m_last->setPreviousEntry(e);
    }
}
    
 
#endif