AssociationMap.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHLINKS_ASSOCIATIONMAP_H
#define ATHLINKS_ASSOCIATIONMAP_H
 
#define ASSOCIATION_CONTEXT
#define ASSOCIATIONMAP_CONTEXT
 
#include "AthLinks/ElementLink.h"
#include "AthLinks/ElementLinkVector.h"
#include "AthLinks/tools/GenerateIndexingPolicy.h"
 
#include <map>
#include <list>
#include <algorithm>
 
template<class OBJCONT,class ASSCONT>
class AssociationMap
{
 public:
  
  typedef OBJCONT                                       object_container_type;
  typedef typename object_container_type::base_value_type         object_type;
  typedef 
    typename 
    SG::GenerateIndexingPolicy<object_container_type>::type::index_type
                                                            object_index_type;
  typedef ElementLink<object_container_type>                      object_link;
  typedef typename std::list<const object_type*>                  object_list;
 
  typedef ASSCONT                                         asso_container_type;
  typedef typename asso_container_type::base_value_type             asso_type;
  typedef 
    typename 
    SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
                                                              asso_index_type;
  typedef typename std::list<const asso_type*>                      asso_list;
  typedef ElementLink<asso_container_type>                          asso_link;
  typedef ElementLinkVector<asso_container_type>                   asso_store;
  typedef typename asso_store::const_iterator             asso_store_iterator;
  typedef typename std::map<object_link,asso_store>                store_type;
  typedef typename store_type::iterator                   store_iterator_type;
  // Dummy to allow defining an end iterator for an empty map.
  static const asso_store s_dum_asso_store;
 
  AssociationMap(); 
  virtual ~AssociationMap();
#include "AthLinks/tools/AssociationVectorIterator.h"
  typedef AssociationVectorIterator                              asso_iterator;
#include "AthLinks/tools/AssociationObjectIterator.h"
  typedef AssociationObjectIterator                            object_iterator;
  void addAssociation(const object_container_type* objectContainer,
              const object_index_type&     objectIndex,
              const asso_container_type*   assoContainer,
              const asso_index_type&       assoIndex);
  void addAssociation(const object_container_type* objectContainer,
              const object_type*           objectPointer,
              const asso_container_type*   assoContainer,
              const asso_type*             assoPointer);
  void addAssociation(const object_link& objectLink,
                      const asso_link& assoLink);
  object_iterator beginObject()  const;
  object_iterator endObject()   const;
 
  asso_iterator beginAssociation(const object_type* objectPointer)  const;
  asso_iterator beginAssociation(const object_iterator& objectIter) const;
  asso_iterator endAssociation(const object_type* objectPointer)    const;
  asso_iterator endAssociation(const object_iterator& objectIter)   const;
 
 
 
  const object_type* getObject(const object_iterator& objectIter) const
    { return (*objectIter).getObject(); }
 
  object_iterator findObject(const object_type* theObject) const
    { return object_iterator(m_associationMap).find(theObject); }
 
  bool containsObject(const object_type* theObject) const
    { return this->findObject(theObject) != this->endObject(); }
 
  size_t getNumberOfObjects() const { return this->size(); }
 
 
 
  const asso_type* getAssociation(asso_iterator assoIter) const
    { return *assoIter; }
 
  asso_iterator findAssociation(const object_iterator& objectIter,
                const asso_type* assoPointer) const
    { return objectIter.findAssociation(assoPointer); }
  asso_iterator findAssociation(const object_type* objectPointer,
                const asso_type* assoPointer) const;
 
  bool containsAssociation(const object_iterator& objectIter,
               const asso_type* assoPointer) const
    { return objectIter.containsAssociation(assoPointer); }
 
  bool containsAssociation(const object_type* objectPointer,
               const asso_type* assoPointer) const;
  bool containsAssociation(const asso_type* assoPointer) const;
 
  bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
 
  bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
    { return this->getObjects(*assoIter,theObjects); }
 
  bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
 
  bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
    { return this->getAssociations(objIter.getObject(),assocs); }
 
  size_t size() { return m_associationMap.size(); }
 
  size_t size() const { return m_associationMap.size(); }
 
  size_t size(const object_type* objectPointer) const;
 
  size_t getNumberOfAssociations(const object_type* objectPointer) const
    { return this->size(objectPointer); }
 
  size_t size(const object_iterator& objectIter) const
    { return objectIter.getNumberOfAssociations(); }
 
  size_t getNumberOfAssociations(const object_iterator& objectIter) const
    { return this->size(objectIter); }
 
 protected:
 
  store_type m_associationMap;
 
  store_iterator_type internalFind(const object_link& objectLink,
                   const asso_link& assoLink)
    {
      // check key
      store_iterator_type mapEnd    = m_associationMap.end();
      store_iterator_type foundIter = mapEnd;
      for ( store_iterator_type iMap = m_associationMap.begin();
        iMap != mapEnd;
        ++iMap ) {
    // look for the address of the pointed-at object 
    // must dereference the ElementLink pointer
    if ( iMap->first.cptr() == objectLink.cptr() ) {
      foundIter = iMap;
      break;
    }
      }
      
      if ( foundIter == m_associationMap.end() ) { return foundIter; }
      // check data
      if ( std::find((foundIter->second).begin(),
             (foundIter->second).end(),
             assoLink) !=
       (foundIter->second).end() )
    { return foundIter; }
      // not found at all
      return m_associationMap.end();
    }
 
  bool addToStore(const object_link& objectLink, const asso_link& assoLink);
 
};
 
#include "AthLinks/AssociationMap.icc"
 
#undef ASSOCIATION_CONTEXT
#undef ASSOCIATIONMAP_CONTEXT
#endif