ATLAS Offline Software
Loading...
Searching...
No Matches
List of all members
AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator Class Reference

code only expands with the ASSOCIATIONMAP_CONTEXT More...

#include <AssociationMap.h>

Collaboration diagram for AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator:

Public Member Functions

Constructors and Destructor
 AssociationObjectIterator ()
 default constructor
 AssociationObjectIterator (const store_type &theStore)
 useful alternate constructor
 AssociationObjectIterator (const store_type &theStore, const typename store_type::const_iterator &pos)
 useful alternate constructor
 AssociationObjectIterator (const AssociationObjectIterator &rhs)
 copy constructor
AssociationObjectIterator & operator= (const AssociationObjectIterator &rhs)
 assignment operator
 ~AssociationObjectIterator ()
 default destructor
Iterator Manipulation
AssociationObjectIterator begin ()
 begin object iterator
AssociationObjectIterator end ()
 end object iterator
AssociationObjectIterator begin () const
AssociationObjectIterator end () const
 end object iterator
AssociationObjectIterator next ()
 forward advancement
AssociationObjectIterator prev ()
 backward stepping
AssociationObjectIterator operator++ ()
 post-forward advancement operator
AssociationObjectIterator operator++ (int)
 pre-forward advancement operator
AssociationObjectIterator operator-- ()
 post-backward stepping operator
AssociationObjectIterator operator-- (int)
 pre-backward stepping operator
Iterator Comparisons
bool operator== (const AssociationObjectIterator &anOther) const
 equality comparison
bool operator!= (const AssociationObjectIterator &anOther) const
 inequality comparison

Data Access

const store_type * m_store {}
store_type::const_iterator m_actual {}
AssociationObjectIterator operator* () const
 * operator returns iterator by value
const object_type * operator-> ()
 access to underlying object
const object_type * operator-> () const
 access to underlying object
const object_type * first () const
 access to object pointer
asso_iterator second () const
 access to iterator of first association
AssociationObjectIterator find (const object_type *objectPointer) const
 find a given object in store
const object_type * getObject () const
 retrieve the pointer to a given object
const object_link & getObjectLink () const
 retrieve link to the object.
bool isValid () const
asso_iterator getFirstAssociation () const
 retrieve iterator to first associated object
asso_iterator getLastAssociation () const
 retrieve end iterator to internal associated object store
asso_iterator findAssociation (const asso_type *assoPointer) const
 find the iterator for a given object
bool containsAssociation (const asso_type *assoPointer) const
 check if the given object can be matched among the associated objects
size_t getNumberOfAssociations () const
 get number of association for current pointed-to object
size_t size () const

Detailed Description

template<class OBJCONT, class ASSCONT>
class AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator

code only expands with the ASSOCIATIONMAP_CONTEXT

The AssociationObjectIterator protects the AssociationMap class from specifics of the internal look-up map.

object iterator for association maps (internal use only!)


This is not a stand-alone class. It can only be compiled within the AssociationMap class, or similar classes providing the required type definitions!

Author
Peter Loch loch@.nosp@m.phys.nosp@m.ics.a.nosp@m.rizo.nosp@m.na.ed.nosp@m.u
Date
June 2, 2004 - first implementation

fn AssociationObjectIterator begin() brief begin object iterator

fn AssociationObjectIterator end() brief end object iterator

fn AssociationObjectIterator next() brief advances iterator forward

fn AssociationObjectIterator prev() brief steps iterator back

fn AssociationObjectIterator operator++() brief same as next()

fn AssociationObjectIterator operator++(int) brief same as next()

fn AssociationObjectIterator operator--() brief same as prev()

fn AssociationObjectIterator operator--(int) brief same as prev()

fn bool operator==(const AssociationObjectIterator&) brief equality comparator

fn bool operator!=(const AssociationObjectIterator&) brief inequality comparator

fn AssociationObjectIterator operator*() brief iterator value access operator

var const object_type* first brief public variable holding object pointer

var asso_iterator second brief public variable holding iterator to associations

fn AssociationObjectIterator find(const object_type*) brief returns iterator for a given object

fn const object_type* getObject() brief get pointer to object (same as first )

fn const object_link& getObjectLink() brief get link to object

fn asso_iterator getFirstAssociation() brief get iterator to first association (same as second.begin() )

fn asso_iterator getLastAssocation() brief get end iterator for associations (same as second.end() )

fn asso_iterator findAssociation(const asso_type*) brief returns iterator for specific associated object

fn bool containsAssociation(const asso_type*) brief checks if given object is associated with current object

fn size_t size() brief number of associations for current object

Definition at line 89 of file AssociationMap.h.

Constructor & Destructor Documentation

◆ AssociationObjectIterator() [1/4]

template<class OBJCONT, class ASSCONT>
AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::AssociationObjectIterator ( )
inline

default constructor

Definition at line 96 of file AssociationMap.h.

◆ AssociationObjectIterator() [2/4]

template<class OBJCONT, class ASSCONT>
AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::AssociationObjectIterator ( const store_type & theStore)
inline

useful alternate constructor

Parameters
theStore- reference to association map

Definition at line 103 of file AssociationMap.h.

◆ AssociationObjectIterator() [3/4]

template<class OBJCONT, class ASSCONT>
AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::AssociationObjectIterator ( const store_type & theStore,
const typename store_type::const_iterator & pos )
inline

useful alternate constructor

Parameters
theStore- reference to association map
pos- reference to a position in the association map

Definition at line 113 of file AssociationMap.h.

◆ AssociationObjectIterator() [4/4]

template<class OBJCONT, class ASSCONT>
AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::AssociationObjectIterator ( const AssociationObjectIterator & rhs)
inline

copy constructor

Definition at line 121 of file AssociationMap.h.

◆ ~AssociationObjectIterator()

template<class OBJCONT, class ASSCONT>
AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::~AssociationObjectIterator ( )
inline

default destructor

Definition at line 138 of file AssociationMap.h.

Member Function Documentation

◆ begin() [1/2]

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::begin ( )
inline

begin object iterator

Definition at line 146 of file AssociationMap.h.

147 { return this->size(); }
AssociationMap::size
size_t size()
get number of associations
Definition AssociationMap.h:188

◆ begin() [2/2]

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::begin ( ) const
inline

Definition at line 153 of file AssociationMap.h.

◆ containsAssociation()

template<class OBJCONT, class ASSCONT>
bool AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::containsAssociation ( const asso_type * assoPointer) const
inline

check if the given object can be matched among the associated objects

Definition at line 297 of file AssociationMap.h.

