1

/* $Id$ */

     2

     3

/** @file alloc_type.hpp Helper types related to the allocation of memory */

     4

     5

#ifndef ALLOC_TYPE_HPP

     6

#define ALLOC_TYPE_HPP

     7

     8

#include "alloc_func.hpp"

     9

    10

/**

    11

 * A small 'wrapper' for allocations that can be done on most OSes on the

    12

 * stack, but are just too large to fit in the stack on devices with a small

    13

 * stack such as the NDS.

    14

 * So when it is possible a stack allocation is made, otherwise a heap

    15

 * allocation is made and this is freed once the struct goes out of scope.

    16

 * @param T      the type to make the allocation for

    17

 * @param length the amount of items to allocate

    18

 */

    19

template <typename T, size_t length>

    20

struct SmallStackSafeStackAlloc {

    21

#if !defined(__NDS__)

    22

	/** Storing the data on the stack */

    23

	T data[length];

    24

#else

    25

	/** Storing it on the heap */

    26

	T *data;

    27

	/** The length (in elements) of data in this allocator. */

    28

	size_t len;

    29

    30

	/** Allocating the memory */

    31

	SmallStackSafeStackAlloc() : data(MallocT<T>(length)), len(length) {}

    32

    33

	/** And freeing when it goes out of scope */

    34

	~SmallStackSafeStackAlloc()

    35

	{

    36

		free(data);

    37

	}

    38

#endif

    39

    40

	/**

    41

	 * Gets a pointer to the data stored in this wrapper.

    42

	 * @return the pointer.

    43

	 */

    44

	FORCEINLINE operator T* ()

    45

	{

    46

		return data;

    47

	}

    48

    49

	/**

    50

	 * Gets a pointer to the data stored in this wrapper.

    51

	 * @return the pointer.

    52

	 */

    53

	FORCEINLINE T* operator -> ()

    54

	{

    55

		return data;

    56

	}

    57

    58

	/**

    59

	 * Gets a pointer to the last data element stored in this wrapper.

    60

	 * @note needed because endof does not work properly for pointers.

    61

	 * @return the 'endof' pointer.

    62

	 */

    63

	FORCEINLINE T* EndOf()

    64

	{

    65

#if !defined(__NDS__)

    66

		return endof(data);

    67

#else

    68

		return &data[len];

    69

#endif

    70

	}

    71

};

    72

    73

/**

    74

 * Base class that provides memory initialization on dynamically created objects.

    75

 * All allocated memory will be zeroed.

    76

 */

    77

class ZeroedMemoryAllocator

    78

{

    79

public:

    80

	ZeroedMemoryAllocator() {}

    81

	virtual ~ZeroedMemoryAllocator() {}

    82

    83

	/**

    84

	 * Memory allocator for a single class instance.

    85

	 * @param size the amount of bytes to allocate.

    86

	 * @return the given amounts of bytes zeroed.

    87

	 */

    88

	FORCEINLINE void *operator new(size_t size) { return CallocT<byte>(size); }

    89

    90

	/**

    91

	 * Memory allocator for an array of class instances.

    92

	 * @param size the amount of bytes to allocate.

    93

	 * @return the given amounts of bytes zeroed.

    94

	 */

    95

	FORCEINLINE void *operator new[](size_t size) { return CallocT<byte>(size); }

    96

    97

	/**

    98

	 * Memory release for a single class instance.

    99

	 * @param ptr  the memory to free.

   100

	 * @param size the amount of allocated memory (unused).

   101

	 *

   102

	 * @warning The value of the \a size parameter can only be trusted for

   103

	 *          classes that have their own (virtual) destructor method.

   104

	 */

   105

	FORCEINLINE void operator delete(void *ptr, size_t size) { free(ptr); }

   106

   107

	/**

   108

	 * Memory release for an array of class instances.

   109

	 * @param ptr  the memory to free.

   110

	 * @param size the amount of allocated memory (unused).

   111

	 *

   112

	 * @warning The value of the \a size parameter can only be trusted for

   113

	 *          classes that have their own (virtual) destructor method.

   114

	 */

   115

	FORCEINLINE void operator delete[](void *ptr, size_t size) { free(ptr); }

   116

};

   117

   118

#endif /* ALLOC_TYPE_HPP */