• Main Page
  • Namespaces
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

ucommon/vector.h

Go to the documentation of this file.
00001 // Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
00002 //
00003 // This file is part of GNU uCommon C++.
00004 //
00005 // GNU uCommon C++ is free software: you can redistribute it and/or modify
00006 // it under the terms of the GNU Lesser General Public License as published 
00007 // by the Free Software Foundation, either version 3 of the License, or
00008 // (at your option) any later version.
00009 //
00010 // GNU uCommon C++ is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU Lesser General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU Lesser General Public License
00016 // along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
00017 
00027 #ifndef _UCOMMON_VECTOR_H_
00028 #define _UCOMMON_VECTOR_H_
00029 
00030 #ifndef _UCOMMON_THREAD_H_
00031 #include <ucommon/thread.h>
00032 #endif
00033 
00034 typedef unsigned short vectorsize_t;
00035 
00036 NAMESPACE_UCOMMON
00037 
00045 class __EXPORT ArrayReuse : public ReusableAllocator
00046 {
00047 private:
00048     size_t objsize;
00049     unsigned count, limit, used;
00050     caddr_t mem;
00051 
00052 protected:
00053     ArrayReuse(size_t objsize, unsigned c);
00054 
00055 public:
00059     ~ArrayReuse();
00060 
00061 protected:
00062     bool avail(void);
00063 
00064     ReusableObject *get(timeout_t timeout);
00065     ReusableObject *get(void);
00066     ReusableObject *request(void);
00067 };
00068 
00076 class __EXPORT PagerReuse : protected ReusableAllocator
00077 {
00078 private:
00079     mempager *pager;
00080     unsigned limit, count;
00081     size_t osize;
00082 
00083     ReusableObject *alloc(void);
00084 
00085 protected:
00086     PagerReuse(mempager *pager, size_t objsize, unsigned count);
00087     ~PagerReuse();
00088 
00089     bool avail(void);
00090     ReusableObject *get(void);
00091     ReusableObject *get(timeout_t timeout);
00092     ReusableObject *request(void);
00093 };  
00094 
00110 class __EXPORT Vector
00111 {
00112 public:
00113     class __EXPORT array : public CountedObject
00114     {
00115     public:
00116 #pragma pack(1)
00117         vectorsize_t max, len;
00118         Object *list[1];
00119 #pragma pack()
00120 
00121         array(vectorsize_t size);
00122         void dealloc(void);
00123         void set(Object **items);
00124         void add(Object **list);
00125         void add(Object *obj);
00126         void purge(void);
00127         void inc(vectorsize_t adj);
00128         void dec(vectorsize_t adj);
00129     };
00130 
00131 protected:
00132     array *data;
00133 
00134     array *create(vectorsize_t size) const;
00135 
00136     virtual void release(void);
00137     virtual void cow(vectorsize_t adj = 0);
00138     Object **list(void) const;
00139 
00140     friend class Vector::array;
00141 
00142 public:
00146     static const vectorsize_t npos;
00147 
00151     Vector();
00152 
00157     Vector(vectorsize_t size);
00158 
00168     Vector(Object **items, vectorsize_t size = 0);
00169 
00173     virtual ~Vector();
00174 
00179     vectorsize_t len(void) const;
00180 
00186     vectorsize_t size(void) const;
00187 
00193     Object *get(int index) const;
00194 
00201     vectorsize_t get(void **mem, vectorsize_t max) const;
00202 
00208     Object *begin(void) const;
00209 
00215     Object *end(void) const;
00216 
00223     vectorsize_t find(Object *pointer, vectorsize_t offset = 0) const;
00224 
00230     void split(vectorsize_t position);
00231 
00238     void rsplit(vectorsize_t position);
00239 
00246     void set(vectorsize_t position, Object *pointer);
00247 
00252     void set(Object **list);
00253 
00258     void add(Object **list);
00259 
00264     void add(Object *pointer);
00265 
00269     void clear(void);
00270 
00275     virtual bool resize(vectorsize_t size);
00276 
00281     inline void set(Vector &vector)
00282         {set(vector.list());};
00283 
00288     inline void add(Vector &vector)
00289         {add(vector.list());};
00290 
00295     inline Object *operator[](int index)
00296         {return get(index);};
00297 
00303     inline void operator()(vectorsize_t position, Object *pointer)
00304         {set(position, pointer);};
00305 
00311     inline Object *operator()(vectorsize_t position)
00312         {return get(position);};
00313 
00318     inline void operator()(Object *pointer)
00319         {add(pointer);};
00320 
00325     inline void operator=(Vector &vector)
00326         {set(vector.list());};
00327 
00332     inline void operator+=(Vector &vector)
00333         {add(vector.list());};
00334 
00339     inline Vector& operator+(Vector &vector)
00340         {add(vector.list()); return *this;};
00341 
00346     Vector &operator^(Vector &vector);
00347 
00354     void operator^=(Vector &vector);
00355 
00359     void operator++();
00360 
00364     void operator--();
00365 
00370     void operator+=(vectorsize_t count);
00371 
00376     void operator-=(vectorsize_t count);
00377 
00383     static vectorsize_t size(void **list);
00384 };
00385 
00391 class __EXPORT MemVector : public Vector
00392 {
00393 private:
00394     bool resize(vectorsize_t size);
00395     void cow(vectorsize_t adj = 0);
00396     void release(void);
00397 
00398     friend class Vector::array;
00399 
00400 public:
00406     MemVector(void *pointer, vectorsize_t size);
00407 
00411     ~MemVector();
00412 
00417     inline void operator=(Vector &vector)
00418         {set(vector);};
00419 
00420 };
00421 
00427 template<class T>
00428 class vectorof : public Vector
00429 {
00430 public:
00434     inline vectorof() : Vector() {};
00435 
00440     inline vectorof(vectorsize_t size) : Vector(size) {};
00441 
00447     inline T *get(int index)
00448         {return static_cast<T *>(Vector::get(index));};
00449 
00455     inline T *operator()(vectorsize_t position)
00456         {return static_cast<T *>(Vector::get(position));};
00457 
00462     inline T *begin(void)
00463         {return static_cast<T *>(Vector::begin());};
00464 
00469     inline T *end(void)
00470         {return static_cast<T *>(Vector::end());};
00471 
00477     inline Vector &operator+(Vector &vector)
00478         {Vector::add(vector); return static_cast<Vector &>(*this);};
00479 };
00480 
00487 template<class T>
00488 class array_reuse : protected ArrayReuse
00489 {
00490 public:
00495     inline array_reuse(unsigned count) :
00496         ArrayReuse(sizeof(T), count) {};
00497 
00502     inline operator bool() const
00503         {return avail();};
00504 
00509     inline bool operator!() const
00510         {return !avail();};
00511 
00516     inline T* request(void)
00517         {return static_cast<T*>(ArrayReuse::request());};
00518 
00524     inline T* get(void)
00525         {return static_cast<T*>(ArrayReuse::get());};
00526 
00532     inline T* create(void)
00533         {return init<T>(static_cast<T*>(ArrayReuse::get()));};
00534 
00541     inline T* get(timeout_t timeout)
00542         {return static_cast<T*>(ArrayReuse::get(timeout));};
00543 
00550     inline T* create(timeout_t timeout)
00551         {return init<T>(static_cast<T*>(ArrayReuse::get(timeout)));};
00552 
00557     inline void release(T *object)
00558         {ArrayReuse::release(object);};
00559 
00565     inline operator T*()
00566         {return array_reuse::get();};
00567 
00573     inline T *operator*()
00574         {return array_reuse::get();};
00575 };
00576 
00583 template <class T>
00584 class paged_reuse : protected PagerReuse
00585 {
00586 public: 
00594     inline paged_reuse(mempager *pager, unsigned count) :
00595         PagerReuse(pager, sizeof(T), count) {};
00596 
00601     inline operator bool() const
00602         {return PagerReuse::avail();};
00603 
00608     inline bool operator!() const
00609         {return !PagerReuse::avail();};
00610 
00616     inline T *get(void)
00617         {return static_cast<T*>(PagerReuse::get());};
00618 
00625     inline T *create(void)
00626         {return init<T>(static_cast<T*>(PagerReuse::get()));};
00627 
00634     inline T *get(timeout_t timeout)
00635         {return static_cast<T*>(PagerReuse::get(timeout));};
00636 
00644     inline T *create(timeout_t timeout)
00645         {return init<T>(static_cast<T*>(PagerReuse::get(timeout)));};
00646 
00651     inline T *request(void)
00652         {return static_cast<T*>(PagerReuse::request());};
00653 
00658     inline void release(T *object)
00659         {PagerReuse::release(object);};
00660 
00666     inline T *operator*()
00667         {return paged_reuse::get();};
00668 
00674     inline operator T*()
00675         {return paged_reuse::get();};
00676 };
00677 
00685 template<class T, vectorsize_t S>
00686 class vectorbuf : public MemVector
00687 {
00688 private:
00689     char buffer[sizeof(array) + (S * sizeof(void *))];
00690     
00691 public:
00695     inline vectorbuf() : MemVector(buffer, S) {};
00696 
00702     inline T *get(int index)
00703         {return static_cast<T *>(Vector::get(index));};
00704 
00710     inline T *operator()(vectorsize_t position)
00711         {return static_cast<T *>(Vector::get(position));};
00712 
00717     inline T *begin(void)
00718         {return static_cast<T *>(Vector::begin());};
00719 
00724     inline T *end(void)
00725         {return static_cast<T *>(Vector::end());};
00726 
00732     inline Vector &operator+(Vector &vector)
00733         {Vector::add(vector); return static_cast<Vector &>(*this);};
00734 };
00735 
00736 END_NAMESPACE
00737 
00738 #endif

Generated on Sun Sep 4 2011 for UCommon by  doxygen 1.7.1