AuxVectorBase.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
/**
 * @file AthContainers/AuxVectorBase.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Oct, 2013
 * @brief Manage index tracking and synchronization of auxiliary data.
 */
 
 
namespace SG {
 
 
/**
 * @brief Return true if index tracking is enabled for this container.
 */
inline
bool AuxVectorBase::trackIndices() const
{
  return m_trackIndices;
}
 
 
/**
 * @brief Synonym for @c setStore with @c IConstAuxStore.
 * @param store The new store.
 */
inline
void AuxVectorBase::setConstStore (const SG::IConstAuxStore* store)
{
  setStore (store);
}
 
 
/**
 * @brief Synonym for @c setStore with @c IAuxStore.
 * @param store The new store.
 */
inline
void AuxVectorBase::setNonConstStore (SG::IAuxStore* store)
{
  setStore (store);
}
 
 
/**
 * @brief Test to see if a variable exists in the store.
 * @param name Name of the aux variable.
 * @param clsname The name of the associated class.  May be blank.
 */
template <class T>
inline
bool AuxVectorBase::isAvailable (const std::string& name,
                                 const std::string& clsname /*= ""*/) const
{
  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
  return AuxVectorData::isAvailable (id);
}
 
 
/**
 * @brief Test to see if a variable is available for writing.
 * @param name Name of the aux variable.
 * @param clsname The name of the associated class.  May be blank.
 */
template <class T>
inline
bool
AuxVectorBase::isAvailableWritable (const std::string& name,
                                    const std::string& clsname /*= ""*/)
{
  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
  return AuxVectorData::isAvailableWritable (id);
}
 
 
/**
 * @brief Test to see if a variable is available for writing as a decoration.
 * @param name Name of the aux variable.
 * @param clsname The name of the associated class.  May be blank.
 */
template <class T>
inline
bool
AuxVectorBase::isAvailableWritableAsDecoration (const std::string& name,
                                                const std::string& clsname /*= ""*/) const
{
  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name, clsname);
  return AuxVectorData::isAvailableWritableAsDecoration (id);
}
 
 
/**
 * @brief Return a span over an aux data item.
 * @param auxid The desired aux data item.
 *
 * This will return a span containing the value of the requested
 * auxiliary variable for all elements in the container.
 * If the item doesn't exist, it will be created.
 * Errors are signaled by raising an exception.
 * Note that the @c value_type of the span is not necessarily @c T;
 * an example is @c bool for which we return a span of @c char.
 */
template <class T>
AuxVectorBase::span<T> AuxVectorBase::getDataSpan (const std::string& name)
{
  using container_pointer_type = typename AuxDataTraits<T>::container_pointer_type;
  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
  auto beg = reinterpret_cast<container_pointer_type> (AuxVectorData::getDataArray (id));
  return span<T> (beg, size_v());
}
 
 
/**
 * @brief Return a span over an aux data item.
 * @param auxid The desired aux data item.
 *
 * This will return a span containing the value of the requested
 * auxiliary variable for all elements in the container.
 * If the item doesn't exist, it will be created.
 * Errors are signaled by raising an exception.
 * Note that the @c value_type of the span is not necessarily @c T;
 * an example is @c bool for which we return a span of @c char.
 */
template <class T>
AuxVectorBase::const_span<T>
AuxVectorBase::getDataSpan (const std::string& name) const
{
  using const_container_pointer_type = typename AuxDataTraits<T>::const_container_pointer_type;
  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
  auto beg = reinterpret_cast<const_container_pointer_type> (AuxVectorData::getDataArray (id));
  return const_span<T> (beg, size_v());
}
 
 
/**
 * @brief Return a span over an aux data item for a decoration.
 * @param auxid The desired aux data item.
 *
 * This will return a span containing the value of the requested
 * auxiliary variable for all elements in the container.
 * If the item doesn't exist, it will be created.
 * Errors are signaled by raising an exception.
 * Note that the @c value_type of the span is not necessarily @c T;
 * an example is @c bool for which we return a span of @c char.
 *
 * The difference between @c getDecorationSpan and @c getDataSpan is that
 * @c getDecorationSpan takes a const container as input, but returns
 * a span over non-const objects.  This will only succeed if either the
 * container is not locked or the item was first accessed
 * as a decoration.
 */
