PackedLinkDecorator.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 ATHCONTAINERS_PACKEDLINKDECORATOR_H
#define ATHCONTAINERS_PACKEDLINKDECORATOR_H
 
 
#include "AthContainersInterfaces/AuxTypes.h"
#include "AthContainersInterfaces/IAuxElement.h"
#include "AthContainers/Accessor.h"
#include "AthContainers/PackedLinkConstAccessor.h"
#include "AthContainers/PackedLinkImpl.h"
#include "AthContainers/tools/PackedLinkVectorFactory.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/tools/ELProxy.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthContainers/tools/AuxElementConcepts.h"
#include "AthLinks/DataLink.h"
#include "CxxUtils/checker_macros.h"
#include <ranges>
#include <string>
#include <typeinfo>
#include <iterator>
 
 
namespace SG {
 

template <class CONT, class ALLOC>
class Decorator<PackedLink<CONT>, ALLOC>
  : public detail::LinkedVarAccessorBase
{
public:
  // Aliases for the types we're dealing with.
  using Link_t = ElementLink<CONT>;
  using PLink_t = SG::PackedLink<CONT>;
  using DLink_t = DataLink<CONT>;
  using DLinkAlloc_t = typename std::allocator_traits<ALLOC>::template rebind_alloc<DLink_t>;
 

  using const_PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, ALLOC>::const_span;
  using const_DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::const_span;
  using PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, ALLOC>::span;
  using DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::span;
 

  using ConstConverter_t = detail::PackedLinkConstConverter<CONT>;
 

  using const_span = std::ranges::transform_view<const_PackedLink_span,
                                                 ConstConverter_t>;
 

  using ELProxy = detail::ELProxyT<detail::ELProxyValBase<CONT> >;
 

  using span = std::ranges::transform_view<PackedLink_span,
                                           detail::ELProxyInSpanConverter<CONT> >;
 

  using element_type = Link_t;

  using reference_type = ELProxy;

  using const_reference_type = element_type;

  using rhs_const_reference_type = const Link_t&;

  using container_pointer_type = void;
  using const_container_pointer_type = void;
 

  Decorator (const std::string& name);
 

  Decorator (const std::string& name, const std::string& clsname);
 

  Decorator (const SG::auxid_t auxid);
 

  template <IsConstAuxElement ELT>
  ELProxy operator() (const ELT& e) const;
 

  ELProxy
  operator() (const AuxVectorData& container, size_t index) const;
 

  template <IsConstAuxElement ELT>
  void set (const ELT& e, const element_type& l) const;
 

  void set (const AuxVectorData& container, size_t index, const Link_t& x) const;
 

  const PLink_t*
  getPackedLinkArray (const AuxVectorData& container) const;
 

  const DLink_t*
  getDataLinkArray (const AuxVectorData& container) const;
 

  PLink_t*
  getPackedLinkDecorArray (const AuxVectorData& container) const;
 

  DLink_t*
  getDataLinkDecorArray (const AuxVectorData& container) const;
 

  const_PackedLink_span
  getPackedLinkSpan (const AuxVectorData& container) const;
 

  const_DataLink_span
  getDataLinkSpan (const AuxVectorData& container) const;
 

  const_span
  getDataSpan (const AuxVectorData& container) const;
 

  PackedLink_span
  getPackedLinkDecorSpan (const AuxVectorData& container) const;
 

  DataLink_span
  getDataLinkDecorSpan (const AuxVectorData& container) const;
 

  span
  getDecorationSpan (const AuxVectorData& container) const;
 

  template <IsConstAuxElement ELT>
  bool isAvailableWritable (const ELT& e) const;
 

  bool isAvailableWritable (const AuxVectorData& c) const;
 
 
protected:
  Decorator (const std::string& name,
             const std::string& clsname,
             const SG::AuxVarFlags flags);
};
 
 
//************************************************************************
 

template <class CONT, class ALLOC, class VALLOC>
class Decorator<std::vector<PackedLink<CONT>, VALLOC>, ALLOC>
  : public detail::LinkedVarAccessorBase
{
public:
  // Aliases for the types we're dealing with.
  using Link_t = ElementLink<CONT>;
  using PLink_t = SG::PackedLink<CONT>;
  using VElt_t = std::vector<SG::PackedLink<CONT>, VALLOC>;
  using DLink_t = DataLink<CONT>;
  using DLinkAlloc_t = typename std::allocator_traits<ALLOC>::template rebind_alloc<DLink_t>;

  using const_PackedLinkVector_span = typename AuxDataTraits<VElt_t, ALLOC>::const_span;
  using const_DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::const_span;
  using PackedLinkVector_span = typename AuxDataTraits<VElt_t, ALLOC>::span;
  using DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::span;

  using const_PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, VALLOC>::const_span;
  using PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, VALLOC>::span;
 

  using ConstVectorTransform_t = detail::PackedLinkVectorConstConverter<CONT>;

  using const_span = std::ranges::transform_view<const_PackedLinkVector_span,
                                                 ConstVectorTransform_t>;
 

  using elt_span = detail::ELSpanProxy<CONT, VALLOC>;
 

  using ELSpanConverter = detail::ELSpanConverter<CONT, VALLOC>;
  using span = std::ranges::transform_view<PackedLinkVector_span,
                                           ELSpanConverter >;
 

  using element_type = elt_span;

  using reference_type = elt_span;

  using container_pointer_type = void;
  using const_container_pointer_type = void;
 

  Decorator (const std::string& name);
 

  Decorator (const std::string& name, const std::string& clsname);
 

  Decorator (const SG::auxid_t auxid);
 

  template <IsConstAuxElement ELT>
  elt_span operator() (const ELT& e) const;
 

  elt_span
  operator() (const AuxVectorData& container, size_t index) const;
 

  template <IsConstAuxElement ELT, detail::ElementLinkRange<CONT> RANGE>
  void set (const ELT& e, const RANGE& x) const;
 

  template <detail::ElementLinkRange<CONT> RANGE>
  void set (const AuxVectorData& container, size_t index, const RANGE& r) const;
 

  const VElt_t*
  getPackedLinkVectorArray (const AuxVectorData& container) const;
 

  const DLink_t*
  getDataLinkArray (const AuxVectorData& container) const;
 

  VElt_t*
  getPackedLinkVectorDecorArray (const AuxVectorData& container) const;
 

  DLink_t*
  getDataLinkDecorArray (const AuxVectorData& container) const;
 

  template <IsConstAuxElement ELT>
  const_PackedLink_span
  getPackedLinkSpan (const ELT& e) const;
 

  const_PackedLink_span
  getPackedLinkSpan (const AuxVectorData& container, size_t index) const;
 

  PackedLink_span
  getPackedLinkSpan (AuxVectorData& container, size_t index) const;
 

  const_PackedLinkVector_span
  getPackedLinkVectorSpan (const AuxVectorData& container) const;
 

  const_DataLink_span
  getDataLinkSpan (const AuxVectorData& container) const;
 

  const_span
  getDataSpan (const AuxVectorData& container) const;
 

  template <IsConstAuxElement ELT>
  PackedLink_span
  getPackedLinkDecorSpan (const ELT& e) const;
 

  PackedLink_span
  getPackedLinkDecorSpan (const AuxVectorData& container, size_t index) const;
 

  PackedLinkVector_span
  getPackedLinkVectorDecorSpan (const AuxVectorData& container) const;
 

  DataLink_span
  getDataLinkDecorSpan (const AuxVectorData& container) const;
 

  span
  getDecorationSpan (const AuxVectorData& container) const;
 

  template <IsConstAuxElement ELT>
  bool isAvailableWritable (const ELT& e) const;
 

  bool isAvailableWritable (const AuxVectorData& e) const;
 
 
protected:
  Decorator (const std::string& name,
             const std::string& clsname,
             const SG::AuxVarFlags flags);
};
 
 
} // namespace SG
 
 
#include "AthContainers/PackedLinkDecorator.icc"
 
 
 
#endif // not ATHCONTAINERS_PACKEDLINKDECORATOR_H