335{
336 public:
337
340 typedef OBJCONT object_container_type;
341 typedef typename object_container_type::base_value_type object_type;
342 typedef
343 typename
344 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
345 object_index_type;
346 typedef ElementLink<object_container_type> object_link;
347 typedef typename std::list<const object_type*> object_list;
348
349 typedef ASSCONT asso_container_type;
350 typedef typename asso_container_type::base_value_type asso_type;
351 typedef
352 typename
353 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
354 asso_index_type;
355 typedef typename std::list<const asso_type*> asso_list;
356 typedef ElementLink<asso_container_type> asso_link;
357 typedef ElementLinkVector<asso_container_type> asso_store;
358 typedef typename asso_store::const_iterator asso_store_iterator;
359 typedef typename std::map<object_link,asso_store> store_type;
360 typedef typename store_type::iterator store_iterator_type;
362
363 // Dummy to allow defining an end iterator for an empty map.
364 static const asso_store s_dum_asso_store;
365
368 AssociationMap();
369 virtual ~AssociationMap();
371
372
375#include "AthLinks/tools/AssociationVectorIterator.h"
377 typedef AssociationVectorIterator asso_iterator;
378#include "AthLinks/tools/AssociationObjectIterator.h"
380 typedef AssociationObjectIterator object_iterator;
382
393 void addAssociation(const object_container_type* objectContainer,
394 const object_index_type& objectIndex,
395 const asso_container_type* assoContainer,
396 const asso_index_type& assoIndex);
397 void addAssociation(const object_container_type* objectContainer,
398 const object_type* objectPointer,
399 const asso_container_type* assoContainer,
400 const asso_type* assoPointer);
401 void addAssociation(const object_link& objectLink,
402 const asso_link& assoLink);
404
414 object_iterator beginObject() const;
416 object_iterator endObject() const;
417
419 asso_iterator beginAssociation(const object_type* objectPointer) const;
420 asso_iterator beginAssociation(const object_iterator& objectIter) const;
422 asso_iterator endAssociation(const object_type* objectPointer) const;
423 asso_iterator endAssociation(const object_iterator& objectIter) const;
425
427
428
429
431 const object_type* getObject(const object_iterator& objectIter) const
432 { return (*objectIter).getObject(); }
433
435 object_iterator findObject(const object_type* theObject) const
436 { return object_iterator(m_associationMap).find(theObject); }
437
439 bool containsObject(const object_type* theObject) const
440 { return this->findObject(theObject) != this->endObject(); }
441
443 size_t getNumberOfObjects() const { return this->size(); }
444
448
449
450 const asso_type* getAssociation(asso_iterator assoIter) const
451 { return *assoIter; }
452
454 asso_iterator findAssociation(const object_iterator& objectIter,
455 const asso_type* assoPointer) const
456 { return objectIter.findAssociation(assoPointer); }
457 asso_iterator findAssociation(const object_type* objectPointer,
458 const asso_type* assoPointer) const;
459
461 bool containsAssociation(const object_iterator& objectIter,
462 const asso_type* assoPointer) const
463 { return objectIter.containsAssociation(assoPointer); }
464
465 bool containsAssociation(const object_type* objectPointer,
466 const asso_type* assoPointer) const;
467 bool containsAssociation(const asso_type* assoPointer) const;
468
470 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
471
473 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
474 { return this->getObjects(*assoIter,theObjects); }
475
477 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
478
480 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
481 { return this->getAssociations(objIter.getObject(),assocs); }
482
484 size_t size() { return m_associationMap.size(); }
485
487 size_t size() const { return m_associationMap.size(); }
488
489 size_t size(const object_type* objectPointer) const;
490
491 size_t getNumberOfAssociations(const object_type* objectPointer) const
492 { return this->size(objectPointer); }
493
494 size_t size(const object_iterator& objectIter) const
495 { return objectIter.getNumberOfAssociations(); }
496
497 size_t getNumberOfAssociations(const object_iterator& objectIter) const
498 { return this->size(objectIter); }
499
500 protected:
501
503 store_type m_associationMap;
504
506 store_iterator_type internalFind(const object_link& objectLink,
507 const asso_link& assoLink)
508 {
509 // check key
510 store_iterator_type mapEnd = m_associationMap.end();
511 store_iterator_type foundIter = mapEnd;
512 for ( store_iterator_type iMap = m_associationMap.begin();
513 iMap != mapEnd;
514 ++iMap ) {
515 // look for the address of the pointed-at object
516 // must dereference the ElementLink pointer
517 if ( iMap->first.cptr() == objectLink.cptr() ) {
518 foundIter = iMap;
519 break;
520 }
521 }
522
523 if ( foundIter == m_associationMap.end() ) { return foundIter; }
524 // check data
525 if ( std::find((foundIter->second).begin(),
526 (foundIter->second).end(),
527 assoLink) !=
528 (foundIter->second).end() )
529 { return foundIter; }
530 // not found at all
531 return m_associationMap.end();
532 }
533
535 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
536
537};
538
539#include "AthLinks/AssociationMap.icc"
540
541#undef ASSOCIATION_CONTEXT
542#undef ASSOCIATIONMAP_CONTEXT
543#endif
AssociationMap::AssociationObjectIterator::find
AssociationObjectIterator find(const object_type *objectPointer) const
find a given object in store
Definition AssociationMap.h:244
AssociationMap::AssociationObjectIterator::getObject
const object_type * getObject() const
retrieve the pointer to a given object
Definition AssociationMap.h:269
AssociationMap::AssociationObjectIterator::containsAssociation
bool containsAssociation(const asso_type *assoPointer) const
check if the given object can be matched among the associated objects
Definition AssociationMap.h:297
AssociationMap::AssociationObjectIterator::getNumberOfAssociations
size_t getNumberOfAssociations() const
get number of association for current pointed-to object
Definition AssociationMap.h:301
AssociationMap::AssociationObjectIterator::findAssociation
asso_iterator findAssociation(const asso_type *assoPointer) const
find the iterator for a given object
Definition AssociationMap.h:289
AssociationMap
templated base class for a look-up map for associations
Definition AssociationMap.h:39
AssociationMap::getAssociation
const asso_type * getAssociation(asso_iterator assoIter) const
associations iterator access
Definition AssociationMap.h:154
AssociationMap::~AssociationMap
virtual ~AssociationMap()
AssociationMap::beginAssociation
asso_iterator beginAssociation(const object_type *objectPointer) const
begin iterator for associations
AssociationMap::getObject
const object_type * getObject(const object_iterator &objectIter) const
get association iterators by object iterator
Definition AssociationMap.h:135
AssociationMap::internalFind
store_iterator_type internalFind(const object_link &objectLink, const asso_link &assoLink)
internally used find method
Definition AssociationMap.h:210
AssociationMap::containsAssociation
bool containsAssociation(const object_iterator &objectIter, const asso_type *assoPointer) const
containment check
Definition AssociationMap.h:165
AssociationMap::object_iterator
AssociationObjectIterator object_iterator
object iterator type
Definition AssociationMap.h:84
AssociationMap::endObject
object_iterator endObject() const
end iterator for objects
AssociationMap::getNumberOfAssociations
size_t getNumberOfAssociations(const object_type *objectPointer) const
Definition AssociationMap.h:195
AssociationMap::getAssociations
bool getAssociations(const object_type *objPointer, asso_list &assocs) const
get all associations for a given object
AssociationMap::getNumberOfObjects
size_t getNumberOfObjects() const
retrieve number of objects in store
Definition AssociationMap.h:147
AssociationMap::addAssociation
void addAssociation(const object_container_type *objectContainer, const object_index_type &objectIndex, const asso_container_type *assoContainer, const asso_index_type &assoIndex)
AssociationMap::getObjects
bool getObjects(const asso_type *assoPointer, object_list &theObjects) const
get all objects for a given association
AssociationMap::findObject
object_iterator findObject(const object_type *theObject) const
finding an object with allocation
Definition AssociationMap.h:139
AssociationMap::addToStore
bool addToStore(const object_link &objectLink, const asso_link &assoLink)
internally used function to add links to store
AssociationMap::endAssociation
asso_iterator endAssociation(const object_type *objectPointer) const
end iterator for associations
AssociationMap::containsObject
bool containsObject(const object_type *theObject) const
testing if object is in store
Definition AssociationMap.h:143
AssociationMap::findAssociation
asso_iterator findAssociation(const object_iterator &objectIter, const asso_type *assoPointer) const
find association
Definition AssociationMap.h:158
AssociationMap::beginObject
object_iterator beginObject() const
begin iterator for objects
ElementLinkVector< asso_container_type >::const_iterator
ELVIterator< typename RefVector::const_iterator > const_iterator
Definition AthLinks/ElementLinkVector.h:129

◆ end() [1/2]

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::end ( )
inline

end object iterator

Definition at line 150 of file AssociationMap.h.

◆ end() [2/2]

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::end ( ) const
inline

end object iterator

Definition at line 157 of file AssociationMap.h.

◆ find()

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::find ( const object_type * objectPointer) const
inline

find a given object in store

Parameters
objectPointer- pointer reference to the object searched for

This method returns an AssociationObjectIterator which can immediately provide access to the associations using the second public variable, the appropriate getFirstAssociation, getLastAssociation methods.

Definition at line 244 of file AssociationMap.h.

◆ findAssociation()

template<class OBJCONT, class ASSCONT>
asso_iterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::findAssociation ( const asso_type * assoPointer) const
inline

find the iterator for a given object

Definition at line 289 of file AssociationMap.h.

