DataPool.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//-----------------------------------------------------------
// .icc file for DataPool
//-----------------------------------------------------------
// includes:
#include <algorithm>
#include "GaudiKernel/System.h"
 
 
#define DATAPOOL_T template <typename VALUE, DataPoolClearFuncPtr_t<VALUE> clear>
DATAPOOL_T
const typename DataPool<VALUE, clear>::alloc_t::Params DataPool<VALUE, clear>::s_params
  = DataPool<VALUE, clear>::initParams();
 
 
#if __GNUC__ >= 12
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Waddress"
#endif
DATAPOOL_T
typename DataPool<VALUE, clear>::alloc_t::Params DataPool<VALUE, clear>::initParams()
{
  typename alloc_t::Params params = alloc_t::initParams<VALUE> (s_minRefCount);
  if (clear != nullptr) {
    params.clear = callClear;
  }
  return params;
}
#if __GNUC__ >= 12
# pragma GCC diagnostic pop
#endif
 
 
DATAPOOL_T
void DataPool<VALUE, clear>::callClear (SG::ArenaAllocatorBase::pointer p)
{
  clear (reinterpret_cast<VALUE*> (p));
}
 
 
//-----------------------------------------------------------
 
DATAPOOL_T
DataPool<VALUE, clear>::DataPool(size_type n /*= 0*/)
  : m_handle (&s_params)
{
  if (n > 0)
    m_handle.reserve (std::max (n, s_minRefCount));
}
 
DATAPOOL_T
DataPool<VALUE, clear>::DataPool(const EventContext& ctx,
                                 size_type n /*= 0*/)
  : m_handle (static_cast<SG::ArenaHeader*>(nullptr), ctx, &s_params)
{
  if (n > 0)
    m_handle.reserve (std::max (n, s_minRefCount));
}
 
DATAPOOL_T
DataPool<VALUE, clear>::DataPool(SG::Arena* arena,
                                 size_type n /*= 0*/)
  : m_handle (arena, &s_params)
{
  if (n > 0)
    m_handle.reserve (std::max (n, s_minRefCount));
}
 
//-----------------------------------------------------------
/// release all elements in the pool.
DATAPOOL_T
void DataPool<VALUE, clear>::reset()
{
  m_handle.reset();
}
 
/// free all memory in the pool.
DATAPOOL_T
void DataPool<VALUE, clear>::erase()
{
  m_handle.erase();
}
//-----------------------------------------------------------
// reserve space for the pool
// allocated elements will not be deleted.
 
DATAPOOL_T
void DataPool<VALUE, clear>::reserve(unsigned int size)
{
  m_handle.reserve (size);
}
 
 
DATAPOOL_T
void DataPool<VALUE, clear>::prepareToAdd(unsigned int size)
{
  if (this->capacity() - this->allocated() < size) {
    this->reserve(this->allocated() + size);
  }
}
 
DATAPOOL_T
unsigned int DataPool<VALUE, clear>::capacity()
{
  return m_handle.stats().elts.total;
}
 
DATAPOOL_T
unsigned int DataPool<VALUE, clear>::allocated()
{
  return m_handle.stats().elts.inuse;
}
 
 
//-----------------------------------------------------------
/// begin iterators over pool
DATAPOOL_T
typename DataPool<VALUE, clear>::iterator DataPool<VALUE, clear>::begin()
{
  return iterator (m_handle.begin());
}
 
DATAPOOL_T
typename DataPool<VALUE, clear>::const_iterator DataPool<VALUE, clear>::begin() const
{
  return const_Iterator (m_handle.begin());
}
 
//-----------------------------------------------------------
/// the end() method will allow looping over only valid elements
/// and not over ALL elements of the pool
 
DATAPOOL_T
typename DataPool<VALUE, clear>::iterator DataPool<VALUE, clear>::end()
{
  return iterator (m_handle.end());
}
 
DATAPOOL_T
typename DataPool<VALUE, clear>::const_iterator DataPool<VALUE, clear>::end() const {
  return const_iterator (m_handle.end());
}
 
//-----------------------------------------------------------
/// typename of pool
DATAPOOL_T
const std::string& DataPool<VALUE, clear>::typeName() {
  static std::string name = System::typeinfoName (typeid (VALUE));
  return name;
}
 
//-----------------------------------------------------------
/// obtain the next available element in pool by pointer
/// pool is resized if reached its limit
DATAPOOL_T
inline
typename DataPool<VALUE, clear>::pointer DataPool<VALUE, clear>::nextElementPtr()
{
  return m_handle.allocate();
}
 
 
#undef DATAPOOL_T