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-2025 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 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