327{
328 public:
329
332 typedef OBJCONT object_container_type;
333 typedef typename object_container_type::base_value_type object_type;
334 typedef
335 typename
336 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
337 object_index_type;
338 typedef ElementLink<object_container_type> object_link;
339 typedef typename std::list<const object_type*> object_list;
340
341 typedef ASSCONT asso_container_type;
342 typedef typename asso_container_type::base_value_type asso_type;
343 typedef
344 typename
345 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
346 asso_index_type;
347 typedef typename std::list<const asso_type*> asso_list;
348 typedef ElementLink<asso_container_type> asso_link;
349 typedef ElementLinkVector<asso_container_type> asso_store;
350 typedef typename asso_store::const_iterator asso_store_iterator;
351 typedef typename std::map<object_link,asso_store> store_type;
352 typedef typename store_type::iterator store_iterator_type;
354
355 // Dummy to allow defining an end iterator for an empty map.
356 static const asso_store s_dum_asso_store;
357
360 AssociationMap();
361 virtual ~AssociationMap();
363
364
367#include "AthLinks/tools/AssociationVectorIterator.h"
369 typedef AssociationVectorIterator asso_iterator;
370#include "AthLinks/tools/AssociationObjectIterator.h"
372 typedef AssociationObjectIterator object_iterator;
374
385 void addAssociation(const object_container_type* objectContainer,
386 const object_index_type& objectIndex,
387 const asso_container_type* assoContainer,
388 const asso_index_type& assoIndex);
389 void addAssociation(const object_container_type* objectContainer,
390 const object_type* objectPointer,
391 const asso_container_type* assoContainer,
392 const asso_type* assoPointer);
393 void addAssociation(const object_link& objectLink,
394 const asso_link& assoLink);
396
406 object_iterator beginObject() const;
408 object_iterator endObject() const;
409
411 asso_iterator beginAssociation(const object_type* objectPointer) const;
412 asso_iterator beginAssociation(const object_iterator& objectIter) const;
414 asso_iterator endAssociation(const object_type* objectPointer) const;
415 asso_iterator endAssociation(const object_iterator& objectIter) const;
417
419
420
421
423 const object_type* getObject(const object_iterator& objectIter) const
424 { return (*objectIter).getObject(); }
425
427 object_iterator findObject(const object_type* theObject) const
428 { return object_iterator(m_associationMap).find(theObject); }
429
431 bool containsObject(const object_type* theObject) const
432 { return this->findObject(theObject) != this->endObject(); }
433
435 size_t getNumberOfObjects() const { return this->size(); }
436
440
441
442 const asso_type* getAssociation(asso_iterator assoIter) const
443 { return *assoIter; }
444
446 asso_iterator findAssociation(const object_iterator& objectIter,
447 const asso_type* assoPointer) const
448 { return objectIter.findAssociation(assoPointer); }
449 asso_iterator findAssociation(const object_type* objectPointer,
450 const asso_type* assoPointer) const;
451
453 bool containsAssociation(const object_iterator& objectIter,
454 const asso_type* assoPointer) const
455 { return objectIter.containsAssociation(assoPointer); }
456
457 bool containsAssociation(const object_type* objectPointer,
458 const asso_type* assoPointer) const;
459 bool containsAssociation(const asso_type* assoPointer) const;
460
462 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
463
465 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
466 { return this->getObjects(*assoIter,theObjects); }
467
469 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
470
472 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
473 { return this->getAssociations(objIter.getObject(),assocs); }
474
476 size_t size() { return m_associationMap.size(); }
477
479 size_t size() const { return m_associationMap.size(); }
480
481 size_t size(const object_type* objectPointer) const;
482
483 size_t getNumberOfAssociations(const object_type* objectPointer) const
484 { return this->size(objectPointer); }
485
486 size_t size(const object_iterator& objectIter) const
487 { return objectIter.getNumberOfAssociations(); }
488
489 size_t getNumberOfAssociations(const object_iterator& objectIter) const
490 { return this->size(objectIter); }
491
492 protected:
493
495 store_type m_associationMap;
496
498 store_iterator_type internalFind(const object_link& objectLink,
499 const asso_link& assoLink)
500 {
501 // check key
502 store_iterator_type mapEnd = m_associationMap.end();
503 store_iterator_type foundIter = mapEnd;
504 for ( store_iterator_type iMap = m_associationMap.begin();
505 iMap != mapEnd;
506 ++iMap ) {
507 // look for the address of the pointed-at object
508 // must dereference the ElementLink pointer
509 if ( iMap->first.cptr() == objectLink.cptr() ) {
510 foundIter = iMap;
511 break;
512 }
513 }
514
515 if ( foundIter == m_associationMap.end() ) { return foundIter; }
516 // check data
517 if ( std::find((foundIter->second).begin(),
518 (foundIter->second).end(),
519 assoLink) !=
520 (foundIter->second).end() )
521 { return foundIter; }
522 // not found at all
523 return m_associationMap.end();
524 }
525
527 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
528
529};
530
531#include "AthLinks/AssociationMap.icc"
532
533#undef ASSOCIATION_CONTEXT
534#undef ASSOCIATIONMAP_CONTEXT
535#endif

◆ first()

template<class OBJCONT, class ASSCONT>
const object_type * AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::first ( ) const
inline

access to object pointer

Definition at line 232 of file AssociationMap.h.

◆ getFirstAssociation()

template<class OBJCONT, class ASSCONT>
asso_iterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::getFirstAssociation ( ) const
inline

retrieve iterator to first associated object

Definition at line 277 of file AssociationMap.h.

315{
316 public:
317
320 typedef OBJCONT object_container_type;
321 typedef typename object_container_type::base_value_type object_type;
322 typedef
323 typename
324 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
325 object_index_type;
326 typedef ElementLink<object_container_type> object_link;
327 typedef typename std::list<const object_type*> object_list;
328
329 typedef ASSCONT asso_container_type;
330 typedef typename asso_container_type::base_value_type asso_type;
331 typedef
332 typename
333 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
334 asso_index_type;
335 typedef typename std::list<const asso_type*> asso_list;
336 typedef ElementLink<asso_container_type> asso_link;
337 typedef ElementLinkVector<asso_container_type> asso_store;
338 typedef typename asso_store::const_iterator asso_store_iterator;
339 typedef typename std::map<object_link,asso_store> store_type;
340 typedef typename store_type::iterator store_iterator_type;
342
343 // Dummy to allow defining an end iterator for an empty map.
344 static const asso_store s_dum_asso_store;
345
348 AssociationMap();
349 virtual ~AssociationMap();
351
352
355#include "AthLinks/tools/AssociationVectorIterator.h"
357 typedef AssociationVectorIterator asso_iterator;
358#include "AthLinks/tools/AssociationObjectIterator.h"
360 typedef AssociationObjectIterator object_iterator;
362
373 void addAssociation(const object_container_type* objectContainer,
374 const object_index_type& objectIndex,
375 const asso_container_type* assoContainer,
376 const asso_index_type& assoIndex);
377 void addAssociation(const object_container_type* objectContainer,
378 const object_type* objectPointer,
379 const asso_container_type* assoContainer,
380 const asso_type* assoPointer);
381 void addAssociation(const object_link& objectLink,
382 const asso_link& assoLink);
384
394 object_iterator beginObject() const;
396 object_iterator endObject() const;
397
399 asso_iterator beginAssociation(const object_type* objectPointer) const;
400 asso_iterator beginAssociation(const object_iterator& objectIter) const;
402 asso_iterator endAssociation(const object_type* objectPointer) const;
403 asso_iterator endAssociation(const object_iterator& objectIter) const;
405
407
408
409
411 const object_type* getObject(const object_iterator& objectIter) const
412 { return (*objectIter).getObject(); }
413
415 object_iterator findObject(const object_type* theObject) const
416 { return object_iterator(m_associationMap).find(theObject); }
417
419 bool containsObject(const object_type* theObject) const
420 { return this->findObject(theObject) != this->endObject(); }
421
423 size_t getNumberOfObjects() const { return this->size(); }
424
428
429
430 const asso_type* getAssociation(asso_iterator assoIter) const
431 { return *assoIter; }
432
434 asso_iterator findAssociation(const object_iterator& objectIter,
435 const asso_type* assoPointer) const
436 { return objectIter.findAssociation(assoPointer); }
437 asso_iterator findAssociation(const object_type* objectPointer,
438 const asso_type* assoPointer) const;
439
441 bool containsAssociation(const object_iterator& objectIter,
442 const asso_type* assoPointer) const
443 { return objectIter.containsAssociation(assoPointer); }
444
445 bool containsAssociation(const object_type* objectPointer,
446 const asso_type* assoPointer) const;
447 bool containsAssociation(const asso_type* assoPointer) const;
448
450 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
451
453 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
454 { return this->getObjects(*assoIter,theObjects); }
455
457 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
458
460 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
461 { return this->getAssociations(objIter.getObject(),assocs); }
462
464 size_t size() { return m_associationMap.size(); }
465
467 size_t size() const { return m_associationMap.size(); }
468
469 size_t size(const object_type* objectPointer) const;
470
471 size_t getNumberOfAssociations(const object_type* objectPointer) const
472 { return this->size(objectPointer); }
473
474 size_t size(const object_iterator& objectIter) const
475 { return objectIter.getNumberOfAssociations(); }
476
477 size_t getNumberOfAssociations(const object_iterator& objectIter) const
478 { return this->size(objectIter); }
479
480 protected:
481
483 store_type m_associationMap;
484
486 store_iterator_type internalFind(const object_link& objectLink,
487 const asso_link& assoLink)
488 {
489 // check key
490 store_iterator_type mapEnd = m_associationMap.end();
491 store_iterator_type foundIter = mapEnd;
492 for ( store_iterator_type iMap = m_associationMap.begin();
493 iMap != mapEnd;
494 ++iMap ) {
495 // look for the address of the pointed-at object
496 // must dereference the ElementLink pointer
497 if ( iMap->first.cptr() == objectLink.cptr() ) {
498 foundIter = iMap;
499 break;
500 }
501 }
502
503 if ( foundIter == m_associationMap.end() ) { return foundIter; }
504 // check data
505 if ( std::find((foundIter->second).begin(),
506 (foundIter->second).end(),
507 assoLink) !=
508 (foundIter->second).end() )
509 { return foundIter; }
510 // not found at all
511 return m_associationMap.end();
512 }
513
515 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
516
517};
518
519#include "AthLinks/AssociationMap.icc"
520
521#undef ASSOCIATION_CONTEXT
522#undef ASSOCIATIONMAP_CONTEXT
523#endif

◆ getLastAssociation()

template<class OBJCONT, class ASSCONT>
asso_iterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::getLastAssociation ( ) const
inline

retrieve end iterator to internal associated object store

Definition at line 283 of file AssociationMap.h.

