Main Page | Modules | Namespace List | Class Hierarchy | Data Structures | Directories | File List | Namespace Members | Data Fields | Globals

Vector.h

Go to the documentation of this file.
00001 /********************************************************************
00002 
00003 Copyright 2006, ACCESS Systems Americas, Inc. All rights reserved.
00004 
00005 The contents of this file are subject to the Mozilla Public License Version
00006 1.1 (the "License"); you may not use this file except in compliance with
00007 the License. You may obtain a copy of the License at
00008 http://www.mozilla.org/MPL/
00009 
00010 Software distributed under the License is distributed on an "AS IS" basis,
00011 WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
00012 for the specific language governing rights and limitations under the
00013 License.
00014 
00015 The Original Code is the entire contents of this file.
00016 
00017 The Initial Developer of the Original Code is ACCESS Systems Americas, Inc.
00018 
00019 Portions created by ACCESS Systems Americas, Inc. are Copyright © 2006. All
00020 Rights Reserved.
00021 
00022 Contributor(s): none.
00023 
00024 ********************************************************************/
00025 /***************************************************************************
00026 //
00027 //      File:                   support/Vector.h
00028 //
00029 //      Description:    A simple array-like container class.  Implemented as
00030 //                                      a general purpose abstract base-class AbstractVector,
00031 //                                      with the concrete class Vector layered on top and
00032 //                                      templatized on the array type.
00033 //
00034 //      Copyright 2001, Be Incorporated, All Rights Reserved.
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 /*----- AbstractVector abstract base class --------------*/
00059 
00060 class AbstractVector
00061 {
00062 public:
00063                                                         AbstractVector(size_t element_size);
00064                                                         AbstractVector(const AbstractVector& o);
00065                                                         // WARNING: Your subclass must call MakeEmpty()
00066                                                         // in its own destructor!
00067         virtual                                 ~AbstractVector();
00068 
00069                         AbstractVector& operator=(const AbstractVector& o);
00070 
00071         /* Size stats */
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         /* Data access */
00082 
00083                         const void*             At(size_t index) const;
00084                         void*                   EditAt(size_t index);
00085 
00086         /* Array modification */
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 // Type optimizations.
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 /*----- Vector concrete class ---------------------------*/
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         /* Size stats */
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         /* Data access */
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         /* Array modification */
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         /* Use as a stack */
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 // Type optimizations.
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 /*---- No user serviceable parts after this -------------------*/
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 //      if (count == 0) debugger(gStaskOverFlow);
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 //      if (count == 0) debugger(gStaskOverFlow);
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 //      if (count == 0) debugger(gStaskOverFlow);
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 }       // namespace alp
00455 
00456 #endif

Generated on Sat Dec 16 20:29:47 2006 for hiker-0.9 by  doxygen 1.4.4