AuxElement.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-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef ATHCONTAINERS_AUXELEMENTBASE_H
#define ATHCONTAINERS_AUXELEMENTBASE_H
 
 
#include "AthContainersInterfaces/IAuxElement.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthLinks/DataLink.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthContainers/TypelessConstAccessor.h"
#include "AthContainers/ConstAccessor.h"
#include "AthContainers/Accessor.h"
#include "AthContainers/Decorator.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/tools/likely.h"
#include "CxxUtils/span.h"
#include <cstddef>
 
 
// In non-analysis builds, warn about uses of auxdata/auxdecor.
// @c XAOD_DEPRECATE_AUXDATA may be set directly to override this; for example,
// in unit tests.
#ifndef XAOD_DEPRECATE_AUXDATA
# if defined(XAOD_ANALYSIS)
#  define XAOD_DEPRECATE_AUXDATA 0
# else
#  define XAOD_DEPRECATE_AUXDATA 1
# endif
#endif
#if XAOD_DEPRECATE_AUXDATA
# define XAOD_AUXDATA_DEPRECATED [[deprecated("auxdata/auxdecor are deprecated in non-analysis builds.  Use SG::ConstAccessor/SG::Accessor/SG::Decorator instead.")]]
#else
# define XAOD_AUXDATA_DEPRECATED
#endif
 
 
 
