AssociationObjectIterator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifdef ASSOCIATIONMAP_CONTEXT 
 
class AssociationObjectIterator 
{ 
public: 
 
AssociationObjectIterator() : m_store(0) 
{ }
 
AssociationObjectIterator(const store_type& theStore)
  : m_store(&theStore) 
  , m_actual(theStore.begin())
{ }
 
AssociationObjectIterator(const store_type& theStore, 
              const typename store_type::const_iterator& pos)
  : m_store(&theStore) 
  , m_actual(pos)
{ }
 
AssociationObjectIterator(const AssociationObjectIterator& rhs) :
  m_store ( rhs.m_store ),
  m_actual( rhs.m_actual )
{}
 
AssociationObjectIterator& operator=(const AssociationObjectIterator& rhs)
{
  if ( this != &rhs ) {
    m_store = rhs.m_store;
    m_actual= rhs.m_actual;
  }
  return *this;
}
 
~AssociationObjectIterator() 
{ }
 
AssociationObjectIterator begin() 
{ return AssociationObjectIterator(*m_store); }
 
AssociationObjectIterator end()
{ return AssociationObjectIterator(*m_store, m_store->end()); }
 
AssociationObjectIterator begin() const
{ return AssociationObjectIterator(*m_store); }
AssociationObjectIterator end() const
{ return AssociationObjectIterator(*m_store,m_store->end()); }
 
AssociationObjectIterator next()
{ ++m_actual; return *this; }
 
AssociationObjectIterator prev()
{ --m_actual; return *this; }
 
AssociationObjectIterator operator++()    
{ 
  AssociationObjectIterator tmp(*this); 
  ++m_actual;
  return tmp;
}
 
AssociationObjectIterator operator++(int) { return this->next(); }
 
AssociationObjectIterator operator--()    
{ 
  AssociationObjectIterator tmp(*this);
  --m_actual;
  return tmp;
}
 
AssociationObjectIterator operator--(int) { return this->prev(); }
bool operator==(const AssociationObjectIterator& anOther) const
{ return m_actual == anOther.m_actual; } 
// bool operator==(AssociationObjectIterator& anOther)
// { return m_actual == anOther.m_actual; } 
bool operator!=(const AssociationObjectIterator& anOther) const
{ return m_actual != anOther.m_actual; }
// bool operator!=(AssociationObjectIterator& anOther)
// { return m_actual != anOther.m_actual; }
AssociationObjectIterator operator*() const { return *this; }
 
const object_type* operator->() 
{ return this->getObject(); }
 
const object_type* operator->() const 
{ return this->getObject(); }
 
const object_type*  first()  const { return *(m_actual->first); }
asso_iterator       second() const 
{ return asso_iterator(m_actual->second,m_actual->second.begin()); }
AssociationObjectIterator find(const object_type* objectPointer) const
{
  const AssociationObjectIterator lastObj = this->end();
  AssociationObjectIterator firstObj = this->begin();
  AssociationObjectIterator foundObj = lastObj;
  while (firstObj != lastObj )
    {
      if ( firstObj.isValid() && firstObj.getObject() == objectPointer )
    {
      foundObj = firstObj;
      firstObj = lastObj;
    }
      else
    {
      ++firstObj;
    }
    }
  return foundObj;
}
const object_type*  getObject()     const { return this->first(); }
 
const object_link&  getObjectLink() const { return m_actual->first; }
 
bool  isValid()     const { return this->m_actual->first.isValid(); }
 
asso_iterator getFirstAssociation() const 
{ 
  return asso_iterator(m_actual->second, m_actual->second.begin()); 
}
 
asso_iterator getLastAssociation()  const 
{ 
  return asso_iterator(m_actual->second, m_actual->second.end()); 
}
 
asso_iterator findAssociation(const asso_type* assoPointer) const
{ 
  asso_iterator assItr = asso_iterator(m_actual->second,
                       m_actual->second.begin());
  return assItr.find(assoPointer); 
}
 
bool containsAssociation(const asso_type* assoPointer) const
{ return this->findAssociation(assoPointer) != this->getLastAssociation(); }
 
size_t getNumberOfAssociations() const
{ return m_actual->second.size(); }
 
size_t size() const { return m_store->size(); }
 
private:
 
  const store_type* m_store;
  typename store_type::const_iterator m_actual;
};
#endif