A/AthLinks/DataLink.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
/*
 Copyright (C) 2002-2024 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):
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 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();
 
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