AuxTypeVector.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
/**
 * @file AthContainers/tools/AuxTypeVector.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Sep, 2013
 * @brief Implementation of @c IAuxTypeVector for specific types.
 */
 
 
 
 
namespace SG { 
 
 
/**
 * @brief Constructor.
 * @param auxid The auxid of the variable this vector represents.
 * @param vecPtr Pointer to the object (of type @c CONT).
 * @param ownFlag If true, take ownership of the object.
 * @param isLinked True if this variable is linked from another one.
 */
template <class T, class CONT>
inline
AuxTypeVectorHolder<T, CONT>::AuxTypeVectorHolder (auxid_t auxid,
                                                   vector_type* vecPtr,
                                                   bool ownFlag,
                                                   bool isLinked)
  : IAuxTypeVector (auxid, isLinked),
    m_vecPtr (vecPtr),
    m_ownFlag (ownFlag)
{
}
 
 
/**
 * @brief Destructor.
 * If @c ownFlag was true, then delete the vector object.
 */
template <class T, class CONT>
inline
AuxTypeVectorHolder<T, CONT>::~AuxTypeVectorHolder()
{
  if (m_ownFlag)
    delete m_vecPtr;
}
 
 
/**
 * @brief Copy constructor.
 * @param other Object to copy.
 */
template <class T, class CONT>
AuxTypeVectorHolder<T, CONT>::AuxTypeVectorHolder
  (const AuxTypeVectorHolder& other)
    : IAuxTypeVector (other)
{
  // If we own the payload, then make a copy, else just use the same pointer.
  m_ownFlag = other.m_ownFlag;
  if (other.m_ownFlag)
    m_vecPtr = new vector_type (*other.m_vecPtr);
  else
    m_vecPtr = other.m_vecPtr;
}
 
 
/**
 * @brief Move constructor.
 * @param other Object to move.
 */
template <class T, class CONT>
AuxTypeVectorHolder<T, CONT>::AuxTypeVectorHolder (AuxTypeVectorHolder&& other)
  : IAuxTypeVector (other)
{
  m_ownFlag = other.m_ownFlag;
  m_vecPtr = other.m_vecPtr;
  other.m_ownFlag = false;
}
 
 
/**
 * @brief Assignment.
 */
template <class T, class CONT>
AuxTypeVectorHolder<T, CONT>&
AuxTypeVectorHolder<T, CONT>::operator= (const AuxTypeVectorHolder& other)
{
  if (this != &other) {
    IAuxTypeVector::operator= (other);
    if (m_ownFlag)
      delete m_vecPtr;
    m_ownFlag = other.m_ownFlag;
    if (other.m_ownFlag)
      m_vecPtr = new vector_type (*other.m_vecPtr);
    else
      m_vecPtr = other.m_vecPtr;
  }
  return *this;
}
 
 
/**
 * @brief Move assignment.
 */
template <class T, class CONT>
AuxTypeVectorHolder<T, CONT>&
AuxTypeVectorHolder<T, CONT>::operator= (AuxTypeVectorHolder&& other)
{
  if (this != &other) {
    IAuxTypeVector::operator= (other);
    if (m_ownFlag)
      delete m_vecPtr;
    m_ownFlag = other.m_ownFlag;
    m_vecPtr = other.m_vecPtr;
    other.m_ownFlag = false;
  }
  return *this;
}
    
 
/**
 * @brief Return a reference to the payload vector.
 */
template <class T, class CONT>
inline
typename AuxTypeVectorHolder<T, CONT>::vector_type& AuxTypeVectorHolder<T, CONT>::vec()
{
  return *m_vecPtr;
}
 
 
/**
 * @brief Make a copy of this vector.
 */
template <class T, class CONT>
inline
std::unique_ptr<IAuxTypeVector> AuxTypeVectorHolder<T, CONT>::clone() const
{
  vector_type* vecPtr = new vector_type (*m_vecPtr);
  return std::make_unique<AuxTypeVectorHolder<T, CONT> > (auxid(),
                                                          vecPtr,
                                                          true,
                                                          isLinked());
}
 
 
/**
 * @brief Return a pointer to the start of the vector's data.
 */
template <class T, class CONT>
inline
void* AuxTypeVectorHolder<T, CONT>::toPtr ()
{
  if (m_vecPtr->empty())
    return nullptr;
  return m_vecPtr->data();
}
 
 
/**
 * @brief Return a pointer to the start of the vector's data.
 */
template <class T, class CONT>
inline
const void* AuxTypeVectorHolder<T, CONT>::toPtr () const
{
  if (m_vecPtr->empty())
    return nullptr;
  return std::as_const (*m_vecPtr).data();
}
 
 
/**
 * @brief Return a pointer to the STL vector itself.
 */
template <class T, class CONT>
inline
void* AuxTypeVectorHolder<T, CONT>::toVector ()
{
  return m_vecPtr;
}
 
 
/**
 * @brief Return the type of the complete payload object.
 *
 * May be different from what we get from the registry; if packing
 * is used, for example.
 */
template <class T, class CONT>
inline
const std::type_info* AuxTypeVectorHolder<T, CONT>::objType() const
{
  return &typeid(vector_type);
}
 
 
/**
 * @brief Return the size of the vector.
 */
template <class T, class CONT>
inline
size_t AuxTypeVectorHolder<T, CONT>::size () const
{
  return m_vecPtr->size() / SCALE;
}
 
 
/**
 * @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.  (Will always return false when increasing the size
 * of an empty container.)
 */
template <class T, class CONT>
inline
bool AuxTypeVectorHolder<T, CONT>::resize (size_t sz)
{
  const void* orig = m_vecPtr->empty() ? nullptr : m_vecPtr->data();
  m_vecPtr->resize (sz * SCALE,
                    Zero<typename AuxDataTraits<T>::element_type>::zero());
  return m_vecPtr->data() == orig;
}
 
 
/**
 * @brief Change the capacity of the vector.
 * @param sz The new vector capacity.
 */
template <class T, class CONT>
inline
void AuxTypeVectorHolder<T, CONT>::reserve (size_t sz)
{
  m_vecPtr->reserve (sz * SCALE);
}
 
 
} // namespace SG
 
 
namespace DataModel_detail {
 
 
/// Make an option setting.  VEC derives from @c IAuxSetOption.
template <class VEC>
bool setOptionHelper (VEC* vec, const SG::AuxDataOption& option, std::true_type)
{
  SG::IAuxSetOption* setopt = static_cast<SG::IAuxSetOption*> (vec);
  return setopt->setOption (option);
}
 
 
/// Make an option setting.  VEC does not derive from @c IAuxSetOption,
/// so this just returns failure.
template <class VEC>
bool setOptionHelper (VEC* /*vec*/, const SG::AuxDataOption& /*option*/, std::false_type)
{
  return false;
}
 
 
} // namespace DataModel_detail
 
 
namespace SG {
 
 
/**
 * @brief Make an option setting.
 * @param option The option to set.
 *
 * The interpretation of the option depends on the concrete class.
 *
 * Returns true if the option setting was successful; false otherwise.
 */
template <class T, class CONT>
inline
bool AuxTypeVectorHolder<T, CONT>::setOption (const AuxDataOption& option)
{
  // Need to instantiate different functions depending on whether or not
  // the payload implements @c SG::IAuxSetOption.
  return DataModel_detail::setOptionHelper
    (m_vecPtr,
     option,
     typename std::is_base_of<SG::IAuxSetOption,vector_type>::type());
}
 
 
/**
 * @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 CONT>
bool AuxTypeVectorHolder<T, CONT>::shift (size_t pos, ptrdiff_t offs)
{
  vector_type& vec = *m_vecPtr;
  if (offs < 0) {
    if (-offs > static_cast<ptrdiff_t>(pos)) offs = -pos;
    std::copy (vec.begin() + pos*SCALE,
               vec.end(),
               vec.begin() + (pos+offs)*SCALE);
    vec.resize (vec.size() + offs*SCALE);
    return true;
  }
  else if (offs > 0) {
    const void* orig = vec.data();
    size_t oldsz = vec.size();
    // Add to the end, zero-filled.
    vec.resize (vec.size() + offs*SCALE,
                Zero<typename AuxDataTraits<T>::element_type>::zero());
    if (oldsz != pos) {
      // Shift existing elements.  If we're just extending,
      // then we can skip this.
      std::copy (vec.rbegin() + offs*SCALE,
                 vec.rbegin() + (offs+oldsz-pos)*SCALE,
                 vec.rbegin());
      std::fill (vec.begin() + pos*SCALE,
                 vec.begin() + (pos+offs)*SCALE,
                 Zero<typename AuxDataTraits<T>::element_type>::zero());
    }
    return vec.data() == orig;
  }
  return true;
}
 
 
/**
 * @brief Helper for @c insertMove.
 * @param pos The starting index of the insertion.
 * @param beg Start of the range of elements to insert.
 * @param end End of the range of elements to insert.
 *
 * This does the actual move for POD types.
 */
template <class T, class CONT>
void AuxTypeVectorHolder<T, CONT>::insertMove1
  (typename CONT::iterator pos,
   element_type* beg,
   element_type* end,
   std::true_type)
{
  m_vecPtr->insert (pos, beg, end);
}
 
 
/**
 * @brief Helper for @c insertMove.
 * @param pos The starting index of the insertion.
 * @param beg Start of the range of elements to insert.
 * @param end End of the range of elements to insert.
 *
 * This does the actual move for non-POD types.
 */
template <class T, class CONT>
void AuxTypeVectorHolder<T, CONT>::insertMove1
  (typename CONT::iterator pos,
   element_type* beg,
   element_type* end,
   std::false_type)
{
  // std::vector doesn't provide a way to insert a range via move.
  // So first make space, then move.
  typename CONT::iterator pos2= m_vecPtr->insert (pos, end-beg, SG::Zero<element_type>::zero());
  std::move (beg, end, pos2);
}
 
 
/**
 * @brief Insert elements into the vector via move semantics.
 * @param pos The starting index of the insertion.
 * @param beg Start of the range of elements to insert.
 * @param end End of the range of elements to insert.
 * @param srcStore The source store.
 *
 * @c beg and @c end define a range of container elements, with length
 * @c len defined by the difference of the pointers divided by the
 * element size.
 *
 * The size of the container will be increased by @c len, with the elements
 * starting at @c pos copied to @c pos+len.
 *
 * The contents of the @c beg:end 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 CONT>
bool AuxTypeVectorHolder<T, CONT>::insertMove (size_t pos, void* beg, void* end,
                                               IAuxStore& /*srcStore*/)
{
  const void* orig = m_vecPtr->data();
  insertMove1 (m_vecPtr->begin() + pos*SCALE,
               reinterpret_cast<element_type*> (beg),
               reinterpret_cast<element_type*> (end),
               typename std::conjunction<std::is_standard_layout<element_type>,
                                         std::is_trivial<element_type> >::type());
  return m_vecPtr->data() == orig;
}
 
 
} // namespace SG
 
 
namespace DataModel_detail {
 
 
/// Specialization for the case of types that can be packed.
template <class T, class ALLOC>
std::unique_ptr<SG::IAuxTypeVector> makePacked (SG::auxid_t auxid,
                                                bool isLinked,
                                                std::vector<T, ALLOC>& v,
                                                std::true_type)
{
  // Make the new container and move our contents.
  auto iv =
    std::make_unique<SG::AuxTypeVector<T, ALLOC, SG::PackedContainer<T, ALLOC> > > (auxid, 0, 0, isLinked);
  iv->vec().swap (v);
#ifdef __COVERITY__
  // Coverity gives a bogus complaint about the derived->base conversion here.
  return std::unique_ptr<SG::IAuxTypeVector> (iv.release());
#else
  return iv;
#endif
}
 
 
/// Specialization for the case of types that cannot be packed.
template <class T, class FLAG>
std::unique_ptr<SG::IAuxTypeVector> makePacked (SG::auxid_t, bool, T&, FLAG)
{
  return nullptr;
}
 
 
/// Metafunction to determine if a @c vector<T> can be packed.
/// Arithmetic types can be packed, as can arbitrarily-nested vectors
/// of them, except that integers larger than 32 bits and long double
/// cannot be packed.
template <class T>
struct can_pack
{
  typedef typename std::is_arithmetic<T>::type type;
};
template <>
struct can_pack<uint64_t>
{
  typedef std::false_type type;
};
template <>
struct can_pack<int64_t>
{
  typedef std::false_type type;
};
template <>
struct can_pack<long double>
{
  typedef std::false_type type;
};
template <class T, class ALLOC>
struct can_pack<std::vector<T, ALLOC> >
{
  typedef typename can_pack<T>::type type;
};
 
 
} // namespace DataModel_detail
 
 
namespace SG {
 
 
/**
 * @brief Try to convert this aux vector to a @c PackedContainer.
 *
 * If successful, returns a newly-allocated @c IAuxTypeVector.
 * In this case, the contents of the vector will have been moved
 * to the new vector (and this object will be empty).
 *
 * Returns null on failure.
 */
template <class T, class CONT>
std::unique_ptr<IAuxTypeVector> AuxTypeVectorHolder<T, CONT>::toPacked()
{
  /// Use the proper instantiation depending on whether or not
  /// this type can be packed.
  return DataModel_detail::makePacked
    (auxid(), isLinked(), *m_vecPtr, typename DataModel_detail::can_pack<T>::type());
}
 
 
//**********************************************************************
 
 
/**
 * @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 isLinked True if this variable is linked from another one.
 */
template <class HOLDER>
AuxTypeVectorT<HOLDER>::AuxTypeVectorT (auxid_t auxid,
                                        size_t size,
                                        size_t capacity,
                                        bool isLinked)
  : Base (auxid, &m_vec, false, isLinked)
{
  m_vec.reserve (capacity * Base::SCALE);
  m_vec.resize (size * Base::SCALE);
}
 
 
/**
 * @brief Copy constructor.
 */
template <class HOLDER>
AuxTypeVectorT<HOLDER>::AuxTypeVectorT (const AuxTypeVectorT& other)
  : Base (other.auxid(), &m_vec, false, other.isLinked()),
    m_vec (other.m_vec)
{
}
 
 
/**
 * @brief Move constructor.
 */
template <class HOLDER>
AuxTypeVectorT<HOLDER>::AuxTypeVectorT (AuxTypeVectorT&& other)
  : Base (other.auxid(), &m_vec, false, other.isLinked()),
    m_vec (std::move (other.m_vec))
{
}
 
 
/**
 * @brief Assignment.
 */
template <class HOLDER>
AuxTypeVectorT<HOLDER>&
AuxTypeVectorT<HOLDER>::operator= (const AuxTypeVectorT& other)
{
  if (this != &other) {
    Base::IAuxTypeVector::operator= (other);
    m_vec = other.m_vec;
  }
  return *this;
}
 
 
/**
 * @brief Move assignment.
 */
template <class HOLDER>
AuxTypeVectorT<HOLDER>&
AuxTypeVectorT<HOLDER>::operator= (AuxTypeVectorT&& other)
{
  if (this != &other) {
    Base::IAuxTypeVector::operator= (other);
    m_vec = std::move (other.m_vec);
  }
  return *this;
}
 
 
/**
 * @brief Make a copy of this vector.
 */
template <class HOLDER>
inline
std::unique_ptr<IAuxTypeVector> AuxTypeVectorT<HOLDER>::clone() const
{
  return std::make_unique<AuxTypeVectorT> (*this);
}
 
 
} // namespace SG