libs/memory/allocator.h

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #if !defined( INCLUDED_MEMORY_ALLOCATOR_H )
  23 #define INCLUDED_MEMORY_ALLOCATOR_H
  24
  25 #include <memory>
  26 #include <stddef.h>
  27
  28 #if 0
  29
  30 #define DefaultAllocator std::allocator
  31
  32 #else
  33
  34 /// \brief An allocator that uses c++ new/delete.
  35 /// Compliant with the std::allocator interface.
  36 template<typename Type>
  37 class DefaultAllocator
  38 {
  39 public:
  40
  41 typedef Type value_type;
  42 typedef value_type* pointer;
  43 typedef const Type* const_pointer;
  44 typedef Type& reference;
  45 typedef const Type& const_reference;
  46 typedef size_t size_type;
  47 typedef ptrdiff_t difference_type;
  48
  49 template<typename Other>
  50 struct rebind
  51 {
  52         typedef DefaultAllocator<Other> other;
  53 };
  54
  55 DefaultAllocator(){
  56 }
  57 DefaultAllocator( const DefaultAllocator<Type>& ){
  58 }
  59 template<typename Other> DefaultAllocator( const DefaultAllocator<Other>& ){
  60 }
  61 ~DefaultAllocator(){
  62 }
  63
  64 pointer address( reference instance ) const {
  65         return &instance;
  66 }
  67 const_pointer address( const_reference instance ) const {
  68         return &instance;
  69 }
  70 Type* allocate( size_type size, const void* = 0 ){
  71         return static_cast<Type*>( ::operator new( size * sizeof( Type ) ) );
  72 }
  73 void deallocate( pointer p, size_type ){
  74         ::operator delete( p );
  75 }
  76 size_type max_size() const {
  77         return std::size_t( -1 ) / sizeof( Type );
  78 }
  79 void construct( pointer p, const Type& value ){
  80         new(p) Type( value );
  81 }
  82 void destroy( pointer p ){
  83         p->~Type();
  84 }
  85 };
  86
  87 template<typename Type, typename Other>
  88 inline bool operator==( const DefaultAllocator<Type>&, const DefaultAllocator<Other>& ){
  89         return true;
  90 }
  91 template<typename Type, typename OtherAllocator>
  92 inline bool operator==( const DefaultAllocator<Type>&, const OtherAllocator& ){
  93         return false;
  94 }
  95
  96 #endif
  97
  98
  99 template<typename Type>
 100 class NamedAllocator : public DefaultAllocator<Type>
 101 {
 102 typedef DefaultAllocator<Type> allocator_type;
 103
 104 const char* m_name;
 105 public:
 106
 107 typedef Type value_type;
 108 typedef value_type* pointer;
 109 typedef const Type* const_pointer;
 110 typedef Type& reference;
 111 typedef const Type& const_reference;
 112 typedef size_t size_type;
 113 typedef ptrdiff_t difference_type;
 114
 115 template<typename Other>
 116 struct rebind
 117 {
 118         typedef NamedAllocator<Other> other;
 119 };
 120
 121 explicit NamedAllocator( const char* name ) : m_name( name ){
 122 }
 123 NamedAllocator( const NamedAllocator<Type>& other ) : m_name( other.m_name ){
 124 }
 125 template<typename Other> NamedAllocator( const NamedAllocator<Other>& other ) : m_name( other.m_name ){
 126 }
 127 ~NamedAllocator(){
 128 }
 129
 130 pointer address( reference instance ) const {
 131         return allocator_type::address( instance );
 132 }
 133 const_pointer address( const_reference instance ) const {
 134         return allocator_type::address( instance );
 135 }
 136 Type* allocate( size_type size, const void* = 0 ){
 137         return allocator_type::allocate( size );
 138 }
 139 void deallocate( pointer p, size_type size ){
 140         allocator_type::deallocate( p, size );
 141 }
 142 size_type max_size() const {
 143         return allocator_type::max_size();
 144 }
 145 void construct( pointer p, const Type& value ){
 146         allocator_type::construct( p, value );
 147 }
 148 void destroy( pointer p ){
 149         allocator_type::destroy( p );
 150 }
 151
 152 template<typename Other>
 153 bool operator==( const NamedAllocator<Other>& other ){
 154         return true;
 155 }
 156
 157 // returns true if the allocators are not interchangeable
 158 template<typename Other>
 159 bool operator!=( const NamedAllocator<Other>& other ){
 160         return false;
 161 }
 162 };
 163
 164
 165
 166 #include <algorithm>
 167 #include "generic/object.h"
 168
 169
 170
 171 template<typename Type>
 172 class DefaultConstruct
 173 {
 174 public:
 175 void operator()( Type& t ){
 176         constructor( t );
 177 }
 178 };
 179
 180 template<typename Type, typename T1>
 181 class Construct
 182 {
 183 const T1& other;
 184 public:
 185 Construct( const T1& other_ ) : other( other_ ){
 186 }
 187 void operator()( Type& t ){
 188         constructor( t, other );
 189 }
 190 };
 191
 192 template<typename Type>
 193 class Destroy
 194 {
 195 public:
 196 void operator()( Type& t ){
 197         destructor( t );
 198 }
 199 };
 200
 201 template<typename Type, typename Allocator = DefaultAllocator<Type> >
 202 class New : public Allocator
 203 {
 204 public:
 205 New(){
 206 }
 207 explicit New( const Allocator& allocator ) : Allocator( allocator ){
 208 }
 209
 210 Type* scalar(){
 211         return new( Allocator::allocate( 1 ) )Type();
 212 }
 213 template<typename T1>
 214 Type* scalar( const T1& t1 ){
 215         return new( Allocator::allocate( 1 ) )Type( t1 );
 216 }
 217 template<typename T1, typename T2>
 218 Type* scalar( const T1& t1, const T2& t2 ){
 219         return new( Allocator::allocate( 1 ) )Type( t1, t2 );
 220 }
 221 template<typename T1, typename T2, typename T3>
 222 Type* scalar( const T1& t1, const T2& t2, const T3& t3 ){
 223         return new( Allocator::allocate( 1 ) )Type( t1, t2, t3 );
 224 }
 225 template<typename T1, typename T2, typename T3, typename T4>
 226 Type* scalar( const T1& t1, const T2& t2, const T3& t3, const T4& t4 ){
 227         return new( Allocator::allocate( 1 ) )Type( t1, t2, t3, t4 );
 228 }
 229 template<typename T1, typename T2, typename T3, typename T4, typename T5>
 230 Type* scalar( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5 ){
 231         return new( Allocator::allocate( 1 ) )Type( t1, t2, t3, t4, t5 );
 232 }
 233 Type* vector( std::size_t size ){
 234 #if 1
 235         Type* p = Allocator::allocate( size );
 236         std::for_each( p, p + size, DefaultConstruct<Type>() );
 237         return p;
 238 #else
 239         // this does not work with msvc71 runtime
 240         return new( Allocator::allocate( size ) )Type[size];
 241 #endif
 242 }
 243 template<typename T1>
 244 Type* vector( std::size_t size, const T1& t1 ){
 245         Type* p = Allocator::allocate( size );
 246         std::for_each( p, p + size, Construct<Type, T1>( t1 ) );
 247         return p;
 248 }
 249 };
 250
 251 template<typename Type, typename Allocator = DefaultAllocator<Type> >
 252 class Delete : public Allocator
 253 {
 254 public:
 255 Delete(){
 256 }
 257 explicit Delete( const Allocator& allocator ) : Allocator( allocator ){
 258 }
 259
 260 void scalar( Type* p ){
 261         if ( p != 0 ) {
 262                 p->~Type();
 263                 Allocator::deallocate( p, 1 );
 264         }
 265 }
 266 void vector( Type* p, std::size_t size ){
 267         // '::operator delete' handles null
 268         // 'std::allocator::deallocate' requires non-null
 269         if ( p != 0 ) {
 270                 std::for_each( p, p + size, Destroy<Type>() );
 271                 Allocator::deallocate( p, size );
 272         }
 273 }
 274 };
 275
 276
 277 template<typename Type>
 278 class NamedNew
 279 {
 280 public:
 281 typedef New<Type, NamedAllocator<Type> > type;
 282 };
 283
 284 template<typename Type>
 285 class NamedDelete
 286 {
 287 public:
 288 typedef Delete<Type, NamedAllocator<Type> > type;
 289 };
 290
 291 #endif