AthLinks/DataLink.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef ATHLINKS_DATALINK_H
#define ATHLINKS_DATALINK_H
 
 
#include "AthLinks/DataLinkBase.h"
#include "AthenaKernel/ClassID_traits.h"
#include "AthContainersInterfaces/ToTransient.h"
#include "AthenaKernel/proxyDictFromEventContext.h"
#include "AthenaKernel/DefaultKey.h"
#include <format>
#include <vector>
class EventContext;
class IProxyDict;
 

template <class STORABLE>
class DataLink
  : public DataLinkBase
{
public:
  typedef STORABLE                      value_type;
  typedef STORABLE*                     pointer;
  typedef const STORABLE*               const_pointer;
  typedef STORABLE&                     reference;
  typedef const STORABLE&               const_reference;

  typedef DataLinkBase::ID_type ID_type;

  typedef DataLinkBase::sgkey_t sgkey_t;
 

  static CLID classID();
 
 
  //========================================================================
 

  DataLink();
 

  DataLink(const_reference data, IProxyDict* sg=0);
 

  DataLink(const_reference data, const EventContext& ctx);
 

  DataLink(const_pointer pdata, IProxyDict* sg=0);
 

  DataLink(const_pointer pdata, const EventContext& ctx);
 

  DataLink(const ID_type& dataID, IProxyDict* sg=0);
 

  DataLink(const ID_type& dataID, const EventContext& ctx);
 

  DataLink(sgkey_t key, IProxyDict* sg=0);
 

  DataLink(sgkey_t key, const EventContext& ctx);
 

  DataLink(sgkey_t key, const SG::DataProxyHolder& holder);
 

  //========================================================================
 

  void toStorableObject(const_reference data, IProxyDict* sg = 0);
 

  void toStorableObject(const_reference data, const EventContext& ctx);
 

  void toIdentifiedObject(const ID_type& dataID, IProxyDict* sg = 0);
 

  void toIdentifiedObject(const ID_type& dataID, const EventContext& ctx);
 

  void toIdentifiedObject(sgkey_t key, IProxyDict* sg = 0);
 

  void toIdentifiedObject(sgkey_t key, const EventContext& ctx);
 

  void toDefaultObject (IProxyDict* sg = 0);
 

  void toDefaultObject (const EventContext& ctx);
 

  bool toTransient (IProxyDict* sg = 0);
 

  bool toTransient (const EventContext& ctx);
 

  bool toTransient (const ID_type& dataID, IProxyDict* sg = 0);
  

  bool toTransient (const ID_type& dataID, const EventContext& ctx);
  
 

  //========================================================================

  const_pointer getDataPtr() const;
 

  pointer getDataNonConstPtr();
 

  const_reference operator* () const;
 

  const_pointer operator->() const;
 

  operator const_pointer() const;
 

  const_pointer cptr() const;
 

  bool isValid() const; 
 
 

  bool operator!() const;
 
 
  // Inherited from base class:
  //   bool isDefault() const;
  //   const ID_type& dataID() const;
  //   sgkey_t key() const;
  //   void clear();
  //   SG::DataProxy* proxy (bool nothrow = false) const;
  //   IProxyDict* source() const;
  //   bool toPersistent();
  //   bool toPersistentNoRemap();
  //   bool operator== (const DataLinkBase& other) const;
  //   bool operator!= (const DataLinkBase& other) const;
 
 
private:
  const void* storable() const;
 

  void* storableNonConst();
};
 
 
namespace SG {
 

template <class STORABLE>
class ToTransient<DataLink<STORABLE> >
{
public:
  static void toTransient (DataLink<STORABLE>& dl,
                           IProxyDict* sg = nullptr);
  static void toTransient (DataLink<STORABLE>& dl,
                           const EventContext& ctx);
};
 

template <class STORABLE, class ALLOC>
class ToTransient<std::vector<DataLink<STORABLE>, ALLOC> >
{
public:
  static void toTransient (std::vector<DataLink<STORABLE>, ALLOC>& dlv,
                           IProxyDict* sg = nullptr);
  static void toTransient (std::vector<DataLink<STORABLE>, ALLOC>& dlv,
                           const EventContext& ctx);
};
 

template <class STORABLE, class ALLOC1, class ALLOC2>
class ToTransient<std::vector<std::vector<DataLink<STORABLE>, ALLOC1>, ALLOC2> >
{
public:
  static void toTransient (std::vector<std::vector<DataLink<STORABLE>, ALLOC1>, ALLOC2>& dlvv,
                           IProxyDict* sg = nullptr);
  static void toTransient (std::vector<std::vector<DataLink<STORABLE>, ALLOC1>, ALLOC2>& dlvv,
                           const EventContext& ctx);
};
 
 
 
} // namespace SG
 
 
namespace std {
 
 
// C++20 compatible formatter.
template <class T>
struct formatter<DataLink<T> >
  : public formatter<string_view>
{
  template <class FmtContext>
  FmtContext::iterator format(const DataLink<T>& k, FmtContext& ctx) const
  {
    if (k.isDefault()) {
      return formatter<string_view>::format ("(nullLink)", ctx);
    }
    return std::format_to (ctx.out(), "@{}", k.dataID());
  }
};
 
 
} // namespace std
 
 
#include "AthLinks/DataLink.icc"
 
 
#endif // not ATHLINKS_DATALINK_H