JaggedVecConversions.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_JAGGEDVECCONVERSIONS_H
#define ATHCONTAINERS_JAGGEDVECCONVERSIONS_H
 
 
#include "AthContainers/JaggedVecImpl.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthContainersInterfaces/IAuxTypeVector.h"
#include "AthContainersInterfaces/AuxDataSpan.h"
#include "AthContainersInterfaces/AuxTypes.h"
#include "CxxUtils/range_with_conv.h"
#include "CxxUtils/ranges.h"
#include <variant>
#include <cassert>
#include <stdexcept>
 
 
// For unit testing.
void test_JaggedVecProxyValBase();
void test_JaggedVecProxyRefBase();
 
 
namespace SG { namespace detail {
 
 
template <class PAYLOAD_T>
class JaggedVecConstConverter
{
public:
  using Payload_t = PAYLOAD_T;
 
  using const_Payload_span = detail::AuxDataConstSpan<Payload_t>;
 
  using element_type = CxxUtils::range_with_conv<typename AuxDataTraits<Payload_t>::const_span>;
 
 
  JaggedVecConstConverter (const JaggedVecEltBase* elts,
                           const_Payload_span payload);
 
 
  const element_type operator() (const JaggedVecEltBase& elt) const;
 
 
private:
  const JaggedVecEltBase* m_elts;
 
  const_Payload_span m_payload;
};
 
 
//****************************************************************************
 
 
class JaggedVecProxyBase
{
public:
  using Elt_t = SG::JaggedVecEltBase;
 
  using Elt_span = std::span<Elt_t>;
 
  using index_type = typename Elt_t::index_type;
 
 
  JaggedVecProxyBase (const AuxDataSpanBase& elts,
                      AuxVectorData& container,
                      SG::auxid_t auxid);
 
 
  Elt_t& elt (size_t elt_index) noexcept;
 
 
  const Elt_t& elt (size_t elt_index) const noexcept;
 
 
  void resize1 (size_t elt_index, index_type n_new);
 
 
  void adjust1 (size_t elt_index, index_type index, int n_add);
 
 
private:
  Elt_span m_elts;
 
  AuxVectorData& m_container;
 
