PackedLinkAccessor.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_PACKEDLINKACCESSOR_H
#define ATHCONTAINERS_PACKEDLINKACCESSOR_H
 
 
#include "AthContainersInterfaces/AuxTypes.h"
#include "AthContainersInterfaces/IAuxElement.h"
#include "AthContainers/PackedLinkConstAccessor.h"
#include "AthContainers/Accessor.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/tools/ELProxy.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "CxxUtils/checker_macros.h"
#include <string>
#include <typeinfo>
 
 
namespace SG {
 

template <class CONT, class ALLOC>
class Accessor<PackedLink<CONT>, ALLOC>
  : public ConstAccessor<PackedLink<CONT>, ALLOC>
{
public:
  // Aliases for the types we're dealing with.
  using Base = ConstAccessor<PackedLink<CONT>, ALLOC>;
  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 PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, ALLOC>::span;
  using DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::span;
 

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

  using span = CxxUtils::transform_view_with_at<PackedLink_span,
                                                detail::ELProxyInSpanConverter<CONT> >;
 

  using element_type = Link_t;

  using reference_type = ELProxy;

  using rhs_const_reference_type = const Link_t&;

  using container_pointer_type = void;
  using const_container_pointer_type = void;
 

  using Base::operator();
  using Base::getPackedLinkArray;
  using Base::getDataLinkArray;
  using Base::getPackedLinkSpan;
  using Base::getDataLinkSpan;
  using Base::getDataSpan;
 

  Accessor (const std::string& name);
 

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

  Accessor (const SG::auxid_t auxid);
 

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

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

  void set (AuxElement& e, const Link_t& l) const;
 

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

  PLink_t*
  getPackedLinkArray (AuxVectorData& container) const;
 

  DLink_t*
  getDataLinkArray (AuxVectorData& container) const;
 

  PackedLink_span
  getPackedLinkSpan (AuxVectorData& container) const;
 

  DataLink_span
  getDataLinkSpan (AuxVectorData& container) const;
 

  span
  getDataSpan (AuxVectorData& container) const;
    

  bool isAvailableWritable (AuxElement& e) const;
    

  bool isAvailableWritable (AuxVectorData& c) const;
};
 
 
//************************************************************************
 

template <class CONT, class ALLOC, class VALLOC>
class Accessor<std::vector<PackedLink<CONT>, VALLOC>, ALLOC>
  : public ConstAccessor<std::vector<PackedLink<CONT>, VALLOC>, ALLOC>
{
public:
  // Aliases for the types we're dealing with.
  using Base = ConstAccessor<std::vector<PackedLink<CONT>, VALLOC>, ALLOC>;
  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 PackedLinkVector_span = typename AuxDataTraits<VElt_t, ALLOC>::span;
  using DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::span;

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

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

  using ELSpanConverter = detail::ELSpanConverter<CONT, VALLOC>;
  using span =
    CxxUtils::transform_view_with_at<PackedLinkVector_span, ELSpanConverter >;
 

  using element_type = elt_span;

  using reference_type = elt_span;

  using container_pointer_type = void;
  using const_container_pointer_type = void;
 

  using Base::operator();
  using Base::getPackedLinkVectorArray;
  using Base::getDataLinkArray;
  using Base::getPackedLinkSpan;
  using Base::getPackedLinkVectorSpan;
  using Base::getDataSpan;
  using Base::getDataLinkSpan;
 

  Accessor (const std::string& name);
 

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

  Accessor (const SG::auxid_t auxid);
 

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

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

  template <detail::ElementLinkRange<CONT> RANGE>
  void set (AuxElement& e, const RANGE& r) const;
 

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

  VElt_t*
  getPackedLinkVectorArray (AuxVectorData& container) const;
 

  DLink_t*
  getDataLinkArray (AuxVectorData& container) const;
 

  PackedLink_span
  getPackedLinkSpan (AuxElement& e) const;
 

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

  PackedLinkVector_span
  getPackedLinkVectorSpan (AuxVectorData& container) const;
 

  DataLink_span
  getDataLinkSpan (AuxVectorData& container) const;
 

  span
  getDataSpan (AuxVectorData& container) const;
    

  bool isAvailableWritable (AuxElement& e) const;
    

  bool isAvailableWritable (AuxVectorData& e) const;
};
 
 
} // namespace SG
 
 
#include "AthContainers/PackedLinkAccessor.icc"
 
 
#endif // not ATHCONTAINERS_PACKEDLINKACCESSOR_H