AuxVectorBase.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#include "AthContainers/AuxVectorBase.h"
 
 
namespace SG {
 
 
AuxVectorBase::AuxVectorBase()
  : m_trackIndices (false)
{
}
 
 
AuxVectorBase::AuxVectorBase (AuxVectorBase&& rhs)
  : AuxVectorData (std::move (rhs)),
    m_trackIndices (rhs.m_trackIndices)
{
}
 
 
AuxVectorBase& AuxVectorBase::operator= (AuxVectorBase&& rhs)
{
  if (this != &rhs) {
    AuxVectorData::operator= (std::move (rhs));
    m_trackIndices = rhs.m_trackIndices;
  }
  return *this;
}
 
 
AuxVectorBase::~AuxVectorBase()
{
}
 
 
void AuxVectorBase::setStore (const SG::IConstAuxStore* store)
{
  if (store && !m_trackIndices)
    throw SG::ExcUntrackedSetStore();
  SG::AuxVectorData::setStore (store);
}
 
 
void AuxVectorBase::setStore (SG::IAuxStore* store)
{
  if (store && !m_trackIndices)
    throw SG::ExcUntrackedSetStore();
  SG::AuxVectorData::setStore (store);
}
 
 
void AuxVectorBase::setStore (const DataLink<SG::IConstAuxStore>& store)
{
  if (!m_trackIndices)
    throw SG::ExcUntrackedSetStore();
  SG::AuxVectorData::setStore (store);
}
 
 
void
AuxVectorBase::initAuxVectorBase1 (const std::false_type&,
                                   SG::OwnershipPolicy /*ownPolicy*/,
                                   SG::IndexTrackingPolicy /*indexTrackingPolicy*/)
{
  m_trackIndices = false;
  if (this->hasStore())
    throw SG::ExcUntrackedSetStore();
}
 
 
void
AuxVectorBase::initAuxVectorBase1 (const std::true_type&,
                                   SG::OwnershipPolicy ownPolicy,
                                   SG::IndexTrackingPolicy indexTrackingPolicy)
{
  if (indexTrackingPolicy == SG::ALWAYS_TRACK_INDICES)
    m_trackIndices = true;
  else if (indexTrackingPolicy == SG::NEVER_TRACK_INDICES)
    m_trackIndices = false;
  else if (ownPolicy == SG::OWN_ELEMENTS)
    m_trackIndices = true;
  else
    m_trackIndices = false;
 
  if (!m_trackIndices && this->hasStore())
    throw SG::ExcUntrackedSetStore();
}
 
 
void AuxVectorBase::resize1 (const std::true_type&, size_t size)
{
  if (this->hasNonConstStore()) {
    if (!this->getStore()->resize (size)) {
      // Only clear the cache if iterators have been invalidated.
      clearCache();
    }
  }
  else if (this->hasStore())
    throw SG::ExcConstAuxData ("resize");
}
 
 
void AuxVectorBase::reserve1 (const std::true_type&, size_t size)
{
  if (this->hasNonConstStore()) {
    this->getStore()->reserve (size);
    clearCache();
  }
  else if (this->hasStore())
    throw SG::ExcConstAuxData ("reserve");
}
 
 
void
AuxVectorBase::moveAux (size_t index, SG::AuxElement* p,
                        bool clear /*= false*/,
                        bool skipDestClear /*= false*/)
{
  if (!m_trackIndices)
    return;
 
  SG::AuxElement to (this, index);
  if (!p) {
    if (!skipDestClear) {
      AuxElement::clearAuxHelper (*this, index);
    }
    return;
  }
 
  if (p->hasStore() || !skipDestClear) {
    AuxElement::copyAuxHelper (*this, index, *p, false);
  }
  if (clear)
    p->clearAux();
  p->setIndex (index, this);
}
 
 
void AuxVectorBase::swapElementsAux (size_t aindex,
                                     size_t bindex,
                                     SG::AuxElement* a,
                                     SG::AuxElement* b,
                                     AuxVectorBase* bcont)
{
  AuxVectorBase* acont = this;
 
  // If one of the elements is null, then this is just a @c moveAux.
  if (!b) {
    if (!a) return;
    acont->moveAux (aindex, a, true);
    return;
  }
  if (!a) {
    bcont->moveAux (bindex, b, true);
    return;
  }
 
  // Reset indices.
  if (b && bcont->trackIndices())
    b->setIndex (bindex, bcont);
  if (a && acont->trackIndices())
    a->setIndex (aindex, acont);
 
  // Check stores.
  if (!this->hasNonConstStore()) {
    if (this->hasStore()) {
      throw SG::ExcConstAuxData ("swapElementsAux");
    }
    return;
  }
 
  // Swap aux data.
 
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  SG::auxid_set_t a_ids = acont->getAuxIDs();
  for (SG::auxid_t auxid : a_ids) {
    r.swap (auxid, *acont, aindex, *bcont, bindex, 1);
  }
  for (SG::auxid_t auxid : bcont->getAuxIDs()) {
    if (!a_ids.test (auxid)) {
      r.swap (auxid, *acont, aindex, *bcont, bindex, 1);
    }
  }
}
 
 
AuxVectorBase::ResortAuxHelper::ResortAuxHelper (size_t sz,
                                                 size_t index,
                                                 AuxVectorBase& vec)
  : m_vec (vec),
    m_index (index),
    m_imap (sz),
    m_rmap (sz)
{
  for (size_t i = 0; i < sz; i++)
    m_imap[i] = m_rmap[i] = i;
 
  const SG::auxid_set_t& auxid_set = vec.getAuxIDs();
  size_t naux = auxid_set.size();
  m_auxdata.reserve (naux);
  m_auxids.reserve (naux);
  for (SG::auxid_t auxid : auxid_set) {
    m_auxdata.push_back (vec.getDataArrayForResort (auxid));
    m_auxids.push_back (auxid);
  }
}
 
 
void
AuxVectorBase::ResortAuxHelper::resortElement (size_t idx, SG::AuxElement* elt)
{
  //                          V
  // x:        9  8  7  6  5  0  1  2  3  4
  // m_index:  0  1  2  3  4  0  1  2  3  4
  // imap      9  8  7  6  5  4  3  2  1  0
  // rmap      9  8  7  6  5  4  3  2  1  0
  // aux      19 18 17 16 15 14 13 12 11 10
  //
  // imap[i] tells in which slot the auxdata originally in slot
  // i is currently located.
  // rmap[i] gives the original location of the auxdata
  // currently in slot i.
  //
  // each time through the loop, looking at index i:
  //  -- look at the index that was set.
  //     we want to move the aux data originally at
  //     auxindex=v[i]->index() here.
  //  -- that data is currently at slot ii1 = imap[auxindex]
  //  -- swap auxdata between slots i and ii1
  //  -- swap rmap between slots i and ii1
  //  -- swap imap entries rmap[i] and rmap[ii1]
  //  -- set v[i]->index() to index.
  // but need to remember to take into account any offset between
  // the beginning of the range we're given and the beginning 
  // of the container (i.e., index was nonzero on entry).
  //
  // ??? can this be made more efficient?  do we need so much
  //     working storage???  xxx
 
  size_t index = m_index;
  size_t auxindex = elt->index();
  ATHCONTAINERS_ASSERT (auxindex-index < m_imap.size());
  size_t ii1 = m_imap[auxindex-index];
  if (ii1 != idx) {
    ATHCONTAINERS_ASSERT (ii1 > idx);
    // swap between auxdata slots dx+index, ii1+index
    SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    size_t naux = m_auxids.size();
    SG::AuxVectorData& cont = *elt->container();
    for (size_t iid = 0; iid < naux; iid++) {
      r.swap (m_auxids[iid], cont, idx+index, cont, ii1+index, 1);
    }
    std::swap (m_rmap[idx], m_rmap[ii1]);
    std::swap (m_imap[m_rmap[idx]], m_imap[m_rmap[ii1]]);
  }
 
  m_vec.setIndexForResort (elt, index+idx);
}
 
 
} // namespace SG