Allocator.hpp File Reference

#include "CeresEngine/Macros.hpp"
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <foonathan/memory/aligned_allocator.hpp>
#include <foonathan/memory/deleter.hpp>
#include <foonathan/memory/fallback_allocator.hpp>
#include <foonathan/memory/iteration_allocator.hpp>
#include <foonathan/memory/joint_allocator.hpp>
#include <foonathan/memory/memory_arena.hpp>
#include <foonathan/memory/memory_pool.hpp>
#include <foonathan/memory/memory_pool_collection.hpp>
#include <foonathan/memory/memory_resource_adapter.hpp>
#include <foonathan/memory/segregator.hpp>
#include <foonathan/memory/static_allocator.hpp>
#include <foonathan/memory/std_allocator.hpp>
#include <foonathan/memory/temporary_allocator.hpp>
#include <foonathan/memory/tracking.hpp>
#include <memory>
#include <scoped_allocator>

Go to the source code of this file.

Classes
struct	CeresEngine::DefaultAllocator
class	CeresEngine::Arena< N, Alignment >
class	CeresEngine::ShortAllocator< T, N, Align >
struct	CeresEngine::ShortAllocator< T, N, Align >::rebind< Up >

Namespaces
namespace	CeresEngine
namespace	CeresEngine::BucketDistribution

