Files
@ r9951:8026cba2423a
Branch filter:
Location: cpp/openttd-patchpack/source/src/core/smallvec_type.hpp
r9951:8026cba2423a
3.7 KiB
text/x-c++hdr
(svn r14106) -Fix(r14104): A string too much been commited
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | /* $Id$ */
/** @file smallvec_type.hpp Simple vector class that allows allocating an item without the need to copy this->data needlessly. */
#ifndef SMALLVEC_TYPE_HPP
#define SMALLVEC_TYPE_HPP
#include "alloc_func.hpp"
#include "math_func.hpp"
/**
* Simple vector template class.
*
* @note There are no asserts in the class so you have
* to care about that you grab an item which is
* inside the list.
*
* @param T The type of the items stored
* @param S The steps of allocation
*/
template <typename T, uint S>
class SmallVector {
protected:
T *data; ///< The pointer to the first item
uint items; ///< The number of items stored
uint capacity; ///< The avalible space for storing items
public:
SmallVector() : data(NULL), items(0), capacity(0) { }
~SmallVector()
{
free(this->data);
}
/**
* Remove all items from the list.
*/
FORCEINLINE void Clear()
{
/* In fact we just reset the item counter avoiding the need to
* probably reallocate the same amount of memory the list was
* previously using. */
this->items = 0;
}
/**
* Compact the list down to the smallest block size boundary.
*/
FORCEINLINE void Compact()
{
uint capacity = Align(this->items, S);
if (capacity >= this->capacity) return;
this->capacity = capacity;
this->data = ReallocT(this->data, this->capacity);
}
/**
* Append an item and return it.
*/
FORCEINLINE T *Append()
{
if (this->items == this->capacity) {
this->capacity += S;
this->data = ReallocT(this->data, this->capacity);
}
return &this->data[this->items++];
}
/**
* Get the number of items in the list.
*/
FORCEINLINE uint Length() const
{
return this->items;
}
/**
* Get the pointer to the first item (const)
*
* @return the pointer to the first item
*/
FORCEINLINE const T *Begin() const
{
return this->data;
}
/**
* Get the pointer to the first item
*
* @return the pointer to the first item
*/
FORCEINLINE T *Begin()
{
return this->data;
}
/**
* Get the pointer behind the last valid item (const)
*
* @return the pointer behind the last valid item
*/
FORCEINLINE const T *End() const
{
return &this->data[this->items];
}
/**
* Get the pointer behind the last valid item
*
* @return the pointer behind the last valid item
*/
FORCEINLINE T *End()
{
return &this->data[this->items];
}
/**
* Get the pointer to item "number" (const)
*
* @param index the position of the item
* @return the pointer to the item
*/
FORCEINLINE const T *Get(uint index) const
{
return &this->data[index];
}
/**
* Get the pointer to item "number"
*
* @param index the position of the item
* @return the pointer to the item
*/
FORCEINLINE T *Get(uint index)
{
return &this->data[index];
}
/**
* Get item "number" (const)
*
* @param index the positon of the item
* @return the item
*/
FORCEINLINE const T &operator[](uint index) const
{
return this->data[index];
}
/**
* Get item "number"
*
* @param index the positon of the item
* @return the item
*/
FORCEINLINE T &operator[](uint index)
{
return this->data[index];
}
};
/**
* Simple vector template class, with automatic free.
*
* @note There are no asserts in the class so you have
* to care about that you grab an item which is
* inside the list.
*
* @param T The type of the items stored, must be a pointer
* @param S The steps of allocation
*/
template <typename T, uint S>
class AutoFreeSmallVector : public SmallVector<T, S> {
public:
~AutoFreeSmallVector()
{
this->Clear();
}
/**
* Remove all items from the list.
*/
FORCEINLINE void Clear()
{
for (uint i = 0; i < this->items; i++) {
free(this->data[i]);
}
this->items = 0;
}
};
#endif /* SMALLVEC_TYPE_HPP */
|