  // Holds either a pointer to the @c IAuxTypeVector the variable ID.
  std::variant<IAuxTypeVector*, SG::auxid_t> m_linkedVec;
};
 
 
//****************************************************************************
 
 
class JaggedVecProxyValBase
  : public std::ranges::view_base
{
public:
  JaggedVecProxyValBase (const AuxDataSpanBase& elts,
                         AuxVectorData& container,
                         SG::auxid_t auxid);
 
 
protected:
  friend void ::test_JaggedVecProxyValBase(); // For unit testing.
 
  JaggedVecProxyBase m_base;
};
 
 
class JaggedVecProxyRefBase
  : public std::ranges::view_base
{
public:
  JaggedVecProxyRefBase (JaggedVecProxyBase& base);
 
 
protected:
  friend void ::test_JaggedVecProxyRefBase(); // For unit testing.
 
  JaggedVecProxyBase& m_base;
};
 
 
//****************************************************************************
 
 
template <class PAYLOAD_T, class BASE>
class JaggedVecProxyT
  : public BASE
{
public:
  using Payload_t              = PAYLOAD_T;
  using Payload_span           = detail::AuxDataSpan<Payload_t>;
 
  using Elt_t                  = JaggedVecProxyBase::Elt_t;
  using index_type             = typename Elt_t::index_type;
  using Elt_span               = JaggedVecProxyBase::Elt_span;
  static_assert (sizeof (Elt_t) == sizeof (SG::JaggedVecElt<Payload_t>));
 
  using element_type           = Payload_t;
  using value_type             = std::remove_cv_t<element_type>;
  using size_type              = std::size_t;
  using difference_type        = std::ptrdiff_t;
  using pointer                = element_type*;
  using const_pointer          = const element_type*;
  using reference              = element_type&;
  using const_reference        = const element_type&;
 
  using iterator               = pointer;
  using const_iterator         = const_pointer;
  using reverse_iterator       = std::reverse_iterator<iterator>;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
 
  struct nonnull_iterator
  {
    nonnull_iterator (iterator it) : m_it (it) {}
    nonnull_iterator (std::nullptr_t) = delete;
    nonnull_iterator (int) = delete;
    operator iterator() { return m_it; }
    iterator m_it;
  };
 
 
  JaggedVecProxyT (size_t elt_index,
                   Payload_span payload,
                   const AuxDataSpanBase& elts,
                   AuxVectorData& container,
                   SG::auxid_t auxid);
 
 
  JaggedVecProxyT (size_t elt_index,
                   Payload_span payload,
                   JaggedVecProxyBase& base);
 
  size_t size() const noexcept;
 
 
  bool empty() const noexcept;
 
 
  reference operator[] (size_t i) noexcept;
 
 
  const_reference operator[] (size_t i) const noexcept;
 
 
  reference at (size_t i);
 
 
  const_reference at (size_t i) const;
 
 
  reference front() noexcept;
 
 
  const_reference front() const noexcept;
 
 
  reference back() noexcept;
 
 
  const_reference back() const noexcept;
 
 
  iterator begin() noexcept;
 
 
  iterator end() noexcept;
 
 
  const_iterator begin() const noexcept;
 
 
  const_iterator end() const noexcept;
 
 
  const_iterator cbegin() const noexcept;
 
 
  const_iterator cend() const noexcept;
 
 
  reverse_iterator rbegin() noexcept;
 
 
  reverse_iterator rend() noexcept;
 
 
  const_reverse_iterator rbegin() const noexcept;
 
 
  const_reverse_iterator rend() const noexcept;
 
 
  const_reverse_iterator crbegin() const noexcept;
 
 
  const_reverse_iterator crend() const noexcept;
 
 
  template <CxxUtils::InputRangeOverT<PAYLOAD_T> RANGE>
  JaggedVecProxyT& operator= (const RANGE& range);
 
 
  std::vector<Payload_t> asVector() const;
 
 
  template <class VALLOC>
  operator std::vector<Payload_t, VALLOC>() const;
 
 
  void push_back (const Payload_t& x);
 
 
  void clear();
 
 
  void resize (size_t n, const Payload_t& x = Payload_t());
 
 
  void erase (nonnull_iterator pos);
 
 
  void erase (index_type pos);
 
 
  void erase (nonnull_iterator first, nonnull_iterator last);
 
 
  void erase (index_type first, index_type last);
 
 
  void insert (nonnull_iterator pos, const Payload_t& x);
 
 
  void insert (index_type pos, const Payload_t& x);
 
 
  void insert (nonnull_iterator pos, size_t n, const Payload_t& x);
 
 
  void insert (index_type pos, size_t n, const Payload_t& x);
 
 
  template <CxxUtils::detail::InputValIterator<PAYLOAD_T> ITERATOR>
  void insert (nonnull_iterator pos, ITERATOR first, ITERATOR last);
 
 
  template <CxxUtils::detail::InputValIterator<PAYLOAD_T> ITERATOR>
  void insert (index_type pos, ITERATOR first, ITERATOR last);
 
 
  template <CxxUtils::InputRangeOverT<PAYLOAD_T> RANGE>
  void insert_range (nonnull_iterator pos, const RANGE& range);
 
 
  template <CxxUtils::InputRangeOverT<PAYLOAD_T> RANGE>
  void insert_range (index_type pos, const RANGE& range);
 
 
  template <CxxUtils::InputRangeOverT<PAYLOAD_T> RANGE>
  void append_range (const RANGE& range);
 
 
  void pop_back();
 
 
  void assign (size_t n, const Payload_t& x);
 
 
  template <CxxUtils::detail::InputValIterator<PAYLOAD_T> ITERATOR>
  void assign (ITERATOR first, ITERATOR last);
 
 
  template <CxxUtils::InputRangeOverT<PAYLOAD_T> RANGE>
  void assign_range (const RANGE& range);
 
 
private:
  Elt_t& elt() noexcept;
 
 
  const Elt_t& elt() const noexcept;
 
 
  size_t elt_begin() const noexcept;
 
 
  size_t elt_end() const noexcept;
 
 
  size_t m_index;
 
  Payload_span m_payload;
};
 
 
//****************************************************************************
 
 
template <class PAYLOAD_T>
class JaggedVecConverter
{
public:
  using Payload_t = PAYLOAD_T;
 
  using Payload_span = detail::AuxDataSpan<Payload_t>;
 
  using element_type = CxxUtils::range_with_conv<typename AuxDataTraits<Payload_t>::const_span>;
 
 
  using JVecProxyInSpan = JaggedVecProxyT<Payload_t, JaggedVecProxyRefBase>;
  using value_type = JVecProxyInSpan;
 
 
  JaggedVecConverter (AuxVectorData& container,
                      auxid_t auxid,
                      auxid_t linked_auxid);
 
 
  const element_type operator() (const SG::JaggedVecEltBase& elt) const;
 
 
  value_type operator() (SG::JaggedVecEltBase& elt);
 
 
private:
  JaggedVecProxyBase m_base;
 
  Payload_span m_payload;
};
 
 
} } // namespace SG::detail
 
 
#include "AthContainers/tools/JaggedVecConversions.icc"
 
 
#endif // not ATHCONTAINERS_JAGGEDVECCONVERSIONS_H