Line data    Source code

       1             : // Copyright (C) 2002-2012 Nikolaus Gebhardt
       2             : // This file is part of the "Irrlicht Engine" and the "irrXML" project.
       3             : // For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
       4             : 
       5             : #ifndef __IRR_ALLOCATOR_H_INCLUDED__
       6             : #define __IRR_ALLOCATOR_H_INCLUDED__
       7             : 
       8             : #include "irrTypes.h"
       9             : #include <new>
      10             : // necessary for older compilers
      11             : #include <memory.h>
      12             : 
      13             : namespace irr
      14             : {
      15             : namespace core
      16             : {
      17             : 
      18             : #ifdef DEBUG_CLIENTBLOCK
      19             : #undef DEBUG_CLIENTBLOCK
      20             : #define DEBUG_CLIENTBLOCK new
      21             : #endif
      22             : 
      23             : //! Very simple allocator implementation, containers using it can be used across dll boundaries
      24             : template<typename T>
      25     6937489 : class irrAllocator
      26             : {
      27             : public:
      28             : 
      29             :         //! Destructor
      30     6946657 :         virtual ~irrAllocator() {}
      31             : 
      32             :         //! Allocate memory for an array of objects
      33     1227482 :         T* allocate(size_t cnt)
      34             :         {
      35     1227482 :                 return (T*)internal_new(cnt* sizeof(T));
      36             :         }
      37             : 
      38             :         //! Deallocate memory for an array of objects
      39     8172377 :         void deallocate(T* ptr)
      40             :         {
      41     8172377 :                 internal_delete(ptr);
      42     8172360 :         }
      43             : 
      44             :         //! Construct an element
      45    58738490 :         void construct(T* ptr, const T&e)
      46             :         {
      47    58738490 :                 new ((void*)ptr) T(e);
      48    58738482 :         }
      49             : 
      50             :         //! Destruct an element
      51    64504747 :         void destruct(T* ptr)
      52             :         {
      53          58 :                 ptr->~T();
      54    64504747 :         }
      55             : 
      56             : protected:
      57             : 
      58     2802222 :         virtual void* internal_new(size_t cnt)
      59             :         {
      60     2802222 :                 return operator new(cnt);
      61             :         }
      62             : 
      63    10003375 :         virtual void internal_delete(void* ptr)
      64             :         {
      65    10003375 :                 operator delete(ptr);
      66    10003384 :         }
      67             : 
      68             : };
      69             : 
      70             : 
      71             : //! Fast allocator, only to be used in containers inside the same memory heap.
      72             : /** Containers using it are NOT able to be used it across dll boundaries. Use this
      73             : when using in an internal class or function or when compiled into a static lib */
      74             : template<typename T>
      75             : class irrAllocatorFast
      76             : {
      77             : public:
      78             : 
      79             :         //! Allocate memory for an array of objects
      80             :         T* allocate(size_t cnt)
      81             :         {
      82             :                 return (T*)operator new(cnt* sizeof(T));
      83             :         }
      84             : 
      85             :         //! Deallocate memory for an array of objects
      86             :         void deallocate(T* ptr)
      87             :         {
      88             :                 operator delete(ptr);
      89             :         }
      90             : 
      91             :         //! Construct an element
      92             :         void construct(T* ptr, const T&e)
      93             :         {
      94             :                 new ((void*)ptr) T(e);
      95             :         }
      96             : 
      97             :         //! Destruct an element
      98             :         void destruct(T* ptr)
      99             :         {
     100             :                 ptr->~T();
     101             :         }
     102             : };
     103             : 
     104             : 
     105             : 
     106             : #ifdef DEBUG_CLIENTBLOCK
     107             : #undef DEBUG_CLIENTBLOCK
     108             : #define DEBUG_CLIENTBLOCK new( _CLIENT_BLOCK, __FILE__, __LINE__)
     109             : #endif
     110             : 
     111             : //! defines an allocation strategy
     112             : enum eAllocStrategy
     113             : {
     114             :         ALLOC_STRATEGY_SAFE    = 0,
     115             :         ALLOC_STRATEGY_DOUBLE  = 1,
     116             :         ALLOC_STRATEGY_SQRT    = 2
     117             : };
     118             : 
     119             : 
     120             : } // end namespace core
     121             : } // end namespace irr
     122             : 
     123             : #endif
     124             :