321{
322 public:
323
326 typedef OBJCONT object_container_type;
327 typedef typename object_container_type::base_value_type object_type;
328 typedef
329 typename
330 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
331 object_index_type;
332 typedef ElementLink<object_container_type> object_link;
333 typedef typename std::list<const object_type*> object_list;
334
335 typedef ASSCONT asso_container_type;
336 typedef typename asso_container_type::base_value_type asso_type;
337 typedef
338 typename
339 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
340 asso_index_type;
341 typedef typename std::list<const asso_type*> asso_list;
342 typedef ElementLink<asso_container_type> asso_link;
343 typedef ElementLinkVector<asso_container_type> asso_store;
344 typedef typename asso_store::const_iterator asso_store_iterator;
345 typedef typename std::map<object_link,asso_store> store_type;
346 typedef typename store_type::iterator store_iterator_type;
348
349 // Dummy to allow defining an end iterator for an empty map.
350 static const asso_store s_dum_asso_store;
351
354 AssociationMap();
355 virtual ~AssociationMap();
357
358
361#include "AthLinks/tools/AssociationVectorIterator.h"
363 typedef AssociationVectorIterator asso_iterator;
364#include "AthLinks/tools/AssociationObjectIterator.h"
366 typedef AssociationObjectIterator object_iterator;
368
379 void addAssociation(const object_container_type* objectContainer,
380 const object_index_type& objectIndex,
381 const asso_container_type* assoContainer,
382 const asso_index_type& assoIndex);
383 void addAssociation(const object_container_type* objectContainer,
384 const object_type* objectPointer,
385 const asso_container_type* assoContainer,
386 const asso_type* assoPointer);
387 void addAssociation(const object_link& objectLink,
388 const asso_link& assoLink);
390
400 object_iterator beginObject() const;
402 object_iterator endObject() const;
403
405 asso_iterator beginAssociation(const object_type* objectPointer) const;
406 asso_iterator beginAssociation(const object_iterator& objectIter) const;
408 asso_iterator endAssociation(const object_type* objectPointer) const;
409 asso_iterator endAssociation(const object_iterator& objectIter) const;
411
413
414
415
417 const object_type* getObject(const object_iterator& objectIter) const
418 { return (*objectIter).getObject(); }
419
421 object_iterator findObject(const object_type* theObject) const
422 { return object_iterator(m_associationMap).find(theObject); }
423
425 bool containsObject(const object_type* theObject) const
426 { return this->findObject(theObject) != this->endObject(); }
427
429 size_t getNumberOfObjects() const { return this->size(); }
430
434
435
436 const asso_type* getAssociation(asso_iterator assoIter) const
437 { return *assoIter; }
438
440 asso_iterator findAssociation(const object_iterator& objectIter,
441 const asso_type* assoPointer) const
442 { return objectIter.findAssociation(assoPointer); }
443 asso_iterator findAssociation(const object_type* objectPointer,
444 const asso_type* assoPointer) const;
445
447 bool containsAssociation(const object_iterator& objectIter,
448 const asso_type* assoPointer) const
449 { return objectIter.containsAssociation(assoPointer); }
450
451 bool containsAssociation(const object_type* objectPointer,
452 const asso_type* assoPointer) const;
453 bool containsAssociation(const asso_type* assoPointer) const;
454
456 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
457
459 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
460 { return this->getObjects(*assoIter,theObjects); }
461
463 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
464
466 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
467 { return this->getAssociations(objIter.getObject(),assocs); }
468
470 size_t size() { return m_associationMap.size(); }
471
473 size_t size() const { return m_associationMap.size(); }
474
475 size_t size(const object_type* objectPointer) const;
476
477 size_t getNumberOfAssociations(const object_type* objectPointer) const
478 { return this->size(objectPointer); }
479
480 size_t size(const object_iterator& objectIter) const
481 { return objectIter.getNumberOfAssociations(); }
482
483 size_t getNumberOfAssociations(const object_iterator& objectIter) const
484 { return this->size(objectIter); }
485
486 protected:
487
489 store_type m_associationMap;
490
492 store_iterator_type internalFind(const object_link& objectLink,
493 const asso_link& assoLink)
494 {
495 // check key
496 store_iterator_type mapEnd = m_associationMap.end();
497 store_iterator_type foundIter = mapEnd;
498 for ( store_iterator_type iMap = m_associationMap.begin();
499 iMap != mapEnd;
500 ++iMap ) {
501 // look for the address of the pointed-at object
502 // must dereference the ElementLink pointer
503 if ( iMap->first.cptr() == objectLink.cptr() ) {
504 foundIter = iMap;
505 break;
506 }
507 }
508
509 if ( foundIter == m_associationMap.end() ) { return foundIter; }
510 // check data
511 if ( std::find((foundIter->second).begin(),
512 (foundIter->second).end(),
513 assoLink) !=
514 (foundIter->second).end() )
515 { return foundIter; }
516 // not found at all
517 return m_associationMap.end();
518 }
519
521 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
522
523};
524
525#include "AthLinks/AssociationMap.icc"
526
527#undef ASSOCIATION_CONTEXT
528#undef ASSOCIATIONMAP_CONTEXT
529#endif

◆ getNumberOfAssociations()

template<class OBJCONT, class ASSCONT>
size_t AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::getNumberOfAssociations ( ) const
inline

get number of association for current pointed-to object

Definition at line 301 of file AssociationMap.h.

339{
340 public:
341
344 typedef OBJCONT object_container_type;
345 typedef typename object_container_type::base_value_type object_type;
346 typedef
347 typename
348 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
349 object_index_type;
350 typedef ElementLink<object_container_type> object_link;
351 typedef typename std::list<const object_type*> object_list;
352
353 typedef ASSCONT asso_container_type;
354 typedef typename asso_container_type::base_value_type asso_type;
355 typedef
356 typename
357 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
358 asso_index_type;
359 typedef typename std::list<const asso_type*> asso_list;
360 typedef ElementLink<asso_container_type> asso_link;
361 typedef ElementLinkVector<asso_container_type> asso_store;
362 typedef typename asso_store::const_iterator asso_store_iterator;
363 typedef typename std::map<object_link,asso_store> store_type;
364 typedef typename store_type::iterator store_iterator_type;
366
367 // Dummy to allow defining an end iterator for an empty map.
368 static const asso_store s_dum_asso_store;
369
372 AssociationMap();
373 virtual ~AssociationMap();
375
376
379#include "AthLinks/tools/AssociationVectorIterator.h"
381 typedef AssociationVectorIterator asso_iterator;
382#include "AthLinks/tools/AssociationObjectIterator.h"
384 typedef AssociationObjectIterator object_iterator;
386
397 void addAssociation(const object_container_type* objectContainer,
398 const object_index_type& objectIndex,
399 const asso_container_type* assoContainer,
400 const asso_index_type& assoIndex);
401 void addAssociation(const object_container_type* objectContainer,
402 const object_type* objectPointer,
403 const asso_container_type* assoContainer,
404 const asso_type* assoPointer);
405 void addAssociation(const object_link& objectLink,
406 const asso_link& assoLink);
408
418 object_iterator beginObject() const;
420 object_iterator endObject() const;
421
423 asso_iterator beginAssociation(const object_type* objectPointer) const;
424 asso_iterator beginAssociation(const object_iterator& objectIter) const;
426 asso_iterator endAssociation(const object_type* objectPointer) const;
427 asso_iterator endAssociation(const object_iterator& objectIter) const;
429
431
432
433
435 const object_type* getObject(const object_iterator& objectIter) const
436 { return (*objectIter).getObject(); }
437
439 object_iterator findObject(const object_type* theObject) const
440 { return object_iterator(m_associationMap).find(theObject); }
441
443 bool containsObject(const object_type* theObject) const
444 { return this->findObject(theObject) != this->endObject(); }
445
447 size_t getNumberOfObjects() const { return this->size(); }
448
452
453
454 const asso_type* getAssociation(asso_iterator assoIter) const
455 { return *assoIter; }
456
458 asso_iterator findAssociation(const object_iterator& objectIter,
459 const asso_type* assoPointer) const
460 { return objectIter.findAssociation(assoPointer); }
461 asso_iterator findAssociation(const object_type* objectPointer,
462 const asso_type* assoPointer) const;
463
465 bool containsAssociation(const object_iterator& objectIter,
466 const asso_type* assoPointer) const
467 { return objectIter.containsAssociation(assoPointer); }
468
469 bool containsAssociation(const object_type* objectPointer,
470 const asso_type* assoPointer) const;
471 bool containsAssociation(const asso_type* assoPointer) const;
472
474 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
475
477 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
478 { return this->getObjects(*assoIter,theObjects); }
479
481 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
482
484 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
485 { return this->getAssociations(objIter.getObject(),assocs); }
486
488 size_t size() { return m_associationMap.size(); }
489
491 size_t size() const { return m_associationMap.size(); }
492
493 size_t size(const object_type* objectPointer) const;
494
495 size_t getNumberOfAssociations(const object_type* objectPointer) const
496 { return this->size(objectPointer); }
497
498 size_t size(const object_iterator& objectIter) const
499 { return objectIter.getNumberOfAssociations(); }
500
501 size_t getNumberOfAssociations(const object_iterator& objectIter) const
502 { return this->size(objectIter); }
503
504 protected:
505
507 store_type m_associationMap;
508
510 store_iterator_type internalFind(const object_link& objectLink,
511 const asso_link& assoLink)
512 {
513 // check key
514 store_iterator_type mapEnd = m_associationMap.end();
515 store_iterator_type foundIter = mapEnd;
516 for ( store_iterator_type iMap = m_associationMap.begin();
517 iMap != mapEnd;
518 ++iMap ) {
519 // look for the address of the pointed-at object
520 // must dereference the ElementLink pointer
521 if ( iMap->first.cptr() == objectLink.cptr() ) {
522 foundIter = iMap;
523 break;
524 }
525 }
526
527 if ( foundIter == m_associationMap.end() ) { return foundIter; }
528 // check data
529 if ( std::find((foundIter->second).begin(),
530 (foundIter->second).end(),
531 assoLink) !=
532 (foundIter->second).end() )
533 { return foundIter; }
534 // not found at all
535 return m_associationMap.end();
536 }
537
539 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
540
541};
542
543#include "AthLinks/AssociationMap.icc"
544
545#undef ASSOCIATION_CONTEXT
546#undef ASSOCIATIONMAP_CONTEXT
547#endif

