AssociationObjectIterator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 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