Typedefs
using	CeresEngine::MemoryBlock = foonathan::memory::memory_block
template<typename Allocator >
using	CeresEngine::AllocatorTraits = foonathan::memory::allocator_traits< Allocator >
template<typename Allocator >
using	CeresEngine::ComposableAllocatorTraits = foonathan::memory::composable_allocator_traits< Allocator >
template<class StoragePolicy , class Mutex >
using	CeresEngine::AllocatorStorage = foonathan::memory::allocator_storage< StoragePolicy, Mutex >
template<class RawAllocator >
using	CeresEngine::DirectStorage = foonathan::memory::direct_storage< RawAllocator >
template<class RawAllocator >
using	CeresEngine::ReferenceStorage = foonathan::memory::reference_storage< RawAllocator >
template<class RawAllocator >
using	CeresEngine::AllocatorReference = foonathan::memory::allocator_reference< RawAllocator >
using	CeresEngine::AnyAllocator = foonathan::memory::any_allocator
using	CeresEngine::AnyAllocatorReference = foonathan::memory::any_allocator_reference
template<class RawAllocator >
using	CeresEngine::AllocatorAdapter = foonathan::memory::allocator_adapter< RawAllocator >
template<class RawAllocator , class Mutex = std::mutex>
using	CeresEngine::ThreadSafeAllocator = foonathan::memory::thread_safe_allocator< RawAllocator, Mutex >
template<class RawAllocator >
using	CeresEngine::AlignedAllocator = foonathan::memory::aligned_allocator< RawAllocator >
using	CeresEngine::TemporaryAllocator = foonathan::memory::temporary_allocator
using	CeresEngine::TemporaryStackInitializer = foonathan::memory::temporary_stack_initializer
template<class Default , class Fallback >
using	CeresEngine::FallbackAllocator = foonathan::memory::fallback_allocator< Default, Fallback >
using	CeresEngine::HeapAllocator = foonathan::memory::heap_allocator
template<std::size_t N, class BlockOrRawAllocator = DefaultAllocator>
using	CeresEngine::IterationAllocator = foonathan::memory::iteration_allocator< N, BlockOrRawAllocator >
template<class BlockOrRawAllocator = DefaultAllocator>
using	CeresEngine::DoubleFrameAllocator = foonathan::memory::double_frame_allocator< BlockOrRawAllocator >
using	CeresEngine::MallocAllocator = foonathan::memory::malloc_allocator
template<class BlockAllocator = DefaultAllocator, bool Cached = true>
using	CeresEngine::MemoryArena = foonathan::memory::memory_arena< BlockAllocator, Cached >
template<class RawAllocator = DefaultAllocator, unsigned Num = 2, unsigned Den = 1>
using	CeresEngine::GrowingBlockAllocator = foonathan::memory::growing_block_allocator< RawAllocator, Num, Den >
template<class RawAllocator = DefaultAllocator>
using	CeresEngine::FixedBlockAllocator = foonathan::memory::fixed_block_allocator< RawAllocator >
using	CeresEngine::NodePool = foonathan::memory::node_pool
using	CeresEngine::ArrayPool = foonathan::memory::array_pool
using	CeresEngine::SmallNodePool = foonathan::memory::small_node_pool
template<typename PoolType = foonathan::memory::node_pool, class BlockOrRawAllocator = DefaultAllocator>
using	CeresEngine::MemoryPool = foonathan::memory::memory_pool< PoolType, BlockOrRawAllocator >
using	CeresEngine::BucketDistribution::IdentityBuckets = foonathan::memory::identity_buckets
using	CeresEngine::BucketDistribution::Log2Buckets = foonathan::memory::log2_buckets
template<class PoolType , class BucketDistribution , class BlockOrRawAllocator = DefaultAllocator>
using	CeresEngine::MemoryPoolCollection = foonathan::memory::memory_pool_collection< PoolType, BucketDistribution, BlockOrRawAllocator >
template<class PoolType = NodePool, class BlockOrRawAllocator = DefaultAllocator>
using	CeresEngine::BucketAllocator = foonathan::memory::bucket_allocator< PoolType, BlockOrRawAllocator >
template<class BlockOrRawAllocator = DefaultAllocator>
using	CeresEngine::MemoryStack = foonathan::memory::memory_stack< BlockOrRawAllocator >
template<class Stack = MemoryStack<>>
using	CeresEngine::MemoryStackScope = foonathan::memory::memory_stack_raii_unwind< Stack >
using	CeresEngine::NewAllocator = foonathan::memory::new_allocator
template<class RawAllocator >
using	CeresEngine::ThresholdSegregatable = foonathan::memory::threshold_segregatable< RawAllocator >
using	CeresEngine::NullAllocator = foonathan::memory::null_allocator
template<class Segregatable , class RawAllocator >
using	CeresEngine::BinarySegregator = foonathan::memory::binary_segregator< Segregatable, RawAllocator >
template<std::size_t Size>
using	CeresEngine::StaticAllocatorStorage = foonathan::memory::static_allocator_storage< Size >
using	CeresEngine::StaticAllocator = foonathan::memory::static_allocator
using	CeresEngine::StaticBlockAllocator = foonathan::memory::static_block_allocator
template<class Tracker , class RawAllocator >
using	CeresEngine::TrackedAllocator = foonathan::memory::tracked_allocator< Tracker, RawAllocator >
template<class Tracker , class BlockOrRawAllocator >
using	CeresEngine::TrackedBlockAllocator = foonathan::memory::tracked_block_allocator< Tracker, BlockOrRawAllocator >
template<class Tracker , class BlockOrRawAllocator >
using	CeresEngine::DeeplyTrackedBlockAllocator = foonathan::memory::deeply_tracked_block_allocator< Tracker, BlockOrRawAllocator >
using	CeresEngine::VirtualMemoryAllocator = foonathan::memory::virtual_memory_allocator
using	CeresEngine::VirtualBlockAllocator = foonathan::memory::virtual_block_allocator
template<typename T , class RawAllocator >
using	CeresEngine::JointPtr = foonathan::memory::joint_ptr< T, RawAllocator >
template<typename T >
using	CeresEngine::JointArray = foonathan::memory::joint_array< T >
template<typename T , class RawAllocator >
using	CeresEngine::JointAllocator = foonathan::memory::joint_allocator
template<typename T , class RawAllocator = DefaultAllocator>
using	CeresEngine::StdAllocator = foonathan::memory::std_allocator< T, RawAllocator >
template<typename T >
using	CeresEngine::AnyStdAllocator = foonathan::memory::any_std_allocator< T >
template<class RawAllocator >
using	CeresEngine::MemoryResourceAdapter = foonathan::memory::memory_resource_adapter< RawAllocator >
using	CeresEngine::MemoryResourceAllocator = foonathan::memory::memory_resource_allocator
template<typename Type , class RawAllocator >
using	CeresEngine::AllocatorDeallocator = foonathan::memory::allocator_deallocator< Type, RawAllocator >
template<typename BaseType , class RawAllocator >
using	CeresEngine::AllocatorPolymorphicDeallocator = foonathan::memory::allocator_polymorphic_deallocator< BaseType, RawAllocator >
template<typename Type , class RawAllocator >
using	CeresEngine::AllocatorDeleter = foonathan::memory::allocator_deleter< Type, RawAllocator >
template<typename BaseType , class RawAllocator >
using	CeresEngine::AllocatorPolymorphicDeleter = foonathan::memory::allocator_polymorphic_deleter< BaseType, RawAllocator >
using	CeresEngine::AllocatorInfo = foonathan::memory::allocator_info
using	CeresEngine::OutOfMemoryError = foonathan::memory::out_of_memory
using	CeresEngine::OutOfFixedMemoryError = foonathan::memory::out_of_fixed_memory
using	CeresEngine::BadAllocationSizeError = foonathan::memory::bad_allocation_size
using	CeresEngine::BadNodeSizeError = foonathan::memory::bad_node_size
using	CeresEngine::BadArraySizeError = foonathan::memory::bad_array_size
using	CeresEngine::BadAlignmentError = foonathan::memory::bad_alignment
template<typename OuterAlloc , typename... InnerAlloc>
using	CeresEngine::ScopedAllocatorAdaptor = std::scoped_allocator_adaptor< OuterAlloc, InnerAlloc... >
	The ScopedAllocatorAdaptor class template is an allocator which can be used with multilevel containers (vector of sets of lists of tuples of maps, etc).

