1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
////////////////////////////////////////////////////////////////////////////////
// The Loki Library
// Copyright (c) 2008 by Rich Sposato
//
// Permission to use, copy, modify, distribute and sell this software for any
// purpose is hereby granted without fee, provided that the above copyright
// notice appear in all copies and that both that copyright notice and this
// permission notice appear in supporting documentation.
// The author makes no representations about the
// suitability of this software for any purpose. It is provided "as is"
// without express or implied warranty.
////////////////////////////////////////////////////////////////////////////////
#ifndef LOKI_ALLOCATOR_HPP_INCLUDED
#define LOKI_ALLOCATOR_HPP_INCLUDED
// $Id: Allocator.h 896 2008-08-08 22:20:05Z syntheticpp $
// Requires project to be compiled with loki/src/SmallObj.cpp and loki/src/Singleton.cpp
#include <loki/SmallObj.h>
namespace Loki
{
//-----------------------------------------------------------------------------
/** @class LokiAllocator
Adapts Loki's Small-Object Allocator for STL container classes.
This class provides all the functionality required for STL allocators, but
uses Loki's Small-Object Allocator to perform actual memory operations.
Implementation comes from a post in Loki forums (by Rasmus Ekman?).
*/
template
<
typename Type,
typename AllocT = Loki::AllocatorSingleton<>
>
class LokiAllocator
{
public:
typedef ::std::size_t size_type;
typedef ::std::ptrdiff_t difference_type;
typedef Type* pointer;
typedef const Type* const_pointer;
typedef Type& reference;
typedef const Type& const_reference;
typedef Type value_type;
/// Default constructor does nothing.
inline LokiAllocator( void ) throw() { }
/// Copy constructor does nothing.
inline LokiAllocator( const LokiAllocator& ) throw() { }
/// Type converting allocator constructor does nothing.
template < typename Type1 >
inline LokiAllocator( const LokiAllocator< Type1 > & ) throw() { }
/// Destructor does nothing.
inline ~LokiAllocator() throw() { }
/// Convert an allocator<Type> to an allocator <Type1>.
template < typename Type1 >
struct rebind
{
typedef LokiAllocator< Type1 > other;
};
/// Return address of reference to mutable element.
pointer address( reference elem ) const { return &elem; }
/// Return address of reference to const element.
const_pointer address( const_reference elem ) const { return &elem; }
/** Allocate an array of count elements. Warning! The true parameter in
the call to Allocate means this function can throw exceptions. This is
better than not throwing, and returning a null pointer in case the caller
assumes the return value is not null.
@param count # of elements in array.
@param hint Place where caller thinks allocation should occur.
@return Pointer to block of memory.
*/
pointer allocate( size_type count, const void* hint = 0 )
{
(void)hint; // Ignore the hint.
void* p = AllocT::Instance().Allocate( count * sizeof( Type ), true );
return reinterpret_cast< pointer >( p );
}
/// Ask allocator to release memory at pointer with size bytes.
void deallocate( pointer p, size_type size )
{
AllocT::Instance().Deallocate( p, size * sizeof( Type ) );
}
/// Calculate max # of elements allocator can handle.
size_type max_size( void ) const throw()
{
// A good optimizer will see these calculations always produce the same
// value and optimize this function away completely.
const size_type max_bytes = size_type( -1 );
const size_type bytes = max_bytes / sizeof( Type );
return bytes;
}
/// Construct an element at the pointer.
void construct( pointer p, const Type& value )
{
// A call to global placement new forces a call to copy constructor.
::new( p ) Type( value );
}
/// Destruct the object at pointer.
void destroy( pointer p )
{
// If the Type has no destructor, then some compilers complain about
// an unreferenced parameter, so use the void cast trick to prevent
// spurious warnings.
(void)p;
p->~Type();
}
};
//-----------------------------------------------------------------------------
/** All equality operators return true since LokiAllocator is basically a
monostate design pattern, so all instances of it are identical.
*/
template < typename Type >
inline bool operator == ( const LokiAllocator< Type > &, const LokiAllocator< Type > & )
{
return true;
}
/** All inequality operators return false since LokiAllocator is basically a
monostate design pattern, so all instances of it are identical.
*/
template < typename Type >
inline bool operator != ( const LokiAllocator< Type > & , const LokiAllocator< Type > & )
{
return false;
}
//-----------------------------------------------------------------------------
} // namespace Loki
#endif // LOKI_ALLOCATOR_INCLUDED
|
