PackedLinkVectorHelper.cxx

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration.
 */
#include "AthContainers/tools/PackedLinkVector.h"
 
 
namespace SG::detail {
 
 
std::pair<size_t, bool>
PackedLinkVectorHelperBase::findCollectionBase (LinkedVector& linkedVec,
                                                sgkey_t sgkey,
                                                DataLinkBase_span& links,
                                                IProxyDict* sg,
                                                InitLinkFunc_t* initLinkFunc)
{
  if (sgkey == 0) {
    if (!links.empty())
      return std::make_pair (0u, true);
  }
  else {
    for (size_t i = 1; i < links.size(); ++i) {
      if (links[i].key() == sgkey) return std::make_pair (i, true);
    }
  }
  size_t oldsz = links.size();
  size_t newsz = oldsz+1;
  if (oldsz == 0 && sgkey != 0) {
    newsz = 2;
  }
  bool cacheValid = resizeLinks (linkedVec, newsz);
  initLinkFunc (links.back(), sgkey, sg);
  return std::make_pair (links.size() - 1, cacheValid);
}
 
 
bool
PackedLinkVectorHelperBase::updateLinksBase (IAuxTypeVector& linkedVec,
                                             PackedLinkBase_span& links,
                                             const const_DataLinkBase_span& srcDLinks,
                                             IProxyDict* sg,
                                             InitLinkFunc_t* initLinkFunc)
{
  DataLinkBase_span DLinks = getLinkBaseSpan (linkedVec);
  if (sg == nullptr) {
    sg = storeFromSpan (DLinks);
  }
  bool cacheValid = true;
  for (PackedLinkBase& l : links) {
    size_t in_coll = l.collection();
    if (in_coll > 0) {
      LinkedVector lv (linkedVec);
      auto [index, thisValid] = findCollectionBase
        (lv, srcDLinks.at(in_coll).key(), DLinks, sg, initLinkFunc);
      l.setCollection (index);
      cacheValid &= thisValid;
    }
  }
  return cacheValid;
}
 
 
#ifndef XAOD_STANDALONE
 
bool
PackedLinkVectorHelperBase::applyThinningBase (IAuxTypeVector& linkedVec,
                                               PackedLinkBase_span& links,
                                               DataLinkBase_span& dlinks,
                                               const SG::ThinningCache* tc,
                                               IProxyDict* sg,
                                               InitLinkFunc_t* initLinkFunc)
{
  bool cacheValid = true;
  for (PackedLinkBase& l : links) {
    if (l.collection() != 0) {
      sgkey_t sgkey = dlinks[l.collection()].key();
      size_t index = l.index();
      sgkey_t sgkey_out = sgkey;
      size_t index_out = index;
      if (sg) {
        sg->tryELRemap (sgkey, index, sgkey_out, index_out);
      }
      DataProxyHolder::thin (sgkey_out, index_out, tc);
      l.setIndex (index_out);
      if (sgkey_out != sgkey) {
        LinkedVector lv (linkedVec);
        auto [index, flag] = findCollectionBase (lv, sgkey_out, dlinks,
                                                 sg, initLinkFunc);
        l.setCollection (index);
        cacheValid &= flag;
      }
    }
  }
  return cacheValid;
}
#endif
 
 
bool
PackedLinkVectorHelperBase::resizeLinks (LinkedVector& linkedVec, size_t sz)
{
  return linkedVec->resize (sz);
}
 
 
} // namespace SG::detail