◆ getObject()

template<class OBJCONT, class ASSCONT>
const object_type * AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::getObject ( ) const
inline

retrieve the pointer to a given object

This method allows direct access to the object pointer stored in each AssociationObjectIterator instance.

Definition at line 269 of file AssociationMap.h.

307{
308 public:
309
312 typedef OBJCONT object_container_type;
313 typedef typename object_container_type::base_value_type object_type;
314 typedef
315 typename
316 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
317 object_index_type;
318 typedef ElementLink<object_container_type> object_link;
319 typedef typename std::list<const object_type*> object_list;
320
321 typedef ASSCONT asso_container_type;
322 typedef typename asso_container_type::base_value_type asso_type;
323 typedef
324 typename
325 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
326 asso_index_type;
327 typedef typename std::list<const asso_type*> asso_list;
328 typedef ElementLink<asso_container_type> asso_link;
329 typedef ElementLinkVector<asso_container_type> asso_store;
330 typedef typename asso_store::const_iterator asso_store_iterator;
331 typedef typename std::map<object_link,asso_store> store_type;
332 typedef typename store_type::iterator store_iterator_type;
334
335 // Dummy to allow defining an end iterator for an empty map.
336 static const asso_store s_dum_asso_store;
337
340 AssociationMap();
341 virtual ~AssociationMap();
343
344
347#include "AthLinks/tools/AssociationVectorIterator.h"
349 typedef AssociationVectorIterator asso_iterator;
350#include "AthLinks/tools/AssociationObjectIterator.h"
352 typedef AssociationObjectIterator object_iterator;
354
365 void addAssociation(const object_container_type* objectContainer,
366 const object_index_type& objectIndex,
367 const asso_container_type* assoContainer,
368 const asso_index_type& assoIndex);
369 void addAssociation(const object_container_type* objectContainer,
370 const object_type* objectPointer,
371 const asso_container_type* assoContainer,
372 const asso_type* assoPointer);
373 void addAssociation(const object_link& objectLink,
374 const asso_link& assoLink);
376
386 object_iterator beginObject() const;
388 object_iterator endObject() const;
389
391 asso_iterator beginAssociation(const object_type* objectPointer) const;
392 asso_iterator beginAssociation(const object_iterator& objectIter) const;
394 asso_iterator endAssociation(const object_type* objectPointer) const;
395 asso_iterator endAssociation(const object_iterator& objectIter) const;
397
399
400
401
403 const object_type* getObject(const object_iterator& objectIter) const
404 { return (*objectIter).getObject(); }
405
407 object_iterator findObject(const object_type* theObject) const
408 { return object_iterator(m_associationMap).find(theObject); }
409
411 bool containsObject(const object_type* theObject) const
412 { return this->findObject(theObject) != this->endObject(); }
413
415 size_t getNumberOfObjects() const { return this->size(); }
416
420
421
422 const asso_type* getAssociation(asso_iterator assoIter) const
423 { return *assoIter; }
424
426 asso_iterator findAssociation(const object_iterator& objectIter,
427 const asso_type* assoPointer) const
428 { return objectIter.findAssociation(assoPointer); }
429 asso_iterator findAssociation(const object_type* objectPointer,
430 const asso_type* assoPointer) const;
431
433 bool containsAssociation(const object_iterator& objectIter,
434 const asso_type* assoPointer) const
435 { return objectIter.containsAssociation(assoPointer); }
436
437 bool containsAssociation(const object_type* objectPointer,
438 const asso_type* assoPointer) const;
439 bool containsAssociation(const asso_type* assoPointer) const;
440
442 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
443
445 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
446 { return this->getObjects(*assoIter,theObjects); }
447
449 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
450
452 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
453 { return this->getAssociations(objIter.getObject(),assocs); }
454
456 size_t size() { return m_associationMap.size(); }
457
459 size_t size() const { return m_associationMap.size(); }
460
461 size_t size(const object_type* objectPointer) const;
462
463 size_t getNumberOfAssociations(const object_type* objectPointer) const
464 { return this->size(objectPointer); }
465
466 size_t size(const object_iterator& objectIter) const
467 { return objectIter.getNumberOfAssociations(); }
468
469 size_t getNumberOfAssociations(const object_iterator& objectIter) const
470 { return this->size(objectIter); }
471
472 protected:
473
475 store_type m_associationMap;
476
478 store_iterator_type internalFind(const object_link& objectLink,
479 const asso_link& assoLink)
480 {
481 // check key
482 store_iterator_type mapEnd = m_associationMap.end();
483 store_iterator_type foundIter = mapEnd;
484 for ( store_iterator_type iMap = m_associationMap.begin();
485 iMap != mapEnd;
486 ++iMap ) {
487 // look for the address of the pointed-at object
488 // must dereference the ElementLink pointer
489 if ( iMap->first.cptr() == objectLink.cptr() ) {
490 foundIter = iMap;
491 break;
492 }
493 }
494
495 if ( foundIter == m_associationMap.end() ) { return foundIter; }
496 // check data
497 if ( std::find((foundIter->second).begin(),
498 (foundIter->second).end(),
499 assoLink) !=
500 (foundIter->second).end() )
501 { return foundIter; }
502 // not found at all
503 return m_associationMap.end();
504 }
505
507 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
508
509};
510
511#include "AthLinks/AssociationMap.icc"
512
513#undef ASSOCIATION_CONTEXT
514#undef ASSOCIATIONMAP_CONTEXT
515#endif

◆ getObjectLink()

template<class OBJCONT, class ASSCONT>
const object_link & AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::getObjectLink ( ) const
inline

retrieve link to the object.

Definition at line 272 of file AssociationMap.h.

