00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
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()
00503 {return avail();};
00504
00509 inline bool operator!()
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
00533 inline T* get(timeout_t timeout)
00534 {return static_cast<T*>(ArrayReuse::get(timeout));};
00535
00540 inline void release(T *object)
00541 {ArrayReuse::release(object);};
00542
00548 inline operator T*()
00549 {return array_reuse::get();};
00550
00556 inline T *operator*()
00557 {return array_reuse::get();};
00558 };
00559
00566 template <class T>
00567 class paged_reuse : protected PagerReuse
00568 {
00569 public:
00577 inline paged_reuse(mempager *pager, unsigned count) :
00578 PagerReuse(pager, sizeof(T), count) {};
00579
00584 inline operator bool()
00585 {return PagerReuse::avail();};
00586
00591 inline bool operator!()
00592 {return !PagerReuse::avail();};
00593
00599 inline T *get(void)
00600 {return static_cast<T*>(PagerReuse::get());};
00601
00608 inline T *get(timeout_t timeout)
00609 {return static_cast<T*>(PagerReuse::get(timeout));};
00610
00615 inline T *request(void)
00616 {return static_cast<T*>(PagerReuse::request());};
00617
00622 inline void release(T *object)
00623 {PagerReuse::release(object);};
00624
00630 inline T *operator*()
00631 {return paged_reuse::get();};
00632
00638 inline operator T*()
00639 {return paged_reuse::get();};
00640 };
00641
00649 template<class T, vectorsize_t S>
00650 class vectorbuf : public MemVector
00651 {
00652 private:
00653 char buffer[sizeof(array) + (S * sizeof(void *))];
00654
00655 public:
00659 inline vectorbuf() : MemVector(buffer, S) {};
00660
00666 inline T *get(int index)
00667 {return static_cast<T *>(Vector::get(index));};
00668
00674 inline T *operator()(vectorsize_t position)
00675 {return static_cast<T *>(Vector::get(position));};
00676
00681 inline T *begin(void)
00682 {return static_cast<T *>(Vector::begin());};
00683
00688 inline T *end(void)
00689 {return static_cast<T *>(Vector::end());};
00690
00696 inline Vector &operator+(Vector &vector)
00697 {Vector::add(vector); return static_cast<Vector &>(*this);};
00698 };
00699
00700 END_NAMESPACE
00701
00702 #endif