← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to include/irrAllocator.h

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/irrAllocator.h
 
1
// Copyright (C) 2002-2011 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
class irrAllocator
 
26
{
 
27
public:
 
28
 
 
29
        //! Destructor
 
30
        virtual ~irrAllocator() {}
 
31
 
 
32
        //! Allocate memory for an array of objects
 
33
        T* allocate(size_t cnt)
 
34
        {
 
35
                return (T*)internal_new(cnt* sizeof(T));
 
36
        }
 
37
 
 
38
        //! Deallocate memory for an array of objects
 
39
        void deallocate(T* ptr)
 
40
        {
 
41
                internal_delete(ptr);
 
42
        }
 
43
 
 
44
        //! Construct an element
 
45
        void construct(T* ptr, const T&e)
 
46
        {
 
47
                new ((void*)ptr) T(e);
 
48
        }
 
49
 
 
50
        //! Destruct an element
 
51
        void destruct(T* ptr)
 
52
        {
 
53
                ptr->~T();
 
54
        }
 
55
 
 
56
protected:
 
57
 
 
58
        virtual void* internal_new(size_t cnt)
 
59
        {
 
60
                return operator new(cnt);
 
61
        }
 
62
 
 
63
        virtual void internal_delete(void* ptr)
 
64
        {
 
65
                operator delete(ptr);
 
66
        }
 
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