namespace SG {
 
 
class AuxElement;
class AuxElementData;
class AuxElementStandaloneData;
class AuxVectorData_test;
class AuxVectorBase;
class AuxVectorBase_test;
 

class ConstAuxElement
  : public SG::IAuxElement
{
public:
  ConstAuxElement();
 

  ConstAuxElement (const SG::AuxVectorData* container,  size_t index);
 

  ConstAuxElement (const ConstAuxElement& other);
 

  ConstAuxElement& operator= (const ConstAuxElement& other) = delete;
 

  ~ConstAuxElement();
 

  const SG::AuxVectorData* container() const;
 

  using IAuxElement::index;
 

  using TypelessConstAccessor = SG::TypelessConstAccessor;

  template <class T, class ALLOC = AuxAllocator_t<T> >
  using ConstAccessor = SG::ConstAccessor<T, ALLOC>;

  template <class T, class ALLOC = AuxAllocator_t<T> >
  using Decorator = SG::Decorator<T, ALLOC>;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename ConstAccessor<T, ALLOC>::const_reference_type
  auxdata (const std::string& name) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename ConstAccessor<T, ALLOC>::const_reference_type
  auxdata (const std::string& name,
           const std::string& clsname) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename ConstAccessor<T, ALLOC>::const_reference_type
  auxdataConst (const std::string& name) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename ConstAccessor<T, ALLOC>::const_reference_type
  auxdataConst (const std::string& name,
                const std::string& clsname) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  bool isAvailable (const std::string& name,
                    const std::string& clsname = "") const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  bool isAvailableWritableAsDecoration (const std::string& name,
                                        const std::string& clsname = "") const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Decorator<T, ALLOC>::reference_type
  auxdecor (const std::string& name) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Decorator<T, ALLOC>::reference_type
  auxdecor (const std::string& name,
            const std::string& clsname) const;
 

  const SG::auxid_set_t& getAuxIDs() const;
 

  const SG::auxid_set_t& getDecorIDs() const;
 
 
private:
  friend class AuxElement;
  friend class SG::AuxVectorBase;
 

  void releasePrivateStoreForDtor();
 

  void setIndex (size_t index, const SG::AuxVectorData* container);
 

  bool setIndexPrivate (size_t index, const SG::AuxVectorData* container);
 

  const SG::AuxVectorData* m_container;
};
 
 
//***************************************************************************
 

class AuxElement
#ifdef ATHCONTAINERS_R21_COMPAT
  : public SG::IAuxElement
#else
  : public ConstAuxElement
#endif
{
public:
  AuxElement();
 

  AuxElement (SG::AuxVectorData* container,  size_t index);
 
 

  AuxElement (const AuxElement& other);
 

  AuxElement& operator= (const AuxElement& other);
 

  void assign (const AuxElement& other, bool warnUnlocked = false);
 

  ~AuxElement();
 

  const SG::AuxVectorData* container() const;
 

  SG::AuxVectorData* container();
 

  using IAuxElement::index;
 
 
  using TypelessConstAccessor = ConstAuxElement::TypelessConstAccessor;
 
  template <class T, class ALLOC = AuxAllocator_t<T> >
  using ConstAccessor = SG::ConstAccessor<T, ALLOC>;
 
  template <class T, class ALLOC = AuxAllocator_t<T> >
  using Accessor = SG::Accessor<T, ALLOC>;
 
  template <class T, class ALLOC = AuxAllocator_t<T> >
  using Decorator = SG::Decorator<T, ALLOC>;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Accessor<T, ALLOC>::reference_type
  auxdata (const std::string& name);
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Accessor<T, ALLOC>::reference_type
  auxdata (const std::string& name,
           const std::string& clsname);
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Accessor<T, ALLOC>::const_reference_type
  auxdata (const std::string& name) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Accessor<T, ALLOC>::const_reference_type
  auxdata (const std::string& name,
           const std::string& clsname) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Accessor<T, ALLOC>::const_reference_type
  auxdataConst (const std::string& name) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Accessor<T, ALLOC>::const_reference_type
  auxdataConst (const std::string& name,
                const std::string& clsname) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  bool isAvailable (const std::string& name,
                    const std::string& clsname = "") const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED 
  bool isAvailableWritable (const std::string& name,
                            const std::string& clsname = "");
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  bool isAvailableWritableAsDecoration (const std::string& name,
                                        const std::string& clsname = "") const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Decorator<T, ALLOC>::reference_type
  auxdecor (const std::string& name) const;
 

  template <class T, class ALLOC = AuxAllocator_t<T> >
  XAOD_AUXDATA_DEPRECATED
  typename Decorator<T, ALLOC>::reference_type
  auxdecor (const std::string& name,
            const std::string& clsname) const;
 

  void makePrivateStore();
 

  template <class U1>
  void makePrivateStore (const U1& other,
                         bool warnUnlocked = false);
 

  template <class U1>
  void makePrivateStore (const U1* other,
                         bool warnUnlocked = false);
 

  void releasePrivateStore();
 

  void setStore (const SG::IConstAuxStore* store);
 

  void setStore (SG::IAuxStore* store);
 

  void setStore (const DataLink< SG::IConstAuxStore >& store);
 

  void setConstStore (const SG::IConstAuxStore* store);
 

  void setNonConstStore (SG::IAuxStore* store);
 

  bool usingPrivateStore() const;
 

  bool usingStandaloneStore() const;
 

  const SG::IConstAuxStore* getConstStore() const;
 

  SG::IAuxStore* getStore() const;
 

  void clearCache();
 

  const SG::auxid_set_t& getAuxIDs() const;
 

  const SG::auxid_set_t& getDecorIDs() const;
 

  bool hasStore() const;
 

  bool hasNonConstStore() const;
 

  bool clearDecorations() const;
 

  bool trackIndices() const;
 

  static constexpr bool supportsThinning = true;
 
 
private:
  friend class SG::ConstAuxElement;
  friend class SG::AuxVectorBase;
  friend class SG::AuxVectorBase_test;
 

  void releasePrivateStoreForDtor();
 

  void setIndex (size_t index, SG::AuxVectorData* container);
 

  bool setIndexPrivate (size_t index, SG::AuxVectorData* container);
 

  void makePrivateStore1 (const void* other, bool warnUnlocked);
 

  void makePrivateStore1 (const AuxElement* other,
                          bool warnUnlocked);
 

  AuxElementStandaloneData* setStore1 (const SG::IConstAuxStore* store);
 

  void clearAux();
 

  void copyAux (const ConstAuxElement& other,
                bool warnUnlocked = false);
 
 
#ifdef ATHCONTAINERS_R21_COMPAT
  void copyAux (const AuxElement& other,
                bool warnUnlocked = false);
 

  SG::AuxVectorData* m_container;
#endif
 

  static void clearAuxHelper (AuxVectorData& container, size_t index);
 

  static void copyAuxHelper (AuxVectorData& container,
                             size_t index,
                             const ConstAuxElement& other,
                             bool warnUnlocked);
 
 
#ifdef ATHCONTAINERS_R21_COMPAT
  static void copyAuxHelper (AuxVectorData& container,
                             size_t index,
                             const AuxElement& other,
                             bool warnUnlocked);
#endif
};
 
 
} // namespace SG
 
 
#include "AthContainers/AuxElement.icc"
 
 
#ifndef XAOD_STANDALONE
CLASS_DEF (SG::AuxElement, 225182422, 1)
#endif // not XAOD_STANDALONE
 
 
#endif // not ATHCONTAINERS_AUXELEMENTBASE_H