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

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

    33

	~SmallStackSafeStackAlloc() { free(data); }

    34

#endif

    35

    36

	/**

    37

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

    38

	 * @return the pointer.

    39

	 */

    40

	inline operator T* () { return data; }

    41

    42

	/**

    43

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

    44

	 * @return the pointer.

    45

	 */

    46

	inline T* operator -> () { return data; }

    47

    48

	/**

    49

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

    50

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

    51

	 * @return the 'endof' pointer.

    52

	 */

    53

	inline T* EndOf() {

    54

#if !defined(__NDS__)

    55

		return endof(data);

    56

#else

    57

		return &data[len];

    58

#endif

    59

	}

    60

};

    61

    62

/**

    63

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

    64

 * All allocated memory will be zeroed.

    65

 */

    66

class ZeroedMemoryAllocator

    67

{

    68

public:

    69

	ZeroedMemoryAllocator() {}

    70

	virtual ~ZeroedMemoryAllocator() {}

    71

    72

	/**

    73

	 * Memory allocator for a single class instance.

    74

	 * @param size the amount of bytes to allocate.

    75

	 * @return the given amounts of bytes zeroed.

    76

	 */

    77

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

    78

    79

	/**

    80

	 * Memory allocator for an array of class instances.

    81

	 * @param size the amount of bytes to allocate.

    82

	 * @return the given amounts of bytes zeroed.

    83

	 */

    84

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

    85

    86

	/**

    87

	 * Memory release for a single class instance.

    88

	 * @param ptr  the memory to free.

    89

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

    90

	 *

    91

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

    92

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

    93

	 */

    94

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

    95

    96

	/**

    97

	 * Memory release for an array of class instances.

    98

	 * @param ptr  the memory to free.

    99

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

   100

	 *

   101

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

   102

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

   103

	 */

   104

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

   105

};

   106

   107

#endif /* ALLOC_TYPE_HPP */