template <class T>
AuxVectorBase::span<T>
AuxVectorBase::getDecorationSpan (const std::string& name) const
{
  using container_pointer_type = typename AuxDataTraits<T>::container_pointer_type;
  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
  auto beg = reinterpret_cast<container_pointer_type> (AuxVectorData::getDecorationArray (id));
  return span<T> (beg, size_v());
}
 
 
/**
 * @brief Return a span over an aux data item.
 * @param auxid The desired aux data item.
 *
 * This will return a span containing the value of the requested
 * auxiliary variable for all elements in the container.
 * If the item doesn't exist, it will be created.
 * Errors are signaled by raising an exception.
 * Note that the @c value_type of the span is not necessarily @c T;
 * an example is @c bool for which we return a span of @c char.
 */
template <class T>
AuxVectorBase::const_span<T>
AuxVectorBase::getConstDataSpan (const std::string& name) const
{
  using const_container_pointer_type = typename AuxDataTraits<T>::const_container_pointer_type;
  auxid_t id = SG::AuxTypeRegistry::instance().getAuxID<T> (name);
  auto beg = reinterpret_cast<const_container_pointer_type> (AuxVectorData::getDataArray (id));
  return const_span<T> (beg, size_v());
}
 
 
/**
 * @brief Initialize index tracking mode.
 * @param ownPolicy The container ownership policy.
 * @param indexTrackingPolicy The requested index tracking policy.
 *
 * DVL should be the most-derived class for this container.
 *
 * This handles the logic for setting the state of index tracking.
 * If this container does not handle aux data, then index tracking
 * is always off.  Otherwise, it depends on the requested policies.
 * In any case, it is an error to turn off index tracking
 * for a container that has an associated aux store.
 */
template <class DVL>
inline
void
AuxVectorBase::initAuxVectorBase (SG::OwnershipPolicy ownPolicy,
                                  SG::IndexTrackingPolicy indexTrackingPolicy)
{
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  this->initAuxVectorBase1 (typename AuxStore_traits<DVL>::flag(),
                            ownPolicy,
                            indexTrackingPolicy);
}
 
 
/**
 * @brief Swap with another container.
 * @param other The container with which to swap.
 */
inline
void AuxVectorBase::swap (AuxVectorBase& other)
{
  std::swap (m_trackIndices, other.m_trackIndices);
  SG::AuxVectorData::swap (other);
}
 
 
/**
 * @brief Set container/index for all elements within a range.
 * @param beg Beginning of the range.
 * @param end End of the range.
 * @param first Index to set for the first element in the range.
 *
 * For all elements in the range, the container will be set to this container,
 * and indices will be set sequentially, starting with @c first.
 *
 * @c ForwardIterator should be an iterator over the @c DataVector
 * (not a base iterator).
 */
template <class ForwardIterator>
inline
void AuxVectorBase::setIndices (ForwardIterator beg,
                                ForwardIterator end,
                                size_t first /*= 0*/)
{
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  typedef typename std::iterator_traits<ForwardIterator>::value_type valtype;
  setIndices1 (typename AuxStore_traits<valtype>::flag(),
               beg, end, first);
}
 
 
/**
 * @brief Set container/index for all elements within a range.
 * @param beg Beginning of the range.
 * @param end End of the range.
 * @param first Index to set for the first element in the range.
 *
 * This is the no-auxdata case; doesn't do anything other than checking
 * @c m_trackIndices.
 */
template <class ForwardIterator>
inline
void AuxVectorBase::setIndices1 (const std::false_type&,
                                 ForwardIterator,
                                 ForwardIterator,
                                 size_t)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Set container/index for all elements within a range.
 * @param beg Beginning of the range.
 * @param end End of the range.
 * @param first Index to set for the first element in the range.
 *
 * This is the auxdata case.
 * For all elements in the range, the container will be set to this container,
 * and indices will be set sequentially, starting with @c first.
 */
