ArenaCachingHandle.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: ArenaCachingHandle.icc 470529 2011-11-24 23:54:22Z ssnyder $
/**
 * @file  AthAllocators/ArenaCachingHandle.icc
 * @author scott snyder
 * @date May 2007
 * @brief User interface for allocating memory that caches constructed objects.
 *        Inline and template implementations.
 */
 
 
namespace SG {
 
 
/**
 * @brief Constructor, passing in an index.  (For internal/testing use.)
 * @param header The group of Arenas which this Handle may reference.
 *               May be null to select the global default.
 * @param index The index of this Handle's Allocator type.
 */
template <class T, class ALLOC>
ArenaCachingHandle<T, ALLOC>::ArenaCachingHandle (ArenaHeader* header,
                                                  size_t index)
  : Base (header, index)
{
}
 
 
/**
 * @brief Constructor, passing in an optional parameter set.
 * @param params Parameters to pass to the Allocator,
 *               or nullptr to use the defaults.
 */
template <class T, class ALLOC>
ArenaCachingHandle<T, ALLOC>::ArenaCachingHandle
  (const typename ALLOC::Params* params /*= nullptr*/)
    : Base (static_cast<ArenaHeader*>(nullptr),
            Base::template makeIndex<ArenaCachingHandle, defaultParams_t> (params))
{
}
 
 
/**
 * @brief Constructor, passing in a Header and an optional parameter set.
 * @param header The group of Arenas which this Handle may reference.
 *               May be null to select the global default.
 * @param params Parameters to pass to the Allocator,
 *               or nullptr to use the defaults.
 */
template <class T, class ALLOC>
ArenaCachingHandle<T, ALLOC>::ArenaCachingHandle
  (ArenaHeader* header,
   const typename ALLOC::Params* params /*=nullptr */)
    : Base (header,
            Base::template makeIndex<ArenaCachingHandle, defaultParams_t> (params))
{
}
 
 
/**
 * @brief Constructor, passing in a Header, context, and an optional parameter set.
 * @param header The group of Arenas which this Handle may reference.
 *               May be null to select the global default.
 * @param ctx Event context identifying the event slot.
 * @param params Parameters to pass to the Allocator,
 *               or nullptr to use the defaults.
 */
template <class T, class ALLOC>
ArenaCachingHandle<T, ALLOC>::ArenaCachingHandle
  (ArenaHeader* header,
   const EventContext& ctx,
   const typename ALLOC::Params* params /*= nullptr */)
    : Base (header,
            ctx,
            Base::template makeIndex<ArenaCachingHandle, defaultParams_t> (params))
{
}
 
 
/**
 * @brief Constructor, passing in an Arena and an optional parameter set.
 * @param arena The Arena in which to create the Allocator.
 * @param params Parameters to pass to the Allocator,
 *               or nullptr to use the defaults.
 */
template <class T, class ALLOC>
ArenaCachingHandle<T, ALLOC>::ArenaCachingHandle
  (Arena* arena,
   const typename ALLOC::Params* params /*= nullptr */)
    : Base (arena,
            Base::template makeIndex<ArenaCachingHandle, defaultParams_t> (params))
{
}
 
 
/**
 * @brief Allocate a new element.
 *
 * This returns an already-initialized element.
 *
 * This is on the fast path for element allocation, so keep it small
 * and inline.
 */
template <class T, class ALLOC>
inline
typename ArenaCachingHandle<T, ALLOC>::pointer
ArenaCachingHandle<T, ALLOC>::allocate()
{
  return reinterpret_cast<pointer> (this->allocator()->allocate());
}
 
 
/**
 * @brief Internal helper: create a new Allocator instance.
 * @param params The parameters for the Allocator.
 */
template <class T, class ALLOC>
std::unique_ptr<ArenaAllocatorBase> ArenaCachingHandle<T, ALLOC>::makeAllocator
 (const typename ALLOC::Params& params)
{
  return std::make_unique<ALLOC> (params);
}
 
 
} // namespace SG