00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #ifndef _SUPPORT_VECTOR_H
00039 #define _SUPPORT_VECTOR_H
00040
00041 #include <errno.h>
00042 #include <stddef.h>
00043 #include <stdint.h>
00044
00045 #include <hiker/types.h>
00046
00047 #include <hiker/prv/support/TypeFuncs.h>
00048
00049 typedef int32_t ssize_t;
00050
00051 #ifndef SSIZE_MAX
00052 # define SSIZE_MAX INT32_MAX
00053 #endif
00054
00055 namespace alp {
00056
00057
00058
00059
00060 class AbstractVector
00061 {
00062 public:
00063 AbstractVector(size_t element_size);
00064 AbstractVector(const AbstractVector& o);
00065
00066
00067 virtual ~AbstractVector();
00068
00069 AbstractVector& operator=(const AbstractVector& o);
00070
00071
00072
00073 void SetCapacity(size_t total_space);
00074 void SetExtraCapacity(size_t extra_space);
00075 size_t Capacity() const;
00076
00077 size_t ItemSize() const;
00078
00079 size_t CountItems() const;
00080
00081
00082
00083 const void* At(size_t index) const;
00084 void* EditAt(size_t index);
00085
00086
00087
00088 ssize_t Add(const void* newElement);
00089 ssize_t AddAt(const void* newElement, size_t index);
00090
00091 ssize_t AddVector(const AbstractVector& o);
00092 ssize_t AddVectorAt(const AbstractVector& o, size_t index = SSIZE_MAX);
00093
00094 void MakeEmpty();
00095 void RemoveItemsAt(size_t index, size_t count);
00096
00097 void Swap(AbstractVector& o);
00098
00099 protected:
00100 static char const * const gStaskOverFlow;
00101
00102 virtual void PerformConstruct(void* base, size_t count) const = 0;
00103 virtual void PerformCopy(void* to, const void* from, size_t count) const = 0;
00104 virtual void PerformDestroy(void* base, size_t count) const = 0;
00105
00106 virtual void PerformMoveBefore(void* to, void* from, size_t count) const = 0;
00107 virtual void PerformMoveAfter(void* to, void* from, size_t count) const = 0;
00108
00109 virtual void PerformAssign(void* to, const void* from, size_t count) const = 0;
00110
00111 private:
00112
00113 virtual alp_status_t _ReservedUntypedVector1();
00114 virtual alp_status_t _ReservedUntypedVector2();
00115 virtual alp_status_t _ReservedUntypedVector3();
00116 virtual alp_status_t _ReservedUntypedVector4();
00117 virtual alp_status_t _ReservedUntypedVector5();
00118 virtual alp_status_t _ReservedUntypedVector6();
00119 virtual alp_status_t _ReservedUntypedVector7();
00120 virtual alp_status_t _ReservedUntypedVector8();
00121 virtual alp_status_t _ReservedUntypedVector9();
00122 virtual alp_status_t _ReservedUntypedVector10();
00123
00124 uint8_t* grow(size_t amount, size_t factor=3, size_t pos=0xFFFFFFFF);
00125 uint8_t* shrink(size_t amount, size_t factor=4, size_t pos=0xFFFFFFFF);
00126 const uint8_t* data() const;
00127 uint8_t* edit_data();
00128
00129 const size_t m_elementSize;
00130 const size_t m_localSpace;
00131 size_t m_avail;
00132 size_t m_size;
00133
00134 union {
00135 uint8_t* heap;
00136 uint8_t local[8];
00137 } m_data;
00138
00139 int32_t _reserved[2];
00140 };
00141
00142
00143 void MoveBefore(AbstractVector* to, AbstractVector* from, size_t count = 1);
00144 void MoveAfter(AbstractVector* to, AbstractVector* from, size_t count = 1);
00145 void Swap(AbstractVector& v1, AbstractVector& v2);
00146
00147
00148
00149
00152 template<class TYPE>
00153 class Vector : private AbstractVector
00154 {
00155 public:
00156 Vector();
00157 Vector(const Vector<TYPE>& o);
00158 virtual ~Vector();
00159
00160 Vector<TYPE>& operator=(const Vector<TYPE>& o);
00161
00162
00163
00164 void SetCapacity(size_t total_space);
00165 void SetExtraCapacity(size_t extra_space);
00166 size_t Capacity() const;
00167
00168 size_t CountItems() const;
00169
00170
00171
00172 const TYPE& operator[](size_t i) const;
00173 const TYPE& ItemAt(size_t i) const;
00174 TYPE& EditItemAt(size_t i);
00175
00176
00177
00178 ssize_t AddItem();
00179 ssize_t AddItem(const TYPE& item);
00180 ssize_t AddItemAt(size_t index);
00181 ssize_t AddItemAt(const TYPE& item, size_t index);
00182
00183 ssize_t ReplaceItemAt(const TYPE& item, size_t index);
00184
00185 ssize_t AddVector(const Vector<TYPE>& o);
00186 ssize_t AddVectorAt(const Vector<TYPE>& o, size_t index);
00187
00188 void MakeEmpty();
00189 void RemoveItemsAt(size_t index, size_t count = 1);
00190
00191 void Swap(Vector<TYPE>& o);
00192
00193
00194
00195 void Push();
00196 void Push(const TYPE& item);
00197 TYPE & EditTop();
00198 const TYPE & Top() const;
00199 void Pop();
00200
00201 protected:
00202 virtual void PerformConstruct(void* base, size_t count) const;
00203 virtual void PerformCopy(void* to, const void* from, size_t count) const;
00204 virtual void PerformDestroy(void* base, size_t count) const;
00205
00206 virtual void PerformMoveBefore(void* to, void* from, size_t count) const;
00207 virtual void PerformMoveAfter(void* to, void* from, size_t count) const;
00208
00209 virtual void PerformAssign(void* to, const void* from, size_t count) const;
00210 };
00211
00212
00213 template<class TYPE>
00214 void MoveBefore(Vector<TYPE>* to, Vector<TYPE>* from, size_t count = 1);
00215 template<class TYPE>
00216 void MoveAfter(Vector<TYPE>* to, Vector<TYPE>* from, size_t count = 1);
00217 template<class TYPE>
00218 void Swap(Vector<TYPE>& v1, Vector<TYPE>& v2);
00219
00220
00221
00222
00223 inline void Swap(AbstractVector& v1, AbstractVector& v2)
00224 {
00225 v1.Swap(v2);
00226 }
00227
00228
00229
00230 template<class TYPE> inline
00231 Vector<TYPE>::Vector()
00232 : AbstractVector(sizeof(TYPE[2])/2)
00233 {
00234 }
00235
00236 template<class TYPE> inline
00237 Vector<TYPE>::Vector(const Vector<TYPE>& o)
00238 : AbstractVector(o)
00239 {
00240 }
00241
00242 template<class TYPE> inline
00243 Vector<TYPE>::~Vector()
00244 {
00245 MakeEmpty();
00246 }
00247
00248 template<class TYPE> inline
00249 Vector<TYPE>& Vector<TYPE>::operator=(const Vector<TYPE>& o)
00250 {
00251 AbstractVector::operator=(o);
00252 return *this;
00253 }
00254
00255 template<class TYPE> inline
00256 void Vector<TYPE>::SetCapacity(size_t total_space)
00257 {
00258 AbstractVector::SetCapacity(total_space);
00259 }
00260
00261 template<class TYPE> inline
00262 void Vector<TYPE>::SetExtraCapacity(size_t extra_space)
00263 {
00264 AbstractVector::SetExtraCapacity(extra_space);
00265 }
00266
00267 template<class TYPE> inline
00268 size_t Vector<TYPE>::Capacity() const
00269 {
00270 return AbstractVector::Capacity();
00271 }
00272
00273 template<class TYPE> inline
00274 size_t Vector<TYPE>::CountItems() const
00275 {
00276 return AbstractVector::CountItems();
00277 }
00278
00279 template<class TYPE> inline
00280 const TYPE& Vector<TYPE>::operator[](size_t i) const
00281 {
00282 return *static_cast<const TYPE*>(At(i));
00283 }
00284
00285 template<class TYPE> inline
00286 const TYPE& Vector<TYPE>::ItemAt(size_t i) const
00287 {
00288 return *static_cast<const TYPE*>(At(i));
00289 }
00290
00291 template<class TYPE> inline
00292 TYPE& Vector<TYPE>::EditItemAt(size_t i)
00293 {
00294 return *static_cast<TYPE*>(EditAt(i));
00295 }
00296
00297 template<class TYPE> inline
00298 ssize_t Vector<TYPE>::AddItem()
00299 {
00300 return Add(NULL);
00301 }
00302
00303 template<class TYPE> inline
00304 ssize_t Vector<TYPE>::AddItem(const TYPE &item)
00305 {
00306 return Add(&item);
00307 }
00308
00309 template<class TYPE> inline
00310 ssize_t Vector<TYPE>::AddItemAt(size_t index)
00311 {
00312 return AddAt(NULL, index);
00313 }
00314
00315 template<class TYPE> inline
00316 ssize_t Vector<TYPE>::AddItemAt(const TYPE &item, size_t index)
00317 {
00318 return AddAt(&item, index);
00319 }
00320
00321 template<class TYPE> inline
00322 ssize_t Vector<TYPE>::ReplaceItemAt(const TYPE& item, size_t index)
00323 {
00324 TYPE* elem = static_cast<TYPE*>(EditAt(index));
00325 if (elem) {
00326 *elem = item;
00327 return index;
00328 }
00329 return ENOMEM;
00330 }
00331
00332 template<class TYPE> inline
00333 ssize_t Vector<TYPE>::AddVector(const Vector<TYPE>& o)
00334 {
00335 return AbstractVector::AddVector(o);
00336 }
00337
00338 template<class TYPE> inline
00339 ssize_t Vector<TYPE>::AddVectorAt(const Vector<TYPE>& o, size_t index)
00340 {
00341 return AbstractVector::AddVectorAt(o, index);
00342 }
00343
00344 template<class TYPE> inline
00345 void Vector<TYPE>::MakeEmpty()
00346 {
00347 AbstractVector::MakeEmpty();
00348 }
00349
00350 template<class TYPE> inline
00351 void Vector<TYPE>::RemoveItemsAt(size_t index, size_t count)
00352 {
00353 AbstractVector::RemoveItemsAt(index, count);
00354 }
00355
00356 template<class TYPE> inline
00357 void Vector<TYPE>::Swap(Vector<TYPE>& o)
00358 {
00359 AbstractVector::Swap(o);
00360 }
00361
00362 template<class TYPE> inline
00363 void Vector<TYPE>::Push()
00364 {
00365 AddItem();
00366 }
00367
00368 template<class TYPE> inline
00369 void Vector<TYPE>::Push(const TYPE& item)
00370 {
00371 AddItem(item);
00372 }
00373
00374 template<class TYPE> inline
00375 TYPE& Vector<TYPE>::EditTop()
00376 {
00377 const size_t count = CountItems();
00378
00379 return EditItemAt(count-1);
00380 }
00381
00382 template<class TYPE> inline
00383 const TYPE& Vector<TYPE>::Top() const
00384 {
00385 const size_t count = CountItems();
00386
00387 return ItemAt(count-1);
00388 }
00389
00390 template<class TYPE> inline
00391 void Vector<TYPE>::Pop()
00392 {
00393 const size_t count = CountItems();
00394
00395 RemoveItemsAt(count-1);
00396 }
00397
00398 template<class TYPE>
00399 void Vector<TYPE>::PerformConstruct(void* base, size_t count) const
00400 {
00401 Construct(static_cast<TYPE*>(base), count);
00402 }
00403
00404 template<class TYPE>
00405 void Vector<TYPE>::PerformCopy(void* to, const void* from, size_t count) const
00406 {
00407 Copy(static_cast<TYPE*>(to), static_cast<const TYPE*>(from), count);
00408 }
00409
00410 template<class TYPE>
00411 void Vector<TYPE>::PerformDestroy(void* base, size_t count) const
00412 {
00413 Destroy(static_cast<TYPE*>(base), count);
00414 }
00415
00416 template<class TYPE>
00417 void Vector<TYPE>::PerformMoveBefore( void* to, void* from, size_t count) const
00418 {
00419 MoveBefore(static_cast<TYPE*>(to), static_cast<TYPE*>(from), count);
00420 }
00421
00422 template<class TYPE>
00423 void Vector<TYPE>::PerformMoveAfter( void* to, void* from, size_t count) const
00424 {
00425 MoveAfter(static_cast<TYPE*>(to), static_cast<TYPE*>(from), count);
00426 }
00427
00428 template<class TYPE>
00429 void Vector<TYPE>::PerformAssign( void* to, const void* from, size_t count) const
00430 {
00431 Assign(static_cast<TYPE*>(to), static_cast<const TYPE*>(from), count);
00432 }
00433
00434
00435
00436 template<class TYPE> inline
00437 void MoveBefore(Vector<TYPE>* to, Vector<TYPE>* from, size_t count)
00438 {
00439 MoveBefore(reinterpret_cast<AbstractVector*>(to), reinterpret_cast<AbstractVector*>(from), count);
00440 }
00441
00442 template<class TYPE> inline
00443 void MoveAfter(Vector<TYPE>* to, Vector<TYPE>* from, size_t count)
00444 {
00445 MoveAfter(reinterpret_cast<AbstractVector*>(to), reinterpret_cast<AbstractVector*>(from), count);
00446 }
00447
00448 template<class TYPE> inline
00449 void Swap(Vector<TYPE>& v1, Vector<TYPE>& v2)
00450 {
00451 v1.Swap(v2);
00452 }
00453
00454 }
00455
00456 #endif