310{
311 public:
312
315 typedef OBJCONT object_container_type;
316 typedef typename object_container_type::base_value_type object_type;
317 typedef
318 typename
319 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
320 object_index_type;
321 typedef ElementLink<object_container_type> object_link;
322 typedef typename std::list<const object_type*> object_list;
323
324 typedef ASSCONT asso_container_type;
325 typedef typename asso_container_type::base_value_type asso_type;
326 typedef
327 typename
328 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
329 asso_index_type;
330 typedef typename std::list<const asso_type*> asso_list;
331 typedef ElementLink<asso_container_type> asso_link;
332 typedef ElementLinkVector<asso_container_type> asso_store;
333 typedef typename asso_store::const_iterator asso_store_iterator;
334 typedef typename std::map<object_link,asso_store> store_type;
335 typedef typename store_type::iterator store_iterator_type;
337
338 // Dummy to allow defining an end iterator for an empty map.
339 static const asso_store s_dum_asso_store;
340
343 AssociationMap();
344 virtual ~AssociationMap();
346
347
350#include "AthLinks/tools/AssociationVectorIterator.h"
352 typedef AssociationVectorIterator asso_iterator;
353#include "AthLinks/tools/AssociationObjectIterator.h"
355 typedef AssociationObjectIterator object_iterator;
357
368 void addAssociation(const object_container_type* objectContainer,
369 const object_index_type& objectIndex,
370 const asso_container_type* assoContainer,
371 const asso_index_type& assoIndex);
372 void addAssociation(const object_container_type* objectContainer,
373 const object_type* objectPointer,
374 const asso_container_type* assoContainer,
375 const asso_type* assoPointer);
376 void addAssociation(const object_link& objectLink,
377 const asso_link& assoLink);
379
389 object_iterator beginObject() const;
391 object_iterator endObject() const;
392
394 asso_iterator beginAssociation(const object_type* objectPointer) const;
395 asso_iterator beginAssociation(const object_iterator& objectIter) const;
397 asso_iterator endAssociation(const object_type* objectPointer) const;
398 asso_iterator endAssociation(const object_iterator& objectIter) const;
400
402
403
404
406 const object_type* getObject(const object_iterator& objectIter) const
407 { return (*objectIter).getObject(); }
408
410 object_iterator findObject(const object_type* theObject) const
411 { return object_iterator(m_associationMap).find(theObject); }
412
414 bool containsObject(const object_type* theObject) const
415 { return this->findObject(theObject) != this->endObject(); }
416
418 size_t getNumberOfObjects() const { return this->size(); }
419
423
424
425 const asso_type* getAssociation(asso_iterator assoIter) const
426 { return *assoIter; }
427
429 asso_iterator findAssociation(const object_iterator& objectIter,
430 const asso_type* assoPointer) const
431 { return objectIter.findAssociation(assoPointer); }
432 asso_iterator findAssociation(const object_type* objectPointer,
433 const asso_type* assoPointer) const;
434
436 bool containsAssociation(const object_iterator& objectIter,
437 const asso_type* assoPointer) const
438 { return objectIter.containsAssociation(assoPointer); }
439
440 bool containsAssociation(const object_type* objectPointer,
441 const asso_type* assoPointer) const;
442 bool containsAssociation(const asso_type* assoPointer) const;
443
445 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
446
448 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
449 { return this->getObjects(*assoIter,theObjects); }
450
452 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
453
455 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
456 { return this->getAssociations(objIter.getObject(),assocs); }
457
459 size_t size() { return m_associationMap.size(); }
460
462 size_t size() const { return m_associationMap.size(); }
463
464 size_t size(const object_type* objectPointer) const;
465
466 size_t getNumberOfAssociations(const object_type* objectPointer) const
467 { return this->size(objectPointer); }
468
469 size_t size(const object_iterator& objectIter) const
470 { return objectIter.getNumberOfAssociations(); }
471
472 size_t getNumberOfAssociations(const object_iterator& objectIter) const
473 { return this->size(objectIter); }
474
475 protected:
476
478 store_type m_associationMap;
479
481 store_iterator_type internalFind(const object_link& objectLink,
482 const asso_link& assoLink)
483 {
484 // check key
485 store_iterator_type mapEnd = m_associationMap.end();
486 store_iterator_type foundIter = mapEnd;
487 for ( store_iterator_type iMap = m_associationMap.begin();
488 iMap != mapEnd;
489 ++iMap ) {
490 // look for the address of the pointed-at object
491 // must dereference the ElementLink pointer
492 if ( iMap->first.cptr() == objectLink.cptr() ) {
493 foundIter = iMap;
494 break;
495 }
496 }
497
498 if ( foundIter == m_associationMap.end() ) { return foundIter; }
499 // check data
500 if ( std::find((foundIter->second).begin(),
501 (foundIter->second).end(),
502 assoLink) !=
503 (foundIter->second).end() )
504 { return foundIter; }
505 // not found at all
506 return m_associationMap.end();
507 }
508
510 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
511
512};
513
514#include "AthLinks/AssociationMap.icc"
515
516#undef ASSOCIATION_CONTEXT
517#undef ASSOCIATIONMAP_CONTEXT
518#endif

◆ isValid()

template<class OBJCONT, class ASSCONT>
bool AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::isValid ( ) const
inline

Definition at line 274 of file AssociationMap.h.

312{
313 public:
314
317 typedef OBJCONT object_container_type;
318 typedef typename object_container_type::base_value_type object_type;
319 typedef
320 typename
321 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
322 object_index_type;
323 typedef ElementLink<object_container_type> object_link;
324 typedef typename std::list<const object_type*> object_list;
325
326 typedef ASSCONT asso_container_type;
327 typedef typename asso_container_type::base_value_type asso_type;
328 typedef
329 typename
330 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
331 asso_index_type;
332 typedef typename std::list<const asso_type*> asso_list;
333 typedef ElementLink<asso_container_type> asso_link;
334 typedef ElementLinkVector<asso_container_type> asso_store;
335 typedef typename asso_store::const_iterator asso_store_iterator;
336 typedef typename std::map<object_link,asso_store> store_type;
337 typedef typename store_type::iterator store_iterator_type;
339
340 // Dummy to allow defining an end iterator for an empty map.
341 static const asso_store s_dum_asso_store;
342
345 AssociationMap();
346 virtual ~AssociationMap();
348
349
352#include "AthLinks/tools/AssociationVectorIterator.h"
354 typedef AssociationVectorIterator asso_iterator;
355#include "AthLinks/tools/AssociationObjectIterator.h"
357 typedef AssociationObjectIterator object_iterator;
359
370 void addAssociation(const object_container_type* objectContainer,
371 const object_index_type& objectIndex,
372 const asso_container_type* assoContainer,
373 const asso_index_type& assoIndex);
374 void addAssociation(const object_container_type* objectContainer,
375 const object_type* objectPointer,
376 const asso_container_type* assoContainer,
377 const asso_type* assoPointer);
378 void addAssociation(const object_link& objectLink,
379 const asso_link& assoLink);
381
391 object_iterator beginObject() const;
393 object_iterator endObject() const;
394
396 asso_iterator beginAssociation(const object_type* objectPointer) const;
397 asso_iterator beginAssociation(const object_iterator& objectIter) const;
399 asso_iterator endAssociation(const object_type* objectPointer) const;
400 asso_iterator endAssociation(const object_iterator& objectIter) const;
402
404
405
406
408 const object_type* getObject(const object_iterator& objectIter) const
409 { return (*objectIter).getObject(); }
410
412 object_iterator findObject(const object_type* theObject) const
413 { return object_iterator(m_associationMap).find(theObject); }
414
416 bool containsObject(const object_type* theObject) const
417 { return this->findObject(theObject) != this->endObject(); }
418
420 size_t getNumberOfObjects() const { return this->size(); }
421
425
426
427 const asso_type* getAssociation(asso_iterator assoIter) const
428 { return *assoIter; }
429
431 asso_iterator findAssociation(const object_iterator& objectIter,
432 const asso_type* assoPointer) const
433 { return objectIter.findAssociation(assoPointer); }
434 asso_iterator findAssociation(const object_type* objectPointer,
435 const asso_type* assoPointer) const;
436
438 bool containsAssociation(const object_iterator& objectIter,
439 const asso_type* assoPointer) const
440 { return objectIter.containsAssociation(assoPointer); }
441
442 bool containsAssociation(const object_type* objectPointer,
443 const asso_type* assoPointer) const;
444 bool containsAssociation(const asso_type* assoPointer) const;
445
447 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
448
450 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
451 { return this->getObjects(*assoIter,theObjects); }
452
454 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
455
457 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
458 { return this->getAssociations(objIter.getObject(),assocs); }
459
461 size_t size() { return m_associationMap.size(); }
462
464 size_t size() const { return m_associationMap.size(); }
465
466 size_t size(const object_type* objectPointer) const;
467
468 size_t getNumberOfAssociations(const object_type* objectPointer) const
469 { return this->size(objectPointer); }
470
471 size_t size(const object_iterator& objectIter) const
472 { return objectIter.getNumberOfAssociations(); }
473
474 size_t getNumberOfAssociations(const object_iterator& objectIter) const
475 { return this->size(objectIter); }
476
477 protected:
478
480 store_type m_associationMap;
481
483 store_iterator_type internalFind(const object_link& objectLink,
484 const asso_link& assoLink)
485 {
486 // check key
487 store_iterator_type mapEnd = m_associationMap.end();
488 store_iterator_type foundIter = mapEnd;
489 for ( store_iterator_type iMap = m_associationMap.begin();
490 iMap != mapEnd;
491 ++iMap ) {
492 // look for the address of the pointed-at object
493 // must dereference the ElementLink pointer
494 if ( iMap->first.cptr() == objectLink.cptr() ) {
495 foundIter = iMap;
496 break;
497 }
498 }
499
500 if ( foundIter == m_associationMap.end() ) { return foundIter; }
501 // check data
502 if ( std::find((foundIter->second).begin(),
503 (foundIter->second).end(),
504 assoLink) !=
505 (foundIter->second).end() )
506 { return foundIter; }
507 // not found at all
508 return m_associationMap.end();
509 }
510
512 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
513
514};
515
516#include "AthLinks/AssociationMap.icc"
517
518#undef ASSOCIATION_CONTEXT
519#undef ASSOCIATIONMAP_CONTEXT
520#endif

◆ next()

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::next ( )
inline

forward advancement

Definition at line 161 of file AssociationMap.h.

◆ operator!=()

template<class OBJCONT, class ASSCONT>
bool AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator!= ( const AssociationObjectIterator & anOther) const
inline

inequality comparison

Parameters
anOther- an other AssociationObjectIterator

Definition at line 205 of file AssociationMap.h.

◆ operator*()

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator* ( ) const
inline

* operator returns iterator by value

Warning
This is not the standard behavior of STL-like iterators! This implementation hides the actual value type, though, because it is not the object type, as clients would probably expect. The stored objects can be accessed using the specialized methods provided by this class.

Definition at line 221 of file AssociationMap.h.

