1 | /* |
---|
2 | orxonox - the future of 3D-vertical-scrollers |
---|
3 | |
---|
4 | Copyright (C) 2004 orx |
---|
5 | |
---|
6 | This program is free software; you can redistribute it and/or modify |
---|
7 | it under the terms of the GNU General Public License as published by |
---|
8 | the Free Software Foundation; either version 2, or (at your option) |
---|
9 | any later version. |
---|
10 | |
---|
11 | ### File Specific: |
---|
12 | main-programmer: Benjamin Grauer |
---|
13 | co-programmer: ... |
---|
14 | */ |
---|
15 | |
---|
16 | /*! |
---|
17 | @file array.h |
---|
18 | @brief Contains the Array Class that handles arrays of classes. |
---|
19 | this class creates a Array of a semi-Dynamic length. |
---|
20 | beware, that after finalizing the array may not be resized again. |
---|
21 | */ |
---|
22 | |
---|
23 | #ifndef _ARRAY_H |
---|
24 | #define _ARRAY_H |
---|
25 | #include "debug.h" |
---|
26 | |
---|
27 | //! Array Class that handles dynamic-type arrays. |
---|
28 | template<class T> class Array |
---|
29 | { |
---|
30 | public: |
---|
31 | Array (); |
---|
32 | ~Array(); |
---|
33 | |
---|
34 | void finalizeArray (); |
---|
35 | void addEntry (T entry); |
---|
36 | void addEntry(T entry0, T entry1, T entry2); |
---|
37 | |
---|
38 | /** @returns The array */ |
---|
39 | inline T* getArray () const { return this->array; }; |
---|
40 | inline const T getEntry(unsigned int number) const; |
---|
41 | /** * @returns The Count of entries in the Array*/ |
---|
42 | inline unsigned int getCount()const { return this->entryCount; }; |
---|
43 | inline int getIndex(T* entry) const; |
---|
44 | inline bool isFinalized() const { return this->finalized; } |
---|
45 | void debug() const ; |
---|
46 | |
---|
47 | private: |
---|
48 | //! One entry of the Array |
---|
49 | struct Entry |
---|
50 | { |
---|
51 | T value; //!< The value of this Entry. |
---|
52 | Entry* next; //!< Pointer to the Next entry. |
---|
53 | }; |
---|
54 | |
---|
55 | T* array; //!< The array that will be produced when finalizing the Array. |
---|
56 | unsigned int entryCount; //!< The count of Entries in this Array. |
---|
57 | bool finalized; //!< If this variable is set to true, the Array can not be changed anymore. true if finalized, false else (initially). |
---|
58 | Entry* firstEntry; //!< Pointer to the first Entry of this Array |
---|
59 | Entry* currentEntry; //!< Pointer to the current Entry of this Array. The one Entry we are working with. |
---|
60 | }; |
---|
61 | |
---|
62 | |
---|
63 | /** |
---|
64 | * creates a new Array |
---|
65 | */ |
---|
66 | template<class T> |
---|
67 | Array<T>::Array () |
---|
68 | { |
---|
69 | PRINTF(5)("crating new Array\n"); |
---|
70 | this->firstEntry = new Entry; |
---|
71 | this->firstEntry->next =NULL; |
---|
72 | this->currentEntry = this->firstEntry; |
---|
73 | this->finalized = false; |
---|
74 | this->entryCount = 0; //0 means one entry |
---|
75 | } |
---|
76 | |
---|
77 | template<class T> |
---|
78 | const T Array<T>::getEntry(unsigned int number) const |
---|
79 | { |
---|
80 | if (this->finalized && number < this->entryCount) |
---|
81 | return this->array[number]; |
---|
82 | } |
---|
83 | |
---|
84 | /** |
---|
85 | * deletes an Array. |
---|
86 | It does this by first deleting all the array-entries, and then delete the array[] itself |
---|
87 | */ |
---|
88 | template<class T> |
---|
89 | Array<T>::~Array() |
---|
90 | { |
---|
91 | PRINTF(5)("deleting array\n"); |
---|
92 | if (!this->finalized) |
---|
93 | { |
---|
94 | Entry* walker = this->firstEntry; |
---|
95 | Entry* previous; |
---|
96 | while (walker) |
---|
97 | { |
---|
98 | previous = walker; |
---|
99 | walker = walker->next; |
---|
100 | delete previous; |
---|
101 | } |
---|
102 | } |
---|
103 | if (this->finalized) |
---|
104 | delete[] this->array; |
---|
105 | } |
---|
106 | |
---|
107 | /** |
---|
108 | * finalizes an array. |
---|
109 | This Function creates the array, and makes it ready to be sent to the application. |
---|
110 | */ |
---|
111 | template<class T> |
---|
112 | void Array<T>::finalizeArray () |
---|
113 | { |
---|
114 | if (this->finalized) |
---|
115 | return; |
---|
116 | PRINTF(5)("Finalizing array. Length: %i\n", entryCount); |
---|
117 | if (!(this->array = new T [this->entryCount])) |
---|
118 | PRINTF(1)("could not allocate %i data Blocks\n", this->entryCount); |
---|
119 | Entry* walker = this->firstEntry; |
---|
120 | for (int i=0; i < this->entryCount; i++) |
---|
121 | { |
---|
122 | this->array[i] = walker->value; |
---|
123 | walker = walker->next; |
---|
124 | } |
---|
125 | walker = this->firstEntry; |
---|
126 | Entry* previous; |
---|
127 | while (walker) |
---|
128 | { |
---|
129 | previous = walker; |
---|
130 | walker = walker->next; |
---|
131 | delete previous; |
---|
132 | } |
---|
133 | this->firstEntry = NULL; |
---|
134 | this->finalized = true; |
---|
135 | } |
---|
136 | |
---|
137 | /** |
---|
138 | * adds a new Entry to the Array |
---|
139 | * @param entry Entry to add. |
---|
140 | */ |
---|
141 | template<class T> |
---|
142 | void Array<T>::addEntry (T entry) |
---|
143 | { |
---|
144 | if (!this->finalized) |
---|
145 | { |
---|
146 | PRINTF(5)("adding new Entry to Array: %f\n", entry); |
---|
147 | |
---|
148 | this->currentEntry->value = entry; |
---|
149 | this->currentEntry->next = new Entry; |
---|
150 | this->currentEntry = currentEntry->next; |
---|
151 | this->currentEntry->next = NULL; |
---|
152 | ++this->entryCount; |
---|
153 | } |
---|
154 | else |
---|
155 | PRINTF(2)("adding failed, because array has already been finalized\n"); |
---|
156 | } |
---|
157 | |
---|
158 | /** |
---|
159 | * Adds 3 entries at once (convenience) |
---|
160 | */ |
---|
161 | template<class T> |
---|
162 | void Array<T>::addEntry (T entry0, T entry1, T entry2) |
---|
163 | { |
---|
164 | this->addEntry(entry0); |
---|
165 | this->addEntry(entry1); |
---|
166 | this->addEntry(entry2); |
---|
167 | } |
---|
168 | |
---|
169 | |
---|
170 | /** |
---|
171 | * gets back the index of the entry in the array. value check |
---|
172 | * @param entry: the entry to look up |
---|
173 | * @returns the index in the array, -1 if not found |
---|
174 | */ |
---|
175 | template<class T> |
---|
176 | int Array<T>::getIndex(T* entry) const |
---|
177 | { |
---|
178 | if( unlikely(this->finalized == false)) |
---|
179 | return -1; |
---|
180 | |
---|
181 | for(int i = 0; i < this->entryCount; ++i) |
---|
182 | { |
---|
183 | if( unlikely(*entry == this->array[i])) |
---|
184 | return i; |
---|
185 | } |
---|
186 | } |
---|
187 | |
---|
188 | |
---|
189 | /** |
---|
190 | * Simple debug info about the Array |
---|
191 | */ |
---|
192 | template<class T> |
---|
193 | void Array<T>::debug () const |
---|
194 | { |
---|
195 | PRINT(0)("entryCount=%i, address=%p\n", this->entryCount, this->array); |
---|
196 | } |
---|
197 | |
---|
198 | #endif |
---|