template <class ForwardIterator>
void AuxVectorBase::setIndices1 (const std::true_type&,
                                 ForwardIterator beg,
                                 ForwardIterator end,
                                 size_t first)
{
  if (!m_trackIndices)
    return;
  
  for (; beg != end; ++beg) {
    if (*beg)
      (*beg)->setIndex (first, this);
    ++first;
  }
}
 
 
/**
 * @brief Clear the container / index for element @c elt.
 * @param elt Iterator to the element to clear.
 *
 * @c ForwardIterator should be an iterator over the @c DataVector
 * (not a base iterator).
 */
template <class ForwardIterator>
inline
void AuxVectorBase::clearIndex (ForwardIterator elt)
{
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  typedef typename std::iterator_traits<ForwardIterator>::value_type valtype;
  clearIndex1 (typename AuxStore_traits<valtype>::flag(), elt);
}
 
 
/**
 * @brief Clear the container / index for element @c elt.
 * @param elt Iterator to the element to clear.
 *
 * This is the no-auxdata case; doesn't do anything other than checking
 * @c m_trackIndices.
 */
template <class ForwardIterator>
inline
void AuxVectorBase::clearIndex1 (const std::false_type&,
                                 ForwardIterator /*elt*/)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Clear the container / index for element @c elt.
 * @param elt Iterator to the element to clear.
 *
 * This is the auxdata case.
 */
template <class ForwardIterator>
void AuxVectorBase::clearIndex1 (const std::true_type&,
                                 ForwardIterator elt)
{
  if (!m_trackIndices)
    return;
  
  if (*elt)
    (*elt)->setIndex (0, 0);
}
 
 
/**
 * @brief Clear the container / index for a range of elements.
 * @param beg Beginning of the range.
 * @param end End of the range.
 *
 * @c ForwardIterator should be an iterator over the @c DataVector
 * (not a base iterator).
 */
template <class ForwardIterator>
void AuxVectorBase::clearIndices (ForwardIterator beg,
                                  ForwardIterator end)
{
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  typedef typename std::iterator_traits<ForwardIterator>::value_type valtype;
  clearIndices1 (typename AuxStore_traits<valtype>::flag(),
                 beg, end);
}
 
 
/**
 * @brief Clear the container / index for a range of elements.
 * @param beg Beginning of the range.
 * @param end End of the range.
 *
 * No-auxdata case; a no-op except for checking @c m_trackIndices.
 */
template <class ForwardIterator>
inline
void AuxVectorBase::clearIndices1 (const std::false_type&,
                                   ForwardIterator,
                                   ForwardIterator)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Clear the container / index for a range of elements.
 * @param beg Beginning of the range.
 * @param end End of the range.
 *
 * Auxdata case.
 */
template <class ForwardIterator>
void AuxVectorBase::clearIndices1 (const std::true_type&,
                                   ForwardIterator beg,
                                   ForwardIterator end)
{
  if (!m_trackIndices)
    return;
 
  for (; beg != end; ++beg)
    if (*beg)
      (*beg)->setIndex (0, 0);
}
 
 
/**
 * @brief Resize the aux data associated with this container.
 * @param size The new container size.
 *
 * DVL should be the most-derived class for this container.
 */
template <class DVL>
inline
void AuxVectorBase::resize (size_t size)
{
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  resize1 (typename AuxStore_traits<DVL>::flag(), size);
}
 
 
/**
 * @brief Resize the aux data associated with this container.
 * @param size The new container size.
 *
 * The no-auxdata case; a no-op except for checking @c m_trackIndices.
 */
inline
void
AuxVectorBase::resize1 (const std::false_type&, size_t /*size*/)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Change the capacity of the aux data associated with this container.
 * @param size The new container size.
 *
 * DVL should be the most-derived class for this container.
 */
