A/AthLinks/ElementLink.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
/*
 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 */
#ifndef ATHLINKS_ELEMENTLINK_H
#define ATHLINKS_ELEMENTLINK_H
 
// System include(s):
extern "C" {
#   include <stdint.h>
}
#include <string>
#include <RootMetaSelection.h>
 
// Local include(s):
#include "AthLinks/ElementLinkBase.h"
#include "AthLinks/tools/TypeTools.h"
 
// Forward declaration(s):
namespace ROOT { namespace Meta { namespace Selection {
  template< typename STORABLE >
  class ElementLink;
}}}
namespace xAOD {
   class TVirtualEvent;
}
class EventContext;

template< typename STORABLE >
class ElementLink : public ElementLinkBase {
 
public:

   typedef std::string ID_type;
   typedef uint32_t sgkey_t;

   typedef const STORABLE& BaseConstReference;
   typedef const STORABLE* BaseConstPointer;

   typedef size_t index_type;

   typedef typename STORABLE::value_type value_type;
   typedef typename STORABLE::const_iterator const_iterator;

   typedef typename TypeTools::Copy< value_type >::type ElementType;
   typedef typename TypeTools::Copy< value_type >::const_reference
      ElementConstReference;
   typedef typename TypeTools::Copy< value_type >::const_pointer
      ElementConstPointer;



   ElementLink();
   ElementLink( xAOD::TVirtualEvent* event );

   ElementLink( const ID_type& key, index_type index,
                xAOD::TVirtualEvent* event = 0 );
   ElementLink( sgkey_t id, index_type index,
                xAOD::TVirtualEvent* event = 0 );

   ElementLink( const ID_type& key, index_type index, ElementType element,
                xAOD::TVirtualEvent* event = 0 );
   ElementLink( sgkey_t id, index_type index, ElementType element,
                xAOD::TVirtualEvent* event = 0 );

   ElementLink( BaseConstReference container, index_type index,
                xAOD::TVirtualEvent* event = 0 );
   ElementLink( ElementType element, BaseConstReference container,
                xAOD::TVirtualEvent* event = 0 );

   ElementLink( const ElementLink& parent );

   ElementLink( const ID_type& key, index_type index,
                const EventContext& ctx );
   ElementLink( sgkey_t id, index_type index,
                const EventContext& ctx );
   ElementLink( const ID_type& key, index_type index, ElementType element,
                const EventContext& ctx );
   ElementLink( sgkey_t id, index_type index, ElementType element,
                const EventContext& ctx );
   ElementLink( BaseConstReference container, index_type index,
                const EventContext& ctx );
   ElementLink( ElementType element, BaseConstReference container,
                const EventContext& ctx );


   ElementLink& operator=( const ElementLink& rhs );


   bool toIndexedElement( BaseConstReference container, index_type index );
   bool toContainedElement( BaseConstReference container, ElementType element );

   bool setElement( ElementType element );
   bool setStorableObject( BaseConstReference data, bool replace = false );

   void resetWithKeyAndIndex( const ID_type& key, index_type index,
                              xAOD::TVirtualEvent* event = 0 );
   void resetWithKeyAndIndex( sgkey_t id, index_type index,
                              xAOD::TVirtualEvent* event = 0 );
   void reset();



   BaseConstPointer getStorableObjectPointer() const;
   BaseConstReference getStorableObjectRef() const;

   index_type index() const { return persIndex(); }

   const ID_type& dataID() const;
   sgkey_t key() const { return persKey(); }

   bool operator==( const ElementLink& rhs ) const;
   bool operator!=( const ElementLink& rhs ) const;

   ElementConstReference operator*() const;

   ElementConstPointer operator->() const { return cptr(); }
   operator ElementConstPointer () const { return cptr(); }
   ElementConstPointer cptr() const;

   bool isValid() const;
   bool operator!() const { return ! isValid(); }

   ElementType cachedElement() const { return m_element; }
   bool hasCachedElement() const { return m_elementCached; }


   xAOD::TVirtualEvent* source() const { return m_event; }

   bool toPersistent() { return true; }
 
private:
   virtual bool toTransient();
   void findIdentifier();
   void findIndex();

   mutable BaseConstPointer m_container;
   mutable ElementType m_element;
   mutable bool m_elementCached;
   xAOD::TVirtualEvent* m_event;

   typedef typename
   ROOT::Meta::Selection::ElementLink< STORABLE >::self DictSel;
 
}; // class ElementLink
 
template <typename STORABLE>
bool operator< (const ElementLink<STORABLE> &lhs,
                const ElementLink<STORABLE> &rhs);
 
template <typename STORABLE>
bool operator> (const ElementLink<STORABLE> &lhs,
                const ElementLink<STORABLE> &rhs);
 
/*
 * The following piece of code declares all members of the ElementLink
 * class as transient.
 */
namespace ROOT { namespace Meta { namespace Selection {
template< typename STORABLE >
class ElementLink : public SelectNoInstance
{
 
public:
   typedef ElementLink< STORABLE > self;

   ROOT::Meta::Selection::MemberAttributes< kTransient > m_container;
   ROOT::Meta::Selection::MemberAttributes< kTransient > m_element;
   ROOT::Meta::Selection::MemberAttributes< kTransient > m_elementCached;
   ROOT::Meta::Selection::MemberAttributes< kTransient > m_event;
 
};
}}} // ROOT namespace
 
// Include the implementation:
#ifndef __GCCXML__
#   include "ElementLink.icc"
#endif // __GCCXML__
 
#endif // ATHLINKS_ELEMENTLINK_H