Irrlicht Engine: irrAllocator.h Source File

Home | Namespaces | Hierarchy | Alphabetical List | Class list | Files | Namespace Members | Class members | File members | Tutorials

# irrAllocator.h

Go to the documentation of this file.

    00001 // Copyright (C) 2002-2010 Nikolaus Gebhardt
    00002 // This file is part of the "Irrlicht Engine" and the "irrXML" project.
    00003 // For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
    00004
    00005 #ifndef __IRR_ALLOCATOR_H_INCLUDED__
    00006 #define __IRR_ALLOCATOR_H_INCLUDED__
    00007
    00008 #include "irrTypes.h"
    00009 #include <new>
    00010 // necessary for older compilers
    00011 #include <memory.h>
    00012
    00013 namespace irr
    00014 {
    00015 namespace core
    00016 {
    00017
    00018 #ifdef DEBUG_CLIENTBLOCK
    00019 #undef DEBUG_CLIENTBLOCK
    00020 #define DEBUG_CLIENTBLOCK new
    00021 #endif
    00022
    00024 template<typename T>
    00025 class irrAllocator
    00026 {
    00027 public:
    00028
    00030         virtual ~irrAllocator() {}
    00031
    00033         T* allocate(size_t cnt)
    00034         {
    00035                 return (T*)internal_new(cnt* sizeof(T));
    00036         }
    00037
    00039         void deallocate(T* ptr)
    00040         {
    00041                 internal_delete(ptr);
    00042         }
    00043
    00045         void construct(T* ptr, const T&e)
    00046         {
    00047                 new ((void*)ptr) T(e);
    00048         }
    00049
    00051         void destruct(T* ptr)
    00052         {
    00053                 ptr->~T();
    00054         }
    00055
    00056 protected:
    00057
    00058         virtual void* internal_new(size_t cnt)
    00059         {
    00060                 return operator new(cnt);
    00061         }
    00062
    00063         virtual void internal_delete(void* ptr)
    00064         {
    00065                 operator delete(ptr);
    00066         }
    00067
    00068 };
    00069
    00070
    00072
    00074 template<typename T>
    00075 class irrAllocatorFast
    00076 {
    00077 public:
    00078
    00080         T* allocate(size_t cnt)
    00081         {
    00082                 return (T*)operator new(cnt* sizeof(T));
    00083         }
    00084
    00086         void deallocate(T* ptr)
    00087         {
    00088                 operator delete(ptr);
    00089         }
    00090
    00092         void construct(T* ptr, const T&e)
    00093         {
    00094                 new ((void*)ptr) T(e);
    00095         }
    00096
    00098         void destruct(T* ptr)
    00099         {
    00100                 ptr->~T();
    00101         }
    00102 };
    00103
    00104
    00105
    00106 #ifdef DEBUG_CLIENTBLOCK
    00107 #undef DEBUG_CLIENTBLOCK
    00108 #define DEBUG_CLIENTBLOCK new( _CLIENT_BLOCK, __FILE__, __LINE__)
    00109 #endif
    00110
    00112 enum eAllocStrategy
    00113 {
    00114         ALLOC_STRATEGY_SAFE    = 0,
    00115         ALLOC_STRATEGY_DOUBLE  = 1,
    00116         ALLOC_STRATEGY_SQRT    = 2
    00117 };
    00118
    00119
    00120 } // end namespace core
    00121 } // end namespace irr
    00122
    00123 #endif
    00124

| The Irrlicht Engine Documentation © 2003-2010 by Nikolaus Gebhardt. Generated on Sun Oct 24 12:41:57 2010 by Doxygen (1.6.2)