template <class DVL>
inline
void AuxVectorBase::reserve (size_t size)
{
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  reserve1 (typename AuxStore_traits<DVL>::flag(), size);
}
 
 
/**
 * @brief Change the capacity of the aux data associated with this container.
 * @param size The new container size.
 *
 * The no-auxdata case; a no-op except for checking @c m_trackIndices.
 */
inline
void AuxVectorBase::reserve1 (const std::false_type&, size_t)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Shift the elements of the container.
 * @param cont The container that's being shifted.
 * @param pos The starting index for the shift.
 * @param offs The (signed) amount of the shift.
 *
 * The container should be the derived container.
 * The elements in the container should have already been shifted;
 * this operation will then adjust the element indices and also shift
 * the elements in the vectors for all aux data items.
 * @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).
 */
template <class DVL>
inline
void AuxVectorBase::shift (DVL& cont,
                           size_t pos,
                           ptrdiff_t offs)
{
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  shift1 (typename AuxStore_traits<DVL>::flag(),
          cont, pos, offs);
}
 
 
/**
 * @brief Shift the elements of the container.
 * @param cont The container that's being shifted.
 * @param pos The starting index for the shift.
 * @param offs The (signed) amount of the shift.
 *
 * No-auxdata version; a no-op except for checking @c m_trackIndices.
 */
template <class DVL>
inline
void AuxVectorBase::shift1 (const std::false_type&,
                            DVL& /*cont*/,
                            size_t /*pos*/, ptrdiff_t /*offs*/)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Shift the elements of the container.
 * @param cont The container that's being shifted.
 * @param pos The starting index for the shift.
 * @param offs The (signed) amount of the shift.
 *
 * Auxdata version.
 *
 * The container should be the derived container.
 * The elements in the container should have already been shifted;
 * this operation will then adjust the element indices and also shift
 * the elements in the vectors for all aux data items.
 * @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).
 */
template <class DVL>
void AuxVectorBase::shift1 (const std::true_type&,
                            DVL& cont,
                            size_t pos, ptrdiff_t offs)
{
  if (!m_trackIndices) return;
 
  typename DVL::iterator end = cont.end();
  typename DVL::iterator pos_it = cont.begin() + pos + offs;
  for (; pos_it != end; ++pos_it)
  {
    SG::AuxElement* elt = *pos_it;
    elt->setIndex (elt->index() + offs, this);
  }
 
  if (this->hasNonConstStore()) {
    this->getStore()->shift (pos, offs);
    clearCache();
  }
  else if (this->hasStore())
    throw SG::ExcConstAuxData ("shift");
}
 
 
/**
 * @brief Set index on an element and copy auxiliary data.
 * @param index Container index at which the new element is being added.
 * @param p The new element being added.
 * @param clear If true, then any auxiliary data initially associated
 *              with @c p are cleared after being copied.
 * @param skipDestClear Normally, if the elements do not have auxiliary data,
 *                      then the variables of the destination are cleared.
 *                      If this flag is true, then this clear is skipped.
 *                      This can be appropriate as part of a push_back,
 *                      where the destination is already known to be clear.
 *
 * Overload for the no-auxdata case.
 */
inline
void
AuxVectorBase::moveAux (size_t /*index*/,
                        const void /*p*/*,
                        bool /*clear = false*/,
                        bool /*skipDestClear = false*/)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Set index on a range of elements and copy auxiliary data.
 * @param index Container index at which the first new element is being added.
 * @param beg The start of the range of new elements.
 * @param end The end of the range of new elements.
 * @param clear If true, then any auxiliary data initially associated
 *              with the elements are cleared after being copied.
 * @param skipDestClear Normally, if the elements do not have auxiliary data,
 *                      then the variables of the destination are cleared.
 *                      If this flag is true, then this clear is skipped.
 *                      This can be appropriate as part of a push_back,
 *                      where the destination is already known to be clear.
 *
 * The elements in the range are being a added to the container at @c index.
 * If the new elements have associated auxiliary data,
 * copy it to the container starting at @c index.
 * Then set the container / index on the elements in the range.
 *
 * @c ForwardIterator should be an iterator over the @c DataVector
 * (not a base iterator).
 */
