1

/* $Id$ */

     2

     3

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

     4

     5

#ifndef SMALLVEC_H

     6

#define SMALLVEC_H

     7

     8

#include "../core/alloc_func.hpp"

     9

#include "../core/math_func.hpp"

    10

    11

template <typename T, uint S>

    12

struct SmallVector {

    13

	T *data;

    14

	uint items;

    15

	uint capacity;

    16

    17

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

    18

    19

	~SmallVector()

    20

	{

    21

		free(this->data);

    22

	}

    23

    24

	/**

    25

	 * Remove all items from the list.

    26

	 */

    27

	void Clear()

    28

	{

    29

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

    30

		 * probably reallocate the same amount of memory the list was

    31

		 * previously using. */

    32

		this->items = 0;

    33

	}

    34

    35

	/**

    36

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

    37

	 */

    38

	void Compact()

    39

	{

    40

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

    41

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

    42

    43

		this->capacity = capacity;

    44

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

    45

	}

    46

    47

	/**

    48

	 * Append an item and return it.

    49

	 */

    50

	T *Append()

    51

	{

    52

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

    53

			this->capacity += S;

    54

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

    55

		}

    56

    57

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

    58

	}

    59

    60

	/**

    61

	 * Get the number of items in the list.

    62

	 */

    63

	uint Length() const

    64

	{

    65

		return this->items;

    66

	}

    67

    68

	const T *Begin() const

    69

	{

    70

		return this->data;

    71

	}

    72

    73

	T *Begin()

    74

	{

    75

		return this->data;

    76

	}

    77

    78

	const T *End() const

    79

	{

    80

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

    81

	}

    82

    83

	T *End()

    84

	{

    85

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

    86

	}

    87

    88

	const T *Get(uint index) const

    89

	{

    90

		return &this->data[index];

    91

	}

    92

    93

	T *Get(uint index)

    94

	{

    95

		return &this->data[index];

    96

	}

    97

    98

	const T &operator[](uint index) const

    99

	{

   100

		return this->data[index];

   101

	}

   102

   103

	T &operator[](uint index)

   104

	{

   105

		return this->data[index];

   106

	}

   107

};

   108

   109

#endif /* SMALLVEC_H */