221{

◆ operator++() [1/2]

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator++ ( )
inline

post-forward advancement operator

Definition at line 169 of file AssociationMap.h.

◆ operator++() [2/2]

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator++ ( int )
inline

pre-forward advancement operator

Definition at line 177 of file AssociationMap.h.

◆ operator--() [1/2]

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator-- ( )
inline

post-backward stepping operator

Definition at line 180 of file AssociationMap.h.

185 { return this->getAssociations(objIter.getObject(),assocs); }

◆ operator--() [2/2]

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator-- ( int )
inline

pre-backward stepping operator

Definition at line 188 of file AssociationMap.h.

188{ return m_associationMap.size(); }

◆ operator->() [1/2]

template<class OBJCONT, class ASSCONT>
const object_type * AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator-> ( )
inline

access to underlying object

Definition at line 224 of file AssociationMap.h.

◆ operator->() [2/2]

template<class OBJCONT, class ASSCONT>
const object_type * AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator-> ( ) const
inline

access to underlying object

Definition at line 228 of file AssociationMap.h.

◆ operator=()

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator & AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator= ( const AssociationObjectIterator & rhs)
inline

assignment operator

Definition at line 128 of file AssociationMap.h.

◆ operator==()

template<class OBJCONT, class ASSCONT>
bool AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::operator== ( const AssociationObjectIterator & anOther) const
inline

equality comparison

Parameters
anOther- an other AssociationObjectIterator

Definition at line 197 of file AssociationMap.h.

◆ prev()

template<class OBJCONT, class ASSCONT>
AssociationObjectIterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::prev ( )
inline

backward stepping

Definition at line 165 of file AssociationMap.h.

◆ second()

template<class OBJCONT, class ASSCONT>
asso_iterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::second ( ) const
inline

access to iterator of first association

Definition at line 234 of file AssociationMap.h.

◆ size()

template<class OBJCONT, class ASSCONT>
size_t AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::size ( ) const
inline

Definition at line 304 of file AssociationMap.h.

342{
343 public:
344
347 typedef OBJCONT object_container_type;
348 typedef typename object_container_type::base_value_type object_type;
349 typedef
350 typename
351 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
352 object_index_type;
353 typedef ElementLink<object_container_type> object_link;
354 typedef typename std::list<const object_type*> object_list;
355
356 typedef ASSCONT asso_container_type;
357 typedef typename asso_container_type::base_value_type asso_type;
358 typedef
359 typename
360 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
361 asso_index_type;
362 typedef typename std::list<const asso_type*> asso_list;
363 typedef ElementLink<asso_container_type> asso_link;
364 typedef ElementLinkVector<asso_container_type> asso_store;
365 typedef typename asso_store::const_iterator asso_store_iterator;
366 typedef typename std::map<object_link,asso_store> store_type;
367 typedef typename store_type::iterator store_iterator_type;
369
370 // Dummy to allow defining an end iterator for an empty map.
371 static const asso_store s_dum_asso_store;
372
375 AssociationMap();
376 virtual ~AssociationMap();
378
379
382#include "AthLinks/tools/AssociationVectorIterator.h"
384 typedef AssociationVectorIterator asso_iterator;
385#include "AthLinks/tools/AssociationObjectIterator.h"
387 typedef AssociationObjectIterator object_iterator;
389
400 void addAssociation(const object_container_type* objectContainer,
401 const object_index_type& objectIndex,
402 const asso_container_type* assoContainer,
403 const asso_index_type& assoIndex);
404 void addAssociation(const object_container_type* objectContainer,
405 const object_type* objectPointer,
406 const asso_container_type* assoContainer,
407 const asso_type* assoPointer);
408 void addAssociation(const object_link& objectLink,
409 const asso_link& assoLink);
411
421 object_iterator beginObject() const;
423 object_iterator endObject() const;
424
426 asso_iterator beginAssociation(const object_type* objectPointer) const;
427 asso_iterator beginAssociation(const object_iterator& objectIter) const;
429 asso_iterator endAssociation(const object_type* objectPointer) const;
430 asso_iterator endAssociation(const object_iterator& objectIter) const;
432
434
435
436
438 const object_type* getObject(const object_iterator& objectIter) const
439 { return (*objectIter).getObject(); }
440
442 object_iterator findObject(const object_type* theObject) const
443 { return object_iterator(m_associationMap).find(theObject); }
444
446 bool containsObject(const object_type* theObject) const
447 { return this->findObject(theObject) != this->endObject(); }
448
450 size_t getNumberOfObjects() const { return this->size(); }
451
455
456
457 const asso_type* getAssociation(asso_iterator assoIter) const
458 { return *assoIter; }
459
461 asso_iterator findAssociation(const object_iterator& objectIter,
462 const asso_type* assoPointer) const
463 { return objectIter.findAssociation(assoPointer); }
464 asso_iterator findAssociation(const object_type* objectPointer,
465 const asso_type* assoPointer) const;
466
468 bool containsAssociation(const object_iterator& objectIter,
469 const asso_type* assoPointer) const
470 { return objectIter.containsAssociation(assoPointer); }
471
472 bool containsAssociation(const object_type* objectPointer,
473 const asso_type* assoPointer) const;
474 bool containsAssociation(const asso_type* assoPointer) const;
475
477 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
478
480 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
481 { return this->getObjects(*assoIter,theObjects); }
482
484 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
485
487 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
488 { return this->getAssociations(objIter.getObject(),assocs); }
489
491 size_t size() { return m_associationMap.size(); }
492
494 size_t size() const { return m_associationMap.size(); }
495
496 size_t size(const object_type* objectPointer) const;
497
498 size_t getNumberOfAssociations(const object_type* objectPointer) const
499 { return this->size(objectPointer); }
500
501 size_t size(const object_iterator& objectIter) const
502 { return objectIter.getNumberOfAssociations(); }
503
504 size_t getNumberOfAssociations(const object_iterator& objectIter) const
505 { return this->size(objectIter); }
506
507 protected:
508
510 store_type m_associationMap;
511
513 store_iterator_type internalFind(const object_link& objectLink,
514 const asso_link& assoLink)
515 {
516 // check key
517 store_iterator_type mapEnd = m_associationMap.end();
518 store_iterator_type foundIter = mapEnd;
519 for ( store_iterator_type iMap = m_associationMap.begin();
520 iMap != mapEnd;
521 ++iMap ) {
522 // look for the address of the pointed-at object
523 // must dereference the ElementLink pointer
524 if ( iMap->first.cptr() == objectLink.cptr() ) {
525 foundIter = iMap;
526 break;
527 }
528 }
529
530 if ( foundIter == m_associationMap.end() ) { return foundIter; }
531 // check data
532 if ( std::find((foundIter->second).begin(),
533 (foundIter->second).end(),
534 assoLink) !=
535 (foundIter->second).end() )
536 { return foundIter; }
537 // not found at all
538 return m_associationMap.end();
539 }
540
542 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
543
544};
545
546#include "AthLinks/AssociationMap.icc"
547
548#undef ASSOCIATION_CONTEXT
549#undef ASSOCIATIONMAP_CONTEXT
550#endif

Member Data Documentation

◆ m_actual

template<class OBJCONT, class ASSCONT>
store_type::const_iterator AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::m_actual {}
private

Definition at line 309 of file AssociationMap.h.

347{
348 public:
349
352 typedef OBJCONT object_container_type;
353 typedef typename object_container_type::base_value_type object_type;
354 typedef
355 typename
356 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
357 object_index_type;
358 typedef ElementLink<object_container_type> object_link;
359 typedef typename std::list<const object_type*> object_list;
360
361 typedef ASSCONT asso_container_type;
362 typedef typename asso_container_type::base_value_type asso_type;
363 typedef
364 typename
365 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
366 asso_index_type;
367 typedef typename std::list<const asso_type*> asso_list;
368 typedef ElementLink<asso_container_type> asso_link;
369 typedef ElementLinkVector<asso_container_type> asso_store;
370 typedef typename asso_store::const_iterator asso_store_iterator;
371 typedef typename std::map<object_link,asso_store> store_type;
372 typedef typename store_type::iterator store_iterator_type;
374
375 // Dummy to allow defining an end iterator for an empty map.
376 static const asso_store s_dum_asso_store;
377
380 AssociationMap();
381 virtual ~AssociationMap();
383
384
387#include "AthLinks/tools/AssociationVectorIterator.h"
389 typedef AssociationVectorIterator asso_iterator;
390#include "AthLinks/tools/AssociationObjectIterator.h"
392 typedef AssociationObjectIterator object_iterator;
394
405 void addAssociation(const object_container_type* objectContainer,
406 const object_index_type& objectIndex,
407 const asso_container_type* assoContainer,
408 const asso_index_type& assoIndex);
409 void addAssociation(const object_container_type* objectContainer,
410 const object_type* objectPointer,
411 const asso_container_type* assoContainer,
412 const asso_type* assoPointer);
413 void addAssociation(const object_link& objectLink,
414 const asso_link& assoLink);
416
426 object_iterator beginObject() const;
428 object_iterator endObject() const;
429
431 asso_iterator beginAssociation(const object_type* objectPointer) const;
432 asso_iterator beginAssociation(const object_iterator& objectIter) const;
434 asso_iterator endAssociation(const object_type* objectPointer) const;
435 asso_iterator endAssociation(const object_iterator& objectIter) const;
437
439
440
441
443 const object_type* getObject(const object_iterator& objectIter) const
444 { return (*objectIter).getObject(); }
445
447 object_iterator findObject(const object_type* theObject) const
448 { return object_iterator(m_associationMap).find(theObject); }
449
451 bool containsObject(const object_type* theObject) const
452 { return this->findObject(theObject) != this->endObject(); }
453
455 size_t getNumberOfObjects() const { return this->size(); }
456
460
461
462 const asso_type* getAssociation(asso_iterator assoIter) const
463 { return *assoIter; }
464
466 asso_iterator findAssociation(const object_iterator& objectIter,
467 const asso_type* assoPointer) const
468 { return objectIter.findAssociation(assoPointer); }
469 asso_iterator findAssociation(const object_type* objectPointer,
470 const asso_type* assoPointer) const;
471
473 bool containsAssociation(const object_iterator& objectIter,
474 const asso_type* assoPointer) const
475 { return objectIter.containsAssociation(assoPointer); }
476
477 bool containsAssociation(const object_type* objectPointer,
478 const asso_type* assoPointer) const;
479 bool containsAssociation(const asso_type* assoPointer) const;
480
482 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
483
485 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
486 { return this->getObjects(*assoIter,theObjects); }
487
489 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
490
492 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
493 { return this->getAssociations(objIter.getObject(),assocs); }
494
496 size_t size() { return m_associationMap.size(); }
497
499 size_t size() const { return m_associationMap.size(); }
500
501 size_t size(const object_type* objectPointer) const;
502
503 size_t getNumberOfAssociations(const object_type* objectPointer) const
504 { return this->size(objectPointer); }
505
506 size_t size(const object_iterator& objectIter) const
507 { return objectIter.getNumberOfAssociations(); }
508
509 size_t getNumberOfAssociations(const object_iterator& objectIter) const
510 { return this->size(objectIter); }
511
512 protected:
513
515 store_type m_associationMap;
516
518 store_iterator_type internalFind(const object_link& objectLink,
519 const asso_link& assoLink)
520 {
521 // check key
522 store_iterator_type mapEnd = m_associationMap.end();
523 store_iterator_type foundIter = mapEnd;
524 for ( store_iterator_type iMap = m_associationMap.begin();
525 iMap != mapEnd;
526 ++iMap ) {
527 // look for the address of the pointed-at object
528 // must dereference the ElementLink pointer
529 if ( iMap->first.cptr() == objectLink.cptr() ) {
530 foundIter = iMap;
531 break;
532 }
533 }
534
535 if ( foundIter == m_associationMap.end() ) { return foundIter; }
536 // check data
537 if ( std::find((foundIter->second).begin(),
538 (foundIter->second).end(),
539 assoLink) !=
540 (foundIter->second).end() )
541 { return foundIter; }
542 // not found at all
543 return m_associationMap.end();
544 }
545
547 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
548
549};
550
551#include "AthLinks/AssociationMap.icc"
552
553#undef ASSOCIATION_CONTEXT
554#undef ASSOCIATIONMAP_CONTEXT
555#endif

◆ m_store

template<class OBJCONT, class ASSCONT>
const store_type* AssociationMap< OBJCONT, ASSCONT >::AssociationObjectIterator::m_store {}
private

Definition at line 308 of file AssociationMap.h.

346{
347 public:
348
351 typedef OBJCONT object_container_type;
352 typedef typename object_container_type::base_value_type object_type;
353 typedef
354 typename
355 SG::GenerateIndexingPolicy<object_container_type>::type::index_type
356 object_index_type;
357 typedef ElementLink<object_container_type> object_link;
358 typedef typename std::list<const object_type*> object_list;
359
360 typedef ASSCONT asso_container_type;
361 typedef typename asso_container_type::base_value_type asso_type;
362 typedef
363 typename
364 SG::GenerateIndexingPolicy<asso_container_type>::type::index_type
365 asso_index_type;
366 typedef typename std::list<const asso_type*> asso_list;
367 typedef ElementLink<asso_container_type> asso_link;
368 typedef ElementLinkVector<asso_container_type> asso_store;
369 typedef typename asso_store::const_iterator asso_store_iterator;
370 typedef typename std::map<object_link,asso_store> store_type;
371 typedef typename store_type::iterator store_iterator_type;
373
374 // Dummy to allow defining an end iterator for an empty map.
375 static const asso_store s_dum_asso_store;
376
379 AssociationMap();
380 virtual ~AssociationMap();
382
383
386#include "AthLinks/tools/AssociationVectorIterator.h"
388 typedef AssociationVectorIterator asso_iterator;
389#include "AthLinks/tools/AssociationObjectIterator.h"
391 typedef AssociationObjectIterator object_iterator;
393
404 void addAssociation(const object_container_type* objectContainer,
405 const object_index_type& objectIndex,
406 const asso_container_type* assoContainer,
407 const asso_index_type& assoIndex);
408 void addAssociation(const object_container_type* objectContainer,
409 const object_type* objectPointer,
410 const asso_container_type* assoContainer,
411 const asso_type* assoPointer);
412 void addAssociation(const object_link& objectLink,
413 const asso_link& assoLink);
415
425 object_iterator beginObject() const;
427 object_iterator endObject() const;
428
430 asso_iterator beginAssociation(const object_type* objectPointer) const;
431 asso_iterator beginAssociation(const object_iterator& objectIter) const;
433 asso_iterator endAssociation(const object_type* objectPointer) const;
434 asso_iterator endAssociation(const object_iterator& objectIter) const;
436
438
439
440
442 const object_type* getObject(const object_iterator& objectIter) const
443 { return (*objectIter).getObject(); }
444
446 object_iterator findObject(const object_type* theObject) const
447 { return object_iterator(m_associationMap).find(theObject); }
448
450 bool containsObject(const object_type* theObject) const
451 { return this->findObject(theObject) != this->endObject(); }
452
454 size_t getNumberOfObjects() const { return this->size(); }
455
459
460
461 const asso_type* getAssociation(asso_iterator assoIter) const
462 { return *assoIter; }
463
465 asso_iterator findAssociation(const object_iterator& objectIter,
466 const asso_type* assoPointer) const
467 { return objectIter.findAssociation(assoPointer); }
468 asso_iterator findAssociation(const object_type* objectPointer,
469 const asso_type* assoPointer) const;
470
472 bool containsAssociation(const object_iterator& objectIter,
473 const asso_type* assoPointer) const
474 { return objectIter.containsAssociation(assoPointer); }
475
476 bool containsAssociation(const object_type* objectPointer,
477 const asso_type* assoPointer) const;
478 bool containsAssociation(const asso_type* assoPointer) const;
479
481 bool getObjects(const asso_type* assoPointer, object_list& theObjects) const;
482
484 bool getObjects(const asso_iterator& assoIter, object_list& theObjects) const
485 { return this->getObjects(*assoIter,theObjects); }
486
488 bool getAssociations(const object_type* objPointer, asso_list& assocs) const;
489
491 bool getAssociations(const object_iterator& objIter, asso_list& assocs) const
492 { return this->getAssociations(objIter.getObject(),assocs); }
493
495 size_t size() { return m_associationMap.size(); }
496
498 size_t size() const { return m_associationMap.size(); }
499
500 size_t size(const object_type* objectPointer) const;
501
502 size_t getNumberOfAssociations(const object_type* objectPointer) const
503 { return this->size(objectPointer); }
504
505 size_t size(const object_iterator& objectIter) const
506 { return objectIter.getNumberOfAssociations(); }
507
508 size_t getNumberOfAssociations(const object_iterator& objectIter) const
509 { return this->size(objectIter); }
510
511 protected:
512
514 store_type m_associationMap;
515
517 store_iterator_type internalFind(const object_link& objectLink,
518 const asso_link& assoLink)
519 {
520 // check key
521 store_iterator_type mapEnd = m_associationMap.end();
522 store_iterator_type foundIter = mapEnd;
523 for ( store_iterator_type iMap = m_associationMap.begin();
524 iMap != mapEnd;
525 ++iMap ) {
526 // look for the address of the pointed-at object
527 // must dereference the ElementLink pointer
528 if ( iMap->first.cptr() == objectLink.cptr() ) {
529 foundIter = iMap;
530 break;
531 }
532 }
533
534 if ( foundIter == m_associationMap.end() ) { return foundIter; }
535 // check data
536 if ( std::find((foundIter->second).begin(),
537 (foundIter->second).end(),
538 assoLink) !=
539 (foundIter->second).end() )
540 { return foundIter; }
541 // not found at all
542 return m_associationMap.end();
543 }
544
546 bool addToStore(const object_link& objectLink, const asso_link& assoLink);
547
548};
549
550#include "AthLinks/AssociationMap.icc"
551
552#undef ASSOCIATION_CONTEXT
553#undef ASSOCIATIONMAP_CONTEXT
554#endif
The documentation for this class was generated from the following file:
Generated on for ATLAS Offline Software by doxygen 1.14.0