JaggedVecVector.icc

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration.
 */
/**
 * @file AthContainers/tools/JaggedVecVector.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Mar, 2024
 * @brief Implementation of @c IAuxTypeVector for @c JaggedVecElt types.
 */
 
 
#include "AthContainers/AuxTypeRegistry.h"
 
 
namespace SG {
 
 
/**
 * @brief Fill in any trailing zeros at the end of this vector.
 */
template <class T, class ALLOC>
void JaggedVecVectorHolder<T, ALLOC>::fillTrailingZeros()
{
  vector_type& vec = this->vec();
  if (vec.empty()) return;
  if (vec.back().end() == 0) {
    if (size_t n_payload = m_linkedVec->getDataSpan().size) {
      Shift shift (n_payload);
      for (size_t index = vec.size()-1; vec[index].end() == 0; --index) {
        shift (vec[index]);
        if (index == 0) break;
      }
    }
  }
}
 
 
/**
 * @brief Constructor.
 * @param auxid The auxid of the variable this vector represents.
 * @param vecPtr Pointer to the object.
 * @param linkedVec Interface for the linked vector of DataLinks.
 * @param ownFlag If true, take ownership of the object.
 */
template <class T, class ALLOC>
JaggedVecVectorHolder<T, ALLOC>::JaggedVecVectorHolder
  (auxid_t auxid,
   vector_type* vecPtr,
   IAuxTypeVector* linkedVec,
   bool ownFlag)
    : Base (auxid, vecPtr, ownFlag, false),
      m_linkedVec (linkedVec)
{
}
 
 
/**
 * @brief Change the size of the vector.
 * @param sz The new vector size.
 * Returns true if it is known that iterators have not been invalidated;
 * false otherwise.
 */
template <class T, class ALLOC>
inline
bool JaggedVecVectorHolder<T, ALLOC>::resize (size_t sz)
{
  bool valid = true;
  vector_type& vec = this->vec();
  Elt zero;
  size_t vec_sz = vec.size();
  if (sz == vec_sz) return true;
  if (sz < vec_sz) {
    size_t payload_sz = sz > 0 ? vec[sz-1].end() : 0;
    if (payload_sz == 0 && vec.back().end() == 0) {
      payload_sz = m_linkedVec->getDataSpan().size;
      if (sz > 0 && payload_sz > 0) {
        // At this point, we're dealing with trailing zeros, and we can have
        // one of two cases:
        //
        //   0 0 0 1 2 3 0 0 0
        //     a         b
        //
        // If we try to resize to b, then we're just removing trailing zeros
        // and shouldn't touch the payload.  But if we're resizing to a,
        // then we also need to free the entire payload.
        // There's no way to distinguish between these by looking
        // just at the resize point, end, and total payload size.
        // We need to scan from the resize point to the end to see if
        // there's anything nonzero.  If so, then we remove the entire
        // payload; other wise, we leave it alone.
        for (size_t i = sz; i < vec_sz; ++i) {
          if (vec[i].end() != 0) {
            payload_sz = 0;
            break;
          }
        }
      }
    }
    valid = m_linkedVec->resize (payload_sz);
  }
  else if (vec_sz > 0) {
    fillTrailingZeros();
    size_t payload_sz = vec.back().end();
    zero = Elt (payload_sz);
  }
  const void* orig = vec.data();
  vec.resize (sz, zero);
  this->storeDataSpan();
  return valid && vec.data() == orig;
}
 
 
/**
 * @brief Shift the elements of the vector.
 * @param pos The starting index for the shift.
 * @param offs The (signed) amount of the shift.
 *
 * This operation shifts the elements in the vectors for all
 * aux data items, to implement an insertion or deletion.
 * @c offs may be either positive or negative.
 *
 * If @c offs is positive, then the container is growing.
 * The container size should be increased by @c offs,
 * the element at @c pos moved to @c pos + @c offs,
 * and similarly for following elements.
 * The elements between @c pos and @c pos + @c offs should
 * be default-initialized.
 *
 * If @c offs is negative, then the container is shrinking.
 * The element at @c pos should be moved to @c pos + @c offs,
 * and similarly for following elements.
 * The container should then be shrunk by @c -offs elements
 * (running destructors as appropriate).
 *
 * Returns true if it is known that iterators have not been invalidated;
 * false otherwise.  (Will always return false when increasing the size
 * of an empty container.)
 */
template <class T, class ALLOC>
bool JaggedVecVectorHolder<T, ALLOC>::shift (size_t pos, ptrdiff_t offs)
{
  fillTrailingZeros();
  vector_type& vec = this->vec();
  if (offs < 0) {
    if (-offs > static_cast<ptrdiff_t>(pos)) offs = -pos;
    size_t ppos = pos < vec.size() ? vec[pos].begin(pos) : m_linkedVec->size();
    ptrdiff_t poffs = - (ppos - vec[pos+offs].begin(pos+offs));
    m_linkedVec->shift (ppos, poffs);
    vec.erase (vec.begin() + pos+offs, vec.begin() + pos);
    std::for_each (vec.begin() + pos+offs, vec.end(), Shift (poffs));
    this->storeDataSpan();
    return true;
  }
  else if (offs > 0) {
    const void* orig = vec.data();
    size_t oldsz = vec.size();
    Elt zero;
    if (!vec.empty()) {
      index_type end = vec.back().end();
      zero = Elt (end);
    }
    // Add to the end, zero-filled.
    vec.resize (vec.size() + offs, zero);
    if (oldsz != pos) {
      // Shift existing elements.  If we're just extending,
      // then we can skip this.
      std::copy (vec.rbegin() + offs,
                 vec.rbegin() + (offs+oldsz-pos),
                 vec.rbegin());
      if (pos == 0) {
        zero = Elt (0);
      }
      else {
        index_type end = vec[pos-1].end();
        zero = Elt (end);
      }
      std::fill_n (vec.begin() + pos, offs, zero);
    }
    this->storeDataSpan();
    return vec.data() == orig;
  }
  return true;
}
 
 
/**
 * @brief Insert elements into the vector via move semantics.
 * @param pos The starting index of the insertion.
 * @param src Start of the vector containing the range of elements to insert.
 * @param src_pos Position of the first element to insert.
 * @param src_n Number of elements to insert.
 * @param srcStore The source store.
 *
 * The size of the container will be increased by @c src_n, with the elements
 * starting at @c pos copied to @c pos+src_n.
 *
 * The contents of the source range will then be moved to our vector
 * starting at @c pos.  This will be done via move semantics if possible;
 * otherwise, it will be done with a copy.
 *
 * Returns true if it is known that the vector's memory did not move,
 * false otherwise.
 */
template <class T, class ALLOC>
bool JaggedVecVectorHolder<T, ALLOC>::insertMove
  (size_t pos, void* src, size_t src_pos, size_t src_n, IAuxStore& srcStore)
{
  if (src_n <= 0) return true;
  fillTrailingZeros();
  element_type* srcp = reinterpret_cast<element_type*> (src);
  element_type* beg = srcp + src_pos;
  element_type* end = beg + src_n;
 
  vector_type& vec = this->vec();
  const element_type* orig = vec.data();
  const size_t ppos = vec[pos].begin(pos);
  vec.insert (vec.begin() + pos, beg, end);
 
  IAuxTypeVector* srcPayloadVec = srcStore.linkedVector (this->auxid());
 
  // Fill trailing zeros in the copied elements.
  if (vec[pos + src_n - 1].end() == 0) {
    size_t src_sz = srcStore.size();
    if (srcp[src_sz-1].end() == 0) {
      if (size_t src_nPayload = srcPayloadVec->getDataSpan().size) {
        // Similarly to the case in resize() above, we have two possibilities
        // here.  Suppose the vector from which we're inserting looks like:
        //
        //  0 0 1 2 0 0
        //
        // If we insert 1 element starting from index 0, then we don't
        // want to do this adjustment.  But if we insert 5 elements,
        // then we do.  Again, we can't tell the difference looking
        // at the insertion position; we need to look at the elements
        // between the insertion position and the end.
        bool adjust = false;
        for (size_t i = src_pos+src_n-1; ; --i) {
          if (srcp[i].end() != 0) {
            adjust = true;
            break;
          }
          if (i == 0) break;
        }
        if (adjust) {
          Shift shift (src_nPayload);
          for (size_t i = pos + src_n - 1; vec[i].end() == 0; --i)
          {
            shift (vec[i]);
            if (i == pos) break;
          }
        }
      }
    }
  }
 
  size_t begidx = src_pos > 0 ? srcp[src_pos-1].end() : 0;
  size_t npayload = vec[pos+src_n-1].end() - begidx;
  T* srcPayload = reinterpret_cast<T*> (srcPayloadVec->toPtr());
  bool pflag = m_linkedVec->insertMove (ppos,
                                        srcPayload,
                                        begidx,
                                        npayload,
                                        srcStore);
  std::for_each (vec.begin() + pos, vec.begin() + pos + src_n,
                 Shift (ppos - begidx));
  std::for_each (vec.begin() + pos + src_n, vec.end(),
                 Shift (npayload));
  this->storeDataSpan();
  return pflag && (vec.data() == orig);
}
 
 
//*****************************************************************************
 
 
/**
 * @brief Constructor.  Makes a new vector.
 * @param auxid The auxid of the variable this vector represents.
 * @param size Initial size of the new vector.
 * @param capacity Initial capacity of the new vector.
 * @param linkedVec Ownership of the linked vector.
 */
template <class HOLDER>
JaggedVecVectorT<HOLDER>::JaggedVecVectorT (auxid_t auxid,
                                            size_t size,
                                            size_t capacity,
                                            std::unique_ptr<IAuxTypeVector> linkedVec)
  : Base (auxid, &m_vec, linkedVec.get(), false),
    m_linkedVecHolder (std::move (linkedVec))
{
  m_vec.reserve (capacity);
  m_vec.resize (size);
}
 
 
/**
 * @brief Copy constructor.
 */
template <class HOLDER>
JaggedVecVectorT<HOLDER>::JaggedVecVectorT (const JaggedVecVectorT& other)
  : Base (other.auxid(), &m_vec, false, false),
    m_vec (other.m_vec),
    m_linkedVecHolder (other.m_linkedVec->clone())
{
  Base::m_linkedVec = m_linkedVecHolder.get();
}
 
 
/**
 * @brief Move constructor.
 */
template <class HOLDER>
JaggedVecVectorT<HOLDER>::JaggedVecVectorT (JaggedVecVectorT&& other)
  : Base (other.auxid(), &m_vec, false, other.m_linkedVec),
    m_vec (std::move (other.m_vec)),
    m_linkedVecHolder (std::move (other.m_linkedVecHolder))
{
}
 
 
/**
 * @brief Make a copy of this vector.
 */
template <class HOLDER>
inline
std::unique_ptr<IAuxTypeVector> JaggedVecVectorT<HOLDER>::clone() const
{
  return std::make_unique<JaggedVecVectorT> (*this);
}
 
 
/**
 * @brief Return ownership of the linked vector.
 */
template <class HOLDER>
inline
std::unique_ptr<IAuxTypeVector> JaggedVecVectorT<HOLDER>::linkedVector()
{
  return std::move (m_linkedVecHolder);
}
 
 
} // namespace SG