AthLinks/ElementLink.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_ELEMENTLINK_H
#define ATHLINKS_ELEMENTLINK_H
 
 
#include "AthLinks/tools/ElementLinkTraits.h"
#include "AthLinks/DataLink.h"
#include "AthenaKernel/IProxyDict.h"
#include "GaudiKernel/EventContext.h"
#include <utility>
 
 
template <class STORABLE>
class ElementLink
  : public SG::ElementLinkTraits<STORABLE>::Base
{
private:
  typedef SG::ElementLinkTraits<STORABLE> Traits;
 
  typedef typename Traits::Base Base;
 
  typedef typename Base::castfn_t castfn_t;
 
 
public:
  typedef typename Traits::IndexingPolicy IndexingPolicy;
 
  typedef typename IndexingPolicy::index_type index_type; 
 
  typedef typename Base::sgkey_t sgkey_t;
 
  typedef typename Base::ID_type ID_type;
 
  typedef STORABLE                      value_type;
  typedef STORABLE*                     pointer;
  typedef const STORABLE*               const_pointer;
  typedef const STORABLE& BaseConstReference;
  typedef const STORABLE* BaseConstPointer;
 
 
  typedef typename IndexingPolicy::ElementType ElementType;
  typedef typename IndexingPolicy::ElementConstReference ElementConstReference;
  typedef typename IndexingPolicy::ElementConstPointer ElementConstPointer;
 
 
  static const CLID& classID();
 
 
  //========================================================================
 
 
  ElementLink();
 
 
  ElementLink(const ID_type& dataID, index_type elemID,
              IProxyDict* sg = 0);
 
 
  ElementLink(const ID_type& dataID, index_type elemID,
              const EventContext& ctx);
 
 
  ElementLink(sgkey_t key, index_type elemID, IProxyDict* sg = 0);
 
 
  ElementLink(sgkey_t key, index_type elemID, const EventContext& ctx);
 
 
  ElementLink(const ID_type& dataID,
              index_type elemID,
              ElementType pEl,
              IProxyDict* sg = 0);
 
 
  ElementLink(const ID_type& dataID,
              index_type elemID,
              ElementType pEl,
              const EventContext& ctx);
 
 
  ElementLink (sgkey_t key,
               index_type elemID,
               ElementType pEl,
               IProxyDict* sg = 0);
 
 
  ElementLink (sgkey_t key,
               index_type elemID,
               ElementType pEl,
               const EventContext& ctx);
 
 
  ElementLink (BaseConstReference data,
               index_type elemID, 
               IProxyDict* sg = 0);
 
 
  ElementLink (BaseConstReference data,
               index_type elemID, 
               const EventContext& ctx);
 
 
  ElementLink (const ElementType& element, 
               BaseConstReference data,
               IProxyDict* sg = 0);
 
 
  ElementLink (const ElementType& element, 
               BaseConstReference data,
               const EventContext& ctx);
 
 
  ElementLink (const ElementLink& other, index_type elemID);
 
 
  ElementLink (const DataLink<STORABLE>& dlink, index_type index);
 
 
  // Use default copy ctor.
 
 
  template <class U>
  ElementLink (const ElementLink<U>& other);
 
 
  // Default copy and assignment.
  ElementLink (const ElementLink&) = default;
  ElementLink& operator= (const ElementLink&) = default;
 
 
  //@)
  //========================================================================
 
 
  const_pointer getDataPtr() const;
 
 
  pointer getDataNonConstPtr();
 
 
  DataLink<STORABLE> getDataLink();
 
 
  const DataLink<STORABLE> getDataLink() const;
 
 
  BaseConstPointer getStorableObjectPointer() const;
 
 
  BaseConstReference getStorableObjectRef() const;
 
 
  ElementConstPointer cptr() const;
 
 
  ElementConstReference operator* () const;
 
 
  ElementConstPointer operator->() const;
 
 
  operator ElementConstPointer () const;
 
 
  bool isValid() const;
 
 
  bool operator!() const;
 
 
  ElementType cachedElement() const;
 
 
 
  //@)
  //========================================================================
 
 
  bool toIndexedElement(BaseConstReference data, index_type elemID,
                        IProxyDict* sg = 0);
 
 
  bool toIndexedElement(BaseConstReference data, index_type elemID,
                        const EventContext& ctx);
 
 
  bool toContainedElement(BaseConstReference data,
                          ElementType element,
                          IProxyDict* sg = 0);
 
 
  bool toContainedElement(BaseConstReference data,
                          ElementType element,
                          const EventContext& ctx);
 
 
  bool setElement(ElementType element);
 
 
  bool setStorableObject(BaseConstReference data,
                         bool replace=false,
                         IProxyDict* sg = 0);
 
 
  bool setStorableObject(BaseConstReference data,
                         bool replace,
                         const EventContext& ctx);
 
 
  void resetWithKeyAndIndex(const ID_type& dataID, index_type elemID, 
                            IProxyDict* sg=0);
 
 
  void resetWithKeyAndIndex(const ID_type& dataID, index_type elemID, 
                            const EventContext& ctx);
 
 
  void resetWithKeyAndIndex(sgkey_t key, index_type elemID, 
                            IProxyDict* sg=0);
 
 
  void resetWithKeyAndIndex(sgkey_t key, index_type elemID, 
                            const EventContext& ctx);
 
 
 
 
  // Inherited from base class:
  //  bool isDefaultIndex() const
  //   Test the index validity.
  //  bool hasCachedElement() const
  //   Test to see if this link has a cached element pointer.
  //  bool isDefault() const
  //   Test to see if this link is in the default state.
  //  index_type index() const
  //   Return the index of the link.
  //  ID_type dataID() const
  //   Return the SG key that we reference, as a string.
  //  sgkey_t key() const
  //   Return the SG key that we reference, as a hash.
  //  IProxyDict* source() const
  //   Return the data source for the reference.
  //  void reset()
  //   Reset the link to a null state.
  //  bool toTransient (IProxyDict*)
  //   Finish initialization after link has been read.
  //  bool doPersistent()
  //   Prepare this link for writing.
  //  bool thin()
  //  bool thin(const SG::ThinningCache* thinningCache)
  //   Adjust for thinning.
 
 
private:
  const void* storable() const;
 
 
  void* storableNonConst();
};
 
 
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);
 
 
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);
 
 
namespace SG_detail {
 
 
inline
bool checkForRemap (IProxyDict* sg,
                    SG::sgkey_t sgkey_in,
                    size_t index_in,
                    SG::sgkey_t& sgkey_out,
                    size_t& index_out);
 
 
template <class T>
inline
bool checkForRemap (IProxyDict* sg,
                    SG::sgkey_t sgkey_in,
                    const T& /*dum_in*/,
                    SG::sgkey_t& sgkey_out,
                    T& /*dum_out*/);
 
 
} // namespace SG_detail
 
 
namespace std {
 
 
template <typename CONT, typename T2>
struct pair<ElementLink<CONT>, T2>
{
  // Standard pair types.
  typedef ElementLink<CONT> first_type;
  typedef T2 second_type;
 
  // Standard pair members.
  first_type  first;
  second_type second;
 
  // Standard pair constructors.
  pair() : first(), second() {}
  pair (const first_type& x, const second_type& y) : first (x), second (y) {}
  template <class U, class V>
  pair (const pair<U, V>& p) : first (p.first), second (p.second) {}
 
  // Helper type.
  typedef typename SG::GenerateIndexingPolicy<CONT>::type::index_type
    external_index_type;
 
  // Extra constructor to allow avoiding a temporary for the
  // @c ElementLink initialization.
  pair (const CONT& child_container,
        const external_index_type& index,
        const T2& y)
    : first (child_container, index), second (y)
  {}
 
  // Extra constructor to allow avoiding a temporary for the
  // @c ElementLink initialization.
  pair (const CONT& child_container,
        const external_index_type& index,
        IProxyDict* sg,
        const T2& y)
    : first (child_container, index, sg), second (y)
  {}
 
  void swap (pair& p)
  {
    std::swap (first, p.first);
    std::swap (second, p.second);
  }
};
 
 
} // namespace std
 
 
#include "AthLinks/ElementLink.icc"
 
 
#endif // not ATHLINKS_ELEMENTLINK_H