template <class ForwardIterator>
void
AuxVectorBase::moveAux (size_t index, ForwardIterator beg, ForwardIterator end,
                        bool clear /*= false*/,
                        bool skipDestClear /*= false*/)
{
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  typedef typename std::iterator_traits<ForwardIterator>::value_type valtype;
  moveAux1 (typename AuxStore_traits<valtype>::flag(),
            index, beg, end, clear, skipDestClear);
}
 
 
/**
 * @brief Set index on a range of elements and copy auxiliary data.
 * @param index Container index at which the first new element is being added.
 * @param beg The start of the range of new elements.
 * @param end The end of the range of new elements.
 * @param clear If true, then any auxiliary data initially associated
 *              with the elements are cleared after being copied.
 * @param skipDestClear Normally, if the elements do not have auxiliary data,
 *                      then the variables of the destination are cleared.
 *                      If this flag is true, then this clear is skipped.
 *                      This can be appropriate as part of a push_back,
 *                      where the destination is already known to be clear.
 *
 * No-auxdata version; a no-op except for checking @c m_trackIndices.
 */
template <class ForwardIterator>
inline
void AuxVectorBase::moveAux1 (const std::false_type&,
                              size_t /*index*/,
                              ForwardIterator /*beg*/,
                              ForwardIterator /*end*/,
                              bool /*clear = false*/,
                              bool /*skipDestClear = false*/)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Set index on a range of elements and copy auxiliary data.
 * @param index Container index at which the first new element is being added.
 * @param beg The start of the range of new elements.
 * @param end The end of the range of new elements.
 * @param clear If true, then any auxiliary data initially associated
 *              with the elements are cleared after being copied.
 * @param skipDestClear Normally, if the elements do not have auxiliary data,
 *                      then the variables of the destination are cleared.
 *                      If this flag is true, then this clear is skipped.
 *                      This can be appropriate as part of a push_back,
 *                      where the destination is already known to be clear.
 *
 * The elements in the range are being a added to the container at @c index.
 * If the new elements have associated auxiliary data,
 * copy it to the container starting at @c index.
 * Then set the container / index on the elements in the range.
 *
 * The auxdata case.
 */
template <class ForwardIterator>
void AuxVectorBase::moveAux1 (const std::true_type&,
                              size_t index,
                              ForwardIterator beg,
                              ForwardIterator end,
                              bool clear /*= false*/,
                              bool skipDestClear /*= false*/)
{
  if (!m_trackIndices)
    return;
 
  while (beg != end) {
    this->moveAux (index, *beg, clear, skipDestClear);
    ++beg;
    ++index;
  }
}
 
 
/**
 * @brief Set index on an element and copy auxiliary data,
 *        specialized for the case of no clearing (and inlined).
 * @param index Container index at which the new element is being added.
 * @param p The new element being added.
 *
 * Element @c p is being added to the container at @c index.
 * If @c p has associated auxiliary data, copy it to the container
 * at @c index.  Then set the container / index on @c p.
 *
 * This is equivalent to moveAux with clear=false and skipDestClear=true.
 * m_trackIndices must also be true to call this.
 */
inline
void AuxVectorBase::moveAuxNoClear (size_t index, SG::AuxElement* p)
{
  if (p->hasStore()) {
    AuxElement::copyAuxHelper (*this, index, *p, false);
  }
  p->setIndex (index, this);
}
 
 
/**
 * @brief Set index on an element and copy auxiliary data,
 *        specialized for the case of no clearing (and inlined).
 * @param index Container index at which the new element is being added.
 * @param p The new element being added.
 *
 * Element @c p is being added to the container at @c index.
 * If @c p has associated auxiliary data, copy it to the container
 * at @c index.  Then set the container / index on @c p.
 *
 * This is equivalent to moveAux with clear=false and skipDestClear=true.
 * m_trackIndices must also be true to call this.
 * Overload for the no-auxdata case.
 */