Functions
DefaultAllocator &	CeresEngine::gDefaultAllocator ()
template<class T , std::size_t N, std::size_t A1, class U , std::size_t M, std::size_t A2>
bool	CeresEngine::operator== (const ShortAllocator< T, N, A1 > &x, const ShortAllocator< U, M, A2 > &y) noexcept
template<class T , std::size_t N, std::size_t A1, class U , std::size_t M, std::size_t A2>
bool	CeresEngine::operator!= (const ShortAllocator< T, N, A1 > &x, const ShortAllocator< U, M, A2 > &y) noexcept
void *	operator new (std::size_t count, std::align_val_t alignment)
void *	operator new (std::size_t count)
void *	operator new (std::size_t count, std::align_val_t alignment, const std::nothrow_t &) noexcept
void *	operator new (std::size_t count, const std::nothrow_t &) noexcept
void *	operator new[] (std::size_t count, std::align_val_t alignment)
void *	operator new[] (std::size_t count)
void *	operator new[] (std::size_t count, std::align_val_t alignment, const std::nothrow_t &) noexcept
void *	operator new[] (std::size_t count, const std::nothrow_t &) noexcept
void	operator delete (void *ptr, std::align_val_t alignment) noexcept
void	operator delete (void *ptr) noexcept
void	operator delete (void *ptr, std::align_val_t alignment, const std::nothrow_t &) noexcept
void	operator delete (void *ptr, const std::nothrow_t &) noexcept
void	operator delete (void *ptr, std::size_t sz, std::align_val_t alignment) noexcept
void	operator delete (void *ptr, std::size_t sz) noexcept
void	operator delete (void *ptr, std::size_t sz, std::align_val_t alignment, const std::nothrow_t &) noexcept
void	operator delete (void *ptr, std::size_t sz, const std::nothrow_t &) noexcept
void	operator delete[] (void *ptr, std::align_val_t alignment) noexcept
void	operator delete[] (void *ptr) noexcept
void	operator delete[] (void *ptr, const std::nothrow_t &tag) noexcept
void	operator delete[] (void *ptr, std::align_val_t alignment, const std::nothrow_t &) noexcept
void	operator delete[] (void *ptr, std::size_t sz, std::align_val_t alignment) noexcept
void	operator delete[] (void *ptr, std::size_t sz) noexcept
void	operator delete[] (void *ptr, std::size_t sz, const std::nothrow_t &tag) noexcept
void	operator delete[] (void *ptr, std::size_t sz, std::align_val_t alignment, const std::nothrow_t &) noexcept

Function Documentation

operator delete() [1/8]

void operator delete ( void *  ptr )

noexcept

operator delete() [2/8]

void operator delete ( void *  ptr, const std::nothrow_t &    )

noexcept

operator delete() [3/8]

void operator delete ( void *  ptr, std::align_val_t  alignment  )

noexcept

operator delete() [4/8]

void operator delete ( void *  ptr, std::align_val_t  alignment, const std::nothrow_t &    )

noexcept

operator delete() [5/8]

void operator delete ( void *  ptr, std::size_t  sz  )

noexcept

operator delete() [6/8]

void operator delete ( void *  ptr, std::size_t  sz, const std::nothrow_t &    )

noexcept

operator delete() [7/8]

void operator delete ( void *  ptr, std::size_t  sz, std::align_val_t  alignment  )

noexcept

operator delete() [8/8]

void operator delete ( void *  ptr, std::size_t  sz, std::align_val_t  alignment, const std::nothrow_t &    )

noexcept

operator delete[]() [1/8]

void operator delete[] ( void *  ptr )

noexcept

operator delete[]() [2/8]

void operator delete[] ( void *  ptr, const std::nothrow_t &  tag  )

noexcept

operator delete[]() [3/8]

void operator delete[] ( void *  ptr, std::align_val_t  alignment  )

noexcept

operator delete[]() [4/8]

void operator delete[] ( void *  ptr, std::align_val_t  alignment, const std::nothrow_t &    )

noexcept

operator delete[]() [5/8]

void operator delete[] ( void *  ptr, std::size_t  sz  )

noexcept

operator delete[]() [6/8]

void operator delete[] ( void *  ptr, std::size_t  sz, const std::nothrow_t &  tag  )

noexcept

operator delete[]() [7/8]

void operator delete[] ( void *  ptr, std::size_t  sz, std::align_val_t  alignment  )

noexcept

operator delete[]() [8/8]

void operator delete[] ( void *  ptr, std::size_t  sz, std::align_val_t  alignment, const std::nothrow_t &    )

noexcept

operator new() [1/4]

void * operator new

(

std::size_t

count

)

operator new() [2/4]

void * operator new ( std::size_t  count, const std::nothrow_t &    )

noexcept

operator new() [3/4]

void * operator new	(	std::size_t	count,
		std::align_val_t	alignment
	)

operator new() [4/4]

void * operator new ( std::size_t  count, std::align_val_t  alignment, const std::nothrow_t &    )

noexcept

operator new[]() [1/4]

void * operator new[]

(

std::size_t

count

)

operator new[]() [2/4]

void * operator new[] ( std::size_t  count, const std::nothrow_t &    )

noexcept

operator new[]() [3/4]

void * operator new[]	(	std::size_t	count,
		std::align_val_t	alignment
	)

operator new[]() [4/4]

void * operator new[] ( std::size_t  count, std::align_val_t  alignment, const std::nothrow_t &    )

noexcept