PackedLinkConversions.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-2024 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#ifndef ATHCONTAINERS_PACKEDLINKCONVERSIONS_H
#define ATHCONTAINERS_PACKEDLINKCONVERSIONS_H
 
 
#include "AthContainers/PackedLinkImpl.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthContainers/tools/PackedLinkVectorHelper.h"
#include "AthLinks/ElementLink.h"
#include "AthLinks/DataLink.h"
#include "CxxUtils/ranges.h"
#include "CxxUtils/range_with_at.h"
#include "CxxUtils/range_with_conv.h"
#include <vector>
 
 
namespace SG { namespace detail {
 

template <class CONT>
class PackedLinkConstConverter
{
public:
  using PLVH = PackedLinkVectorHelper<CONT>;
 

  using value_type = ElementLink<CONT>;
 

  using const_DataLink_span = typename PLVH::const_DataLink_span;
 

  PackedLinkConstConverter (const const_DataLink_span& dlinks);
 

  const value_type operator() (const PackedLinkBase& plink) const;
 
 
private:
  const_DataLink_span m_dlinks;
};
 

template <class CONT>
class PackedLinkVectorConstConverter
{
public:
  using PLVH = PackedLinkVectorHelper<CONT>;
 

  using const_PackedLink_span = typename AuxDataTraits<PackedLink<CONT> >::const_span;

  using value_type =
    CxxUtils::range_with_conv<
      CxxUtils::transform_view_with_at<const_PackedLink_span,
                                       detail::PackedLinkConstConverter<CONT> > >;
 

  using const_DataLink_span = typename PLVH::const_DataLink_span;
 

  PackedLinkVectorConstConverter (const const_DataLink_span& dlinks);
 

  template <class VALLOC>
  value_type operator() (const std::vector<PackedLink<CONT>, VALLOC>& velt) const;
 
 
private:
  const_DataLink_span m_dlinks;
};
 

template <class CONT>
class PackedLinkConverter
{
private:
  using PLVH = detail::PackedLinkVectorHelper<CONT>;
 
 
public:
  using value_type = typename PLVH::Link_t;

  using PLink_t = typename PLVH::PLink_t;

  using DLink_t = typename PLVH::DLink_t;

  using DataLinkBase_span = typename PLVH::DataLinkBase_span;
 

  PackedLinkConverter (AuxVectorData& container,
                       SG::auxid_t auxid,
                       SG::auxid_t linked_auxid);
 

  const value_type operator() (const PackedLinkBase& plink) const;
 

  void set (PackedLinkBase& pl, const value_type& link);
 

  template <class VALLOC, ElementLinkRange<CONT> RANGE>
  void set (std::vector<PLink_t, VALLOC>& plv, const RANGE& r);
 

  template <class VALLOC, ElementLinkRange<CONT> RANGE>
  void insert (std::vector<PLink_t, VALLOC>& plv, size_t pos, const RANGE& r);
 
 
private:
  AuxVectorData& m_container;

  PLVH::LinkedVector m_linkedVec;

  DataLinkBase_span m_dlinks;
};
 
 
} } // namespace SG::detail
 
 
#include "AthContainers/tools/PackedLinkConversions.icc"
 
 
#endif // not ATHCONTAINERS_PACKEDLINKCONVERSIONS_H