A/AthLinks/DataLink.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_DATALINK_H
#define ATHLINKS_DATALINK_H
 
// System include(s):
extern "C" {
#   include <stdint.h>
}
#include <string>
#include <RootMetaSelection.h>
 
// Local include(s):
#include "AthLinks/DataLinkBase.h"
 
// Forward declaration(s):
class EventContext;
namespace xAOD {
   class TVirtualEvent;
}
namespace ROOT { namespace Meta { namespace Selection {
   template< class STORABLE >
   class DataLink;
}}}

template< typename STORABLE >
class DataLink : public DataLinkBase {
 
public:

   typedef std::string ID_type;
   typedef uint32_t sgkey_t;

   typedef STORABLE value_type;
   typedef STORABLE* __attribute__((deprecated)) pointer;
   typedef const STORABLE* const_pointer;
   typedef STORABLE& __attribute__((deprecated)) reference;
   typedef const STORABLE& const_reference;



   DataLink();

   DataLink( xAOD::TVirtualEvent* event );

   DataLink( const_reference data, xAOD::TVirtualEvent* event = 0 );

   DataLink( const_pointer data, xAOD::TVirtualEvent* event = 0 );

   DataLink( const_pointer data, const EventContext& );

   DataLink( const ID_type& id, xAOD::TVirtualEvent* event = 0 );

   DataLink( sgkey_t key, xAOD::TVirtualEvent* event = 0 );

   template< typename T >
   DataLink( const DataLink< T >& parent );



   void toStorableObject( const_reference data );

   void toDefaultObject();

   void toIdentifiedObject( const ID_type& id );
   void toIdentifiedObject( sgkey_t key );



   const_reference operator*() const;
   const_pointer operator->() const { return cptr(); }

   operator const_pointer() const { return cptr(); }

   const_pointer cptr() const;

   bool isValid() const;

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

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


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

   bool toPersistent();

   bool toTransient( const EventContext& ) { return false; }
 
private:
   virtual bool toTransient();
   void findIdentifier();

   mutable const_pointer m_object;
   xAOD::TVirtualEvent* m_event;

   typedef typename ROOT::Meta::Selection::DataLink< STORABLE >::self DictSel;
 
}; // class DataLink
 
/*
 * The following piece of code declares the member variables of all
 * DataLink<T> types as transient.
 */
namespace ROOT { namespace Meta { namespace Selection {
template< class STORABLE >
class DataLink : public SelectNoInstance
{
 
public:
   typedef DataLink< STORABLE > self;

   ROOT::Meta::Selection::MemberAttributes< kTransient > m_object;
   ROOT::Meta::Selection::MemberAttributes< kTransient > m_event;
 
};
}}} // ROOT namespace

template< typename STORABLE >
bool operator==( const DataLink< STORABLE >& a,
                 const DataLink< STORABLE >& b );

template< typename STORABLE >
bool operator!=( const DataLink< STORABLE >& a,
                 const DataLink< STORABLE >& b );
 
// Include the implementation:
#ifndef __GCCXML__
#   include "DataLink.icc"
#endif // __GCCXML__
 
#endif // ATHLINKS_DATALINK_H