GenericElementLinkBase.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-2024 CERN for the benefit of the ATLAS collaboration
*/

 
 
#ifndef ATHLINKS_GENERICELEMENTLINKBASE_H
#define ATHLINKS_GENERICELEMENTLINKBASE_H
 
 
#include "AthLinks/tools/DataProxyHolder.h"
#include "AthLinks/DataLinkBase.h"
#include "AthenaKernel/getThinningCache.h"
#include "AthenaKernel/proxyDictFromEventContext.h"
#include "CxxUtils/CachedValue.h"
#include "CxxUtils/checker_macros.h"
#include <concepts>
#include <RootMetaSelection.h>
 
 
// Forward declaration(s):
namespace ROOT { namespace Meta { namespace Selection {
  namespace SG {
    template< class INDEXING_POLICY >
    struct GenericElementLinkBase;
  }
}}}
 
 
template <class POLICY>
class ElementLinkBaseT_test;
 
 
namespace SG {
 
 
class ThinningCache;
 

template <class INDEXING_POLICY>
class GenericElementLinkBase
{
private:
  typedef typename INDEXING_POLICY::ElementType ElementType;
  typedef typename INDEXING_POLICY::ElementConstPointer ElementConstPointer;

  typedef SG::DataProxyHolder::const_pointer_t const_pointer_t;
 
 
public:
  typedef typename INDEXING_POLICY::index_type index_type;

  typedef typename INDEXING_POLICY::stored_index_type stored_index_type;

  typedef SG::DataProxyHolder::sgkey_t sgkey_t;

  typedef SG::DataProxyHolder::ID_type ID_type;

  typedef void* castfn_t (SG::DataProxy*);
 
 
public:
  bool isDefaultIndex() const;
 

  bool hasCachedElement() const;
 

  bool isDefault() const;
 

  index_type index() const;
 

  const ID_type& dataID() const;
 

  sgkey_t key() const;
 

  IProxyDict* source() const;
 

  const SG::DataProxy* proxy() const;
 

  void reset ();
 

  bool toTransient (IProxyDict* sg = 0);
 

  bool toPersistent();
 

  bool thin();
 

  bool thin (const SG::ThinningCache* thinningCache);
 
 
protected:
  GenericElementLinkBase();
 

  GenericElementLinkBase (const ID_type& dataID,
                          CLID link_clid,
                          const index_type& elemID,
                          IProxyDict* sg);
 

  GenericElementLinkBase (sgkey_t key,
                          CLID link_clid,
                          const index_type& elemID,
                          IProxyDict* sg);
 

  GenericElementLinkBase (const ID_type& dataID,
                          CLID link_clid,
                          const index_type& elemID,
                          const ElementType& elt,
                          IProxyDict* sg);
 

  GenericElementLinkBase (sgkey_t key,
                          CLID link_clid,
                          const index_type& elemID,
                          const ElementType& elt,
                          IProxyDict* sg);
 

  GenericElementLinkBase (const_pointer_t obj,
                          CLID link_clid,
                          const index_type& elemID,
                          IProxyDict* sg);
 

  GenericElementLinkBase (const GenericElementLinkBase& other,
                          const index_type& elemID);
 

  GenericElementLinkBase (const DataLinkBase& dlink,
                          const index_type& index);
 

  template <class OTHER_INDEXING_POLICY, class FROM_TRAITS, class TO_TRAITS>
  GenericElementLinkBase (const GenericElementLinkBase<OTHER_INDEXING_POLICY>& other,
                          FROM_TRAITS*, TO_TRAITS*);
 
 
  GenericElementLinkBase (const GenericElementLinkBase&) = default;
  GenericElementLinkBase& operator= (const GenericElementLinkBase&) = default;
 

  void* storableBase (castfn_t* castfn, const CLID& clid, bool isConst) const;
 

  bool setStorableObject (const_pointer_t data,
                          CLID link_clid,
                          bool replace,
                          IProxyDict* sg);
 

  bool toIndexedElement (const_pointer_t obj,
                         CLID link_clid,
                         const index_type& elemID,
                         IProxyDict* sg);
 

  void resetWithKeyAndIndex (const ID_type& dataID,
                             CLID link_clid,
                             const index_type& elemID, 
                             IProxyDict* sg);
 

  void resetWithKeyAndIndex (sgkey_t key,
                             CLID link_clid,
                             const index_type& elemID, 
                             IProxyDict* sg);
 

  void setIndex (const index_type& index);
 

  const stored_index_type& storedIndex() const;
 

  void setCachedElement (const ElementType& elt) const;
 

  void storeCachedElement (const ElementType& elt);
 

  bool getCachedElement (ElementConstPointer& elt) const;
 

  const SG::DataProxyHolder& proxyHolder() const;
 
 
private:
  template <class INDEX>
  requires (std::convertible_to<INDEX, size_t> &&
            std::convertible_to<size_t, INDEX>)
  bool thin1 (INDEX& persIndex,const SG::ThinningCache* thinningCache);
 

  template <class INDEX>
  requires (!(std::convertible_to<INDEX, size_t> &&
              std::convertible_to<size_t, INDEX>))
  bool thin1 (INDEX& persIndex,const SG::ThinningCache* thinningCache);
 
 
  template <class OTHER_POLICY>
  friend class GenericElementLinkBase;

  template <class POLICY>
  friend class ::ElementLinkBaseT_test;

  SG::sgkey_t m_key;

  stored_index_type m_index;

  SG::DataProxyHolder m_proxy;  

  CxxUtils::CachedValue<ElementType> m_element; 
 
  
  typedef typename
  ROOT::Meta::Selection::SG::GenericElementLinkBase<INDEXING_POLICY>::self DictSel;
};
 
 
} // namespace SG
 

namespace ROOT { namespace Meta { namespace Selection {
namespace SG {
template <class INDEXING_POLICY>
struct GenericElementLinkBase : SelectNoInstance {
  typedef GenericElementLinkBase<INDEXING_POLICY> self;
  ROOT::Meta::Selection::MemberAttributes<kTransient> m_proxy;
  ROOT::Meta::Selection::MemberAttributes<kTransient> m_cacheValid;
  ROOT::Meta::Selection::MemberAttributes<kTransient> m_element;
};
 
}
}}} // ROOT namespace
 
 
#include "AthLinks/GenericElementLinkBase.icc"
namespace SG {
 
 
template <class INDEXING_POLICY>
bool toTransient (GenericElementLinkBase<INDEXING_POLICY>& el, IProxyDict* sg)
{
  el.toTransient (sg);
  return true;
}
 
 
template <class INDEXING_POLICY>
bool toTransient (GenericElementLinkBase<INDEXING_POLICY>& el, const EventContext& ctx)
{
  el.toTransient (Atlas::proxyDictFromEventContext (ctx));
  return true;
}
 
 
} // namespace SG
 
 
 
 
#endif // not ATHLINKS_GENERICELEMENTLINKBASE_H