PackedLinkVectorHelper.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_PACKEDLINKVECTORHELPER_H
#define ATHCONTAINERS_PACKEDLINKVECTORHELPER_H
 
 
#include "AthContainers/PackedLinkImpl.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainersInterfaces/IAuxTypeVector.h"
#include "AthLinks/ElementLink.h"
#include "AthLinks/DataLink.h"
#include "CxxUtils/span.h"
#include "CxxUtils/ranges.h"
#include <ranges>
#include <variant>
#include <utility>
 
 
#ifdef XAOD_STANDALONE
#include "xAODRootAccessInterfaces/TVirtualEvent.h"
#include "xAODRootAccessInterfaces/TActiveEvent.h"
 
namespace AthContainers {
using IProxyDict = xAOD::TVirtualEvent;
}
#else
#include "AthenaKernel/IProxyDict.h"
#endif
 
 
namespace SG::detail {
 

template <class RANGE, class CONT>
concept ElementLinkRange = CxxUtils::InputRangeOverT<RANGE, ElementLink<CONT> >;
 

class PackedLinkVectorHelperBase
{
public:
#ifdef XAOD_STANDALONE
  using IProxyDict = AthContainers::IProxyDict;
 
  // To reduce the number of template instantiations, we want to be able
  // to treat the vectors of DataLinks as just vectors of DataLinkBase.
  // That works fine in Athena, where all the data members are in
  // DataLinkBase.  But in AnalysisBase, DataLink<T> adds more
  // data members.  So for this case, use a dummy DataLink type
  // rather than DataLinkBase.
  using DataLinkBase = DataLink<std::vector<float> >;
#else
  using DataLinkBase = ::DataLinkBase;
#endif

  typedef void InitLinkFunc_t (DataLinkBase& dl,
                               sgkey_t sgkey,
                               IProxyDict* sg);
 

  using DataLinkBase_span = detail::AuxDataSpan<DataLinkBase>;
  using const_DataLinkBase_span = detail::AuxDataConstSpan<DataLinkBase>;
 

  class LinkedVector
  {
  public:
    LinkedVector (IAuxTypeVector& linkedVector);
 

    LinkedVector (AuxVectorData& container, SG::auxid_t auxid);
 

    IAuxTypeVector* get();
 

    IAuxTypeVector& operator*();
 

    IAuxTypeVector* operator->();
 
  private:
    // Holds either a pointer to the @c IAuxTypeVector or a container, ID pair.
    std::variant<IAuxTypeVector*,
                 std::pair<AuxVectorData*, SG::auxid_t> > m_data;
  };
 

  // Can't use std::span now because we want span::at(), which is C++26.
  using PackedLinkBase_span = CxxUtils::span<PackedLinkBase>;
 

  static IProxyDict* storeFromSpan (DataLinkBase_span& links);
 

  static DataLinkBase_span getLinkBaseSpan (IAuxTypeVector& linkedVec);
 

  static const_DataLinkBase_span getLinkBaseSpan (const IAuxTypeVector& linkedVec);
 

  static std::pair<size_t, bool>
  findCollectionBase (LinkedVector& linkedVec,
                      sgkey_t sgkey,
                      DataLinkBase_span& links,
                      IProxyDict* sg,
                      InitLinkFunc_t* initLinkFunc);
 

  static bool updateLinksBase (IAuxTypeVector& linkedVec,
                               PackedLinkBase_span& links,
                               const const_DataLinkBase_span& srcDLinks,
                               IProxyDict* sg,
                               InitLinkFunc_t* initLinkFunc);
 
 
#ifndef XAOD_STANDALONE
  static bool applyThinningBase (IAuxTypeVector& linkedVec,
                                 PackedLinkBase_span& links,
                                 DataLinkBase_span& dlinks,
                                 const SG::ThinningCache* tc,
                                 IProxyDict* sg,
                                 InitLinkFunc_t* initLinkFunc);
#endif
 
 
private:
  static bool resizeLinks (LinkedVector& linkedVec, size_t sz);
};
 

template <class CONT>
class PackedLinkVectorHelper
  : public PackedLinkVectorHelperBase
{
public:
  using Link_t = ElementLink<CONT>;
  using DLink_t = DataLink<CONT>;
  using DataLink_span = detail::AuxDataSpan<DataLink<CONT> >;
  using const_DataLink_span = detail::AuxDataConstSpan<DataLink<CONT> >;

  using PLink_t = PackedLink<CONT>;
  using PackedLink_span = CxxUtils::span<PLink_t>;
 

  static std::pair<size_t, bool>
  findCollection (LinkedVector& linkedVec,
                  sgkey_t sgkey,
                  DataLinkBase_span& links,
                  IProxyDict* sg);
 

  static bool updateLinks (IAuxTypeVector& linkedVec,
                           SG::PackedLink<CONT>* ptr,
                           size_t n,
                           const const_DataLinkBase_span& srcDLinks,
                           IProxyDict* sg);
 

  static bool updateLinks (IAuxTypeVector& linkedVec,
                           SG::PackedLink<CONT>* ptr,
                           size_t n,
                           const IAuxTypeVector& srclv,
                           IProxyDict* sg);
 

  template <class VALLOC>
  static bool updateLinks (IAuxTypeVector& linkedVec,
                           std::vector<SG::PackedLink<CONT>, VALLOC>* ptr,
                           size_t n,
                           const IAuxTypeVector& srclv,
                           IProxyDict* sg);
 

  template <class VALLOC, ElementLinkRange<CONT> RANGE>
  static bool assignVElt (std::vector<PLink_t, VALLOC>& velt,
                          IAuxTypeVector& linkedVec,
                          DataLinkBase_span& dlinks,
                          const RANGE& x);
 

  template <class VALLOC, ElementLinkRange<CONT> RANGE>
  static bool insertVElt (std::vector<PLink_t, VALLOC>& velt,
                          size_t pos,
                          IAuxTypeVector& linkedVec,
                          DataLinkBase_span& dlinks,
                          const RANGE& x);
 
 
#ifndef XAOD_STANDALONE
  static bool applyThinning (IAuxTypeVector& linkedVec,
                             PackedLink<CONT>* ptr,
                             size_t n,
                             DataLinkBase_span& dlinks,
                             const SG::ThinningCache* tc,
                             IProxyDict* sg);
#endif
 
 
private:
  // We want to be able to deal with spans over the base classes.
  static_assert (sizeof (PLink_t) == sizeof(PackedLinkBase));
  static_assert (sizeof (DLink_t) == sizeof(DataLinkBase));
 

  static void initLink (DataLinkBase& dl, sgkey_t sgkey, IProxyDict* sg);
};
 
 
} // namespace SG::detail
 
 
#include "AthContainers/tools/PackedLinkVectorHelper.icc"
 
 
#endif // not ATHCONTAINERS_PACKEDLINKVECTORHELPER_H