inline
void AuxVectorBase::moveAuxNoClear (size_t /*index*/, const void* /*p*/)
{
}
 
 
/**
 * @brief Swap indices and auxiliary data between two elements.
 * @param aindex Index of the first element, in this container.
 * @param bindex Index of the second element, in @c bcont.
 * @param a Pointer to the first element.
 * @param b Pointer to the second element.
 * @param bcont Container holding the second element.
 *              (May be the same as this, but doesn't have to be.)
 *
 * This is the no-auxdata case; it is a no-op except for checking
 * @c m_trackIndices.
 */
inline
void AuxVectorBase::swapElementsAux (size_t /*aindex*/,
                                     size_t /*bindex*/,
                                     const void* /*a*/,
                                     const void* /*b*/,
                                     AuxVectorBase* /*bcont*/)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Reset indices / reorder aux data after elements have been permuted.
 * @param index Index in the container of the start of the range.
 * @param beg Start of the range of elements to process.
 * @param end End of the range of elements to process.
 *
 * Call this after some operation that has permuted the elements in the
 * container (such as sort).  The index information in the elements
 * will be used to permute all auxiliary data in the same way.
 * Finally, all the indices will be reset in the correct order.
 *
 * @c ForwardIterator should be an iterator over the @c DataVector
 * (not a base iterator).
 */
template <class ForwardIterator>
inline
void AuxVectorBase::resortAux (size_t index,
                               ForwardIterator beg,
                               ForwardIterator end)
{
  // If the xAOD base classes are used, then they always report that
  // static auxids are present.  However, if the container is empty,
  // these variables are not actually retrievable, which can cause
  // an exception in the ResortAuxHelper ctor.  Work around here.
  if (beg==end) return;
 
  // Forward to the appropriate specialization, depending on whether
  // or not aux data is supported.
  typedef typename std::iterator_traits<ForwardIterator>::value_type valtype;
  resortAux1 (typename AuxStore_traits<valtype>::flag(),
              index, beg, end);
}
 
 
/**
 * @brief Reset indices / reorder aux data after elements have been permuted.
 * @param index Index in the container of the start of the range.
 * @param beg Start of the range of elements to process.
 * @param end End of the range of elements to process.
 *
 * No-auxdata version; a no-op except for checking @c m_trackIndices.
 */
template <class ForwardIterator>
inline
void AuxVectorBase::resortAux1 (const std::false_type&,
                                size_t /*index*/,
                                ForwardIterator /*beg*/,
                                ForwardIterator /*end*/)
{
  ATHCONTAINERS_ASSERT (!m_trackIndices);
}
 
 
/**
 * @brief Reset indices / reorder aux data after elements have been permuted.
 * @param index Index in the container of the start of the range.
 * @param beg Start of the range of elements to process.
 * @param end End of the range of elements to process.
 *
 * Call this after some operation that has permuted the elements in the
 * container (such as sort).  The index information in the elements
 * will be used to permute all auxiliary data in the same way.
 * Finally, all the indices will be reset in the correct order.
 *
 * The auxdata case.
 */
template <class ForwardIterator>
void AuxVectorBase::resortAux1 (const std::true_type&,
                                size_t index,
                                ForwardIterator beg,
                                ForwardIterator end)
{
  if (!m_trackIndices) return;
  if (!this->hasStore()) {
    this->setIndices (beg, end, index);
    return;
  }
  if (!this->hasNonConstStore()) {
    throw SG::ExcConstAuxData ("resortAux");
  }
 
  ResortAuxHelper h (end-beg, index, *this);
  for (size_t i = 0; beg < end; ++beg, ++i)
    h.resortElement (i, *beg);
}
 
 
/// Helper to call @c getDataArray from @c ResortAuxHelper.
inline
void* AuxVectorBase::getDataArrayForResort (SG::auxid_t auxid)
{
  return this->getDataArray (auxid);
}
 
 
/// Helper to call @c setIndex from @c ResortAuxHelper.
inline
void AuxVectorBase::setIndexForResort (SG::AuxElement* elt, size_t i)
{
  elt->setIndex (i, this);
}
 
 
} // namespace SG