1

/* $Id$ */

     2

     3

/** @file smallvec_type.hpp Simple vector class that allows allocating an item without the need to copy this->data needlessly. */

     4

     5

#ifndef SMALLVEC_TYPE_HPP

     6

#define SMALLVEC_TYPE_HPP

     7

     8

#include "alloc_func.hpp"

     9

#include "math_func.hpp"

    10

    11

/**

    12

 * Simple vector template class.

    13

 *

    14

 * @note There are no asserts in the class so you have

    15

 *       to care about that you grab an item which is

    16

 *       inside the list.

    17

 *

    18

 * @param T The type of the items stored

    19

 * @param S The steps of allocation

    20

 */

    21

template <typename T, uint S>

    22

class SmallVector {

    23

protected:

    24

	T *data;       ///< The pointer to the first item

    25

	uint items;    ///< The number of items stored

    26

	uint capacity; ///< The avalible space for storing items

    27

    28

public:

    29

	SmallVector() : data(NULL), items(0), capacity(0) { }

    30

    31

	~SmallVector()

    32

	{

    33

		free(this->data);

    34

	}

    35

    36

	/**

    37

	 * Remove all items from the list.

    38

	 */

    39

	FORCEINLINE void Clear()

    40

	{

    41

		/* In fact we just reset the item counter avoiding the need to

    42

		 * probably reallocate the same amount of memory the list was

    43

		 * previously using. */

    44

		this->items = 0;

    45

	}

    46

    47

	/**

    59

	 * Compact the list down to the smallest block size boundary.

    60

	 */

    61

	FORCEINLINE void Compact()

    62

	{

    63

		uint capacity = Align(this->items, S);

    64

		if (capacity >= this->capacity) return;

    65

    66

		this->capacity = capacity;

    67

		this->data = ReallocT(this->data, this->capacity);

    68

	}

    69

    70

	/**

    71

	 * Append an item and return it.

    72

	 */

    73

	FORCEINLINE T *Append()

    74

	{

    75

		if (this->items == this->capacity) {

    76

			this->capacity += S;

    77

			this->data = ReallocT(this->data, this->capacity);

    78

		}

    79

    80

		return &this->data[this->items++];

    81

	}

    82

    83

	/**

    84

	 * Get the number of items in the list.

    85

	 */

    86

	FORCEINLINE uint Length() const

    87

	{

    88

		return this->items;

    89

	}

    90

    91

	/**

    92

	 * Get the pointer to the first item (const)

    93

	 *

    94

	 * @return the pointer to the first item

    95

	 */

    96

	FORCEINLINE const T *Begin() const

    97

	{

    98

		return this->data;

    99

	}

   100

   101

	/**

   102

	 * Get the pointer to the first item

   103

	 *

   104

	 * @return the pointer to the first item

   105

	 */

   106

	FORCEINLINE T *Begin()

   107

	{

   108

		return this->data;

   109

	}

   110

   111

	/**

   112

	 * Get the pointer behind the last valid item (const)

   113

	 *

   114

	 * @return the pointer behind the last valid item

   115

	 */

   116

	FORCEINLINE const T *End() const

   117

	{

   118

		return &this->data[this->items];

   119

	}

   120

   121

	/**

   122

	 * Get the pointer behind the last valid item

   123

	 *

   124

	 * @return the pointer behind the last valid item

   125

	 */

   126

	FORCEINLINE T *End()

   127

	{

   128

		return &this->data[this->items];

   129

	}

   130

   131

	/**

   132

	 * Get the pointer to item "number" (const)

   133

	 *

   134

	 * @param index the position of the item

   135

	 * @return the pointer to the item

   136

	 */

   137

	FORCEINLINE const T *Get(uint index) const

   138

	{

   139

		return &this->data[index];

   140

	}

   141

   142

	/**

   143

	 * Get the pointer to item "number"

   144

	 *

   145

	 * @param index the position of the item

   146

	 * @return the pointer to the item

   147

	 */

   148

	FORCEINLINE T *Get(uint index)

   149

	{

   150

		return &this->data[index];

   151

	}

   152

   153

	/**

   154

	 * Get item "number" (const)

   155

	 *

   156

	 * @param index the positon of the item

   157

	 * @return the item

   158

	 */

   159

	FORCEINLINE const T &operator[](uint index) const

   160

	{

   161

		return this->data[index];

   162

	}

   163

   164

	/**

   165

	 * Get item "number"

   166

	 *

   167

	 * @param index the positon of the item

   168

	 * @return the item

   169

	 */

   170

	FORCEINLINE T &operator[](uint index)

   171

	{

   172

		return this->data[index];

   173

	}

   174

};

   175

   176

   177

/**

   178

 * Simple vector template class, with automatic free.

   179

 *

   180

 * @note There are no asserts in the class so you have

   181

 *       to care about that you grab an item which is

   182

 *       inside the list.

   183

 *

   184

 * @param T The type of the items stored, must be a pointer

   185

 * @param S The steps of allocation

   186

 */

   187

template <typename T, uint S>

   188

class AutoFreeSmallVector : public SmallVector<T, S> {

   189

public:

   190

	~AutoFreeSmallVector()

   191

	{

   192

		this->Clear();

   193

	}

   194

   195

	/**

   196

	 * Remove all items from the list.

   197

	 */

   198

	FORCEINLINE void Clear()

   199

	{

   200

		for (uint i = 0; i < this->items; i++) {

   201

			free(this->data[i]);

   202

		}

   203

   204

		this->items = 0;

   205

	}

   206

};

   207

   208

#endif /* SMALLVEC_TYPE_HPP */