UCommon
vector.h
Go to the documentation of this file.
1 // Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
2 //
3 // This file is part of GNU uCommon C++.
4 //
5 // GNU uCommon C++ is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU Lesser General Public License as published
7 // by the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // GNU uCommon C++ is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public License
16 // along with GNU uCommon C++. If not, see <http://www.gnu.org/licenses/>.
17 
27 #ifndef _UCOMMON_VECTOR_H_
28 #define _UCOMMON_VECTOR_H_
29 
30 #ifndef _UCOMMON_THREAD_H_
31 #include <ucommon/thread.h>
32 #endif
33 
34 typedef unsigned short vectorsize_t;
35 
36 NAMESPACE_UCOMMON
37 
45 class __EXPORT ArrayReuse : public ReusableAllocator
46 {
47 private:
48  size_t objsize;
49  unsigned count, limit, used;
50  caddr_t mem;
51 
52 protected:
53  ArrayReuse(size_t objsize, unsigned c);
54  ArrayReuse(size_t objsize, unsigned c, void *memory);
55 
56 public:
60  ~ArrayReuse();
61 
62 protected:
63  bool avail(void);
64 
65  ReusableObject *get(timeout_t timeout);
66  ReusableObject *get(void);
67  ReusableObject *request(void);
68 };
69 
77 class __EXPORT PagerReuse : protected MemoryRedirect, protected ReusableAllocator
78 {
79 private:
80  unsigned limit, count;
81  size_t osize;
82 
83 protected:
84  PagerReuse(mempager *pager, size_t objsize, unsigned count);
85  ~PagerReuse();
86 
87  bool avail(void);
88  ReusableObject *get(void);
89  ReusableObject *get(timeout_t timeout);
90  ReusableObject *request(void);
91 };
92 
108 class __EXPORT Vector
109 {
110 public:
111  class __EXPORT array : public CountedObject
112  {
113  public:
114 #pragma pack(1)
115  vectorsize_t max, len;
116  ObjectProtocol *list[1];
117 #pragma pack()
118 
119  array(vectorsize_t size);
120  void dealloc(void);
121  void set(ObjectProtocol **items);
122  void add(ObjectProtocol **list);
123  void add(ObjectProtocol *obj);
124  void purge(void);
125  void inc(vectorsize_t adj);
126  void dec(vectorsize_t adj);
127  };
128 
129 protected:
130  array *data;
131 
132  array *create(vectorsize_t size) const;
133 
134  virtual void release(void);
135  virtual void cow(vectorsize_t adj = 0);
136  ObjectProtocol **list(void) const;
137 
138  friend class Vector::array;
139 
140 protected:
145  virtual ObjectProtocol *invalid(void) const;
146 
147 public:
151  static const vectorsize_t npos;
152 
156  Vector();
157 
162  Vector(vectorsize_t size);
163 
173  Vector(ObjectProtocol **items, vectorsize_t size = 0);
174 
178  virtual ~Vector();
179 
184  vectorsize_t len(void) const;
185 
191  vectorsize_t size(void) const;
192 
198  ObjectProtocol *get(int index) const;
199 
206  vectorsize_t get(void **mem, vectorsize_t max) const;
207 
213  ObjectProtocol *begin(void) const;
214 
220  ObjectProtocol *end(void) const;
221 
228  vectorsize_t find(ObjectProtocol *pointer, vectorsize_t offset = 0) const;
229 
235  void split(vectorsize_t position);
236 
243  void rsplit(vectorsize_t position);
244 
251  void set(vectorsize_t position, ObjectProtocol *pointer);
252 
257  void set(ObjectProtocol **list);
258 
263  void add(ObjectProtocol **list);
264 
269  void add(ObjectProtocol *pointer);
270 
274  void clear(void);
275 
280  virtual bool resize(vectorsize_t size);
281 
286  inline void set(Vector &vector)
287  {set(vector.list());};
288 
293  inline void add(Vector &vector)
294  {add(vector.list());};
295 
300  inline ObjectProtocol *operator[](int index)
301  {return get(index);};
302 
308  inline void operator()(vectorsize_t position, ObjectProtocol *pointer)
309  {set(position, pointer);};
310 
316  inline ObjectProtocol *operator()(vectorsize_t position)
317  {return get(position);};
318 
324  {add(pointer);};
325 
330  inline void operator=(Vector &vector)
331  {set(vector.list());};
332 
337  inline void operator+=(Vector &vector)
338  {add(vector.list());};
339 
344  inline Vector& operator+(Vector &vector)
345  {add(vector.list()); return *this;};
346 
351  Vector &operator^(Vector &vector);
352 
359  void operator^=(Vector &vector);
360 
364  void operator++();
365 
369  void operator--();
370 
375  void operator+=(vectorsize_t count);
376 
381  void operator-=(vectorsize_t count);
382 
388  static vectorsize_t size(void **list);
389 };
390 
396 class __EXPORT MemVector : public Vector
397 {
398 private:
399  bool resize(vectorsize_t size);
400  void cow(vectorsize_t adj = 0);
401  void release(void);
402 
403  friend class Vector::array;
404 
405 public:
411  MemVector(void *pointer, vectorsize_t size);
412 
416  ~MemVector();
417 
422  inline void operator=(Vector &vector)
423  {set(vector);};
424 
425 };
426 
432 template<class T>
433 class vectorof : public Vector
434 {
435 public:
439  inline vectorof() : Vector() {};
440 
445  inline vectorof(vectorsize_t size) : Vector(size) {};
446 
447  inline T& operator[](int index)
448  {return static_cast<T&>(Vector::get(index));};
449 
450  inline const T& at(int index)
451  {return static_cast<const T&>(Vector::get(index));};
452 
458  inline T *operator()(vectorsize_t position)
459  {return static_cast<T *>(Vector::get(position));};
460 
465  inline T *begin(void)
466  {return static_cast<T *>(Vector::begin());};
467 
472  inline T *end(void)
473  {return static_cast<T *>(Vector::end());};
474 
480  inline Vector &operator+(Vector &vector)
481  {Vector::add(vector); return static_cast<Vector &>(*this);};
482 };
483 
490 template<class T>
491 class array_reuse : protected ArrayReuse
492 {
493 public:
498  inline array_reuse(unsigned count) :
499  ArrayReuse(sizeof(T), count) {};
500 
506  inline array_reuse(unsigned count, void *memory) :
507  ArrayReuse(sizeof(T), count, memory) {};
508 
513  inline operator bool() const
514  {return avail();};
515 
520  inline bool operator!() const
521  {return !avail();};
522 
527  inline T* request(void)
528  {return static_cast<T*>(ArrayReuse::request());};
529 
535  inline T* get(void)
536  {return static_cast<T*>(ArrayReuse::get());};
537 
543  inline T* create(void)
544  {return init<T>(static_cast<T*>(ArrayReuse::get()));};
545 
552  inline T* get(timeout_t timeout)
553  {return static_cast<T*>(ArrayReuse::get(timeout));};
554 
561  inline T* create(timeout_t timeout)
562  {return init<T>(static_cast<T*>(ArrayReuse::get(timeout)));};
563 
568  inline void release(T *object)
569  {ArrayReuse::release(object);};
570 
576  inline operator T*()
577  {return array_reuse::get();};
578 
584  inline T *operator*()
585  {return array_reuse::get();};
586 };
587 
594 template <class T>
595 class paged_reuse : protected PagerReuse
596 {
597 public:
605  inline paged_reuse(mempager *pager, unsigned count) :
606  PagerReuse(pager, sizeof(T), count) {};
607 
612  inline operator bool() const
613  {return PagerReuse::avail();};
614 
619  inline bool operator!() const
620  {return !PagerReuse::avail();};
621 
627  inline T *get(void)
628  {return static_cast<T*>(PagerReuse::get());};
629 
636  inline T *create(void)
637  {return init<T>(static_cast<T*>(PagerReuse::get()));};
638 
645  inline T *get(timeout_t timeout)
646  {return static_cast<T*>(PagerReuse::get(timeout));};
647 
655  inline T *create(timeout_t timeout)
656  {return init<T>(static_cast<T*>(PagerReuse::get(timeout)));};
657 
662  inline T *request(void)
663  {return static_cast<T*>(PagerReuse::request());};
664 
669  inline void release(T *object)
670  {PagerReuse::release(object);};
671 
677  inline T *operator*()
678  {return paged_reuse::get();};
679 
685  inline operator T*()
686  {return paged_reuse::get();};
687 };
688 
696 template<typename T, vectorsize_t S>
697 class vectorbuf : public MemVector
698 {
699 private:
700  char buffer[sizeof(array) + (S * sizeof(void *))];
701 
702 public:
706  inline vectorbuf() : MemVector(buffer, S) {};
707 
713  inline const T& at(int index)
714  {return static_cast<const T&>(Vector::get(index));};
715 
716  inline T& operator[](int index)
717  {return static_cast<T&>(Vector::get(index));};
718 
724  inline T *operator()(vectorsize_t position)
725  {return static_cast<T *>(Vector::get(position));};
726 
731  inline T *begin(void)
732  {return static_cast<T *>(Vector::begin());};
733 
738  inline T *end(void)
739  {return static_cast<T *>(Vector::end());};
740 
746  inline Vector &operator+(Vector &vector)
747  {Vector::add(vector); return static_cast<Vector &>(*this);};
748 };
749 
750 END_NAMESPACE
751 
752 #endif
T * create(timeout_t timeout)
Create a typed object from the heap.
Definition: vector.h:561
vectorbuf()
Construct fixed sized vector object in heap or stack.
Definition: vector.h:706
A reusable private pool of reusable types.
Definition: vector.h:595
paged_reuse(mempager *pager, unsigned count)
Create a managed reusable typed object pool.
Definition: vector.h:605
A common base class for all managed objects.
Definition: protocols.h:544
void set(Vector &vector)
Set (duplicate) an existing vector into our vector.
Definition: vector.h:286
Vector with fixed size member list.
Definition: vector.h:396
An array of reusable objects.
Definition: vector.h:45
Generic smart pointer class.
Definition: generics.h:56
T * operator*()
Get a typed object from the heap by pointer reference.
Definition: vector.h:584
unsigned long timeout_t
Typedef for millisecond timer values.
Definition: platform.h:326
A managed private heap for small allocations.
Definition: memory.h:175
void set(vectorsize_t position, ObjectProtocol *pointer)
Set a member of the vector to an object.
ObjectProtocol * operator()(vectorsize_t position)
Retrieve a member of the vector directly.
Definition: vector.h:316
T * end(void)
Get the last typed object pointer contained in the fixed vector.
Definition: vector.h:738
void operator--(void)
Decrease retention operator.
Definition: protocols.h:576
void operator()(vectorsize_t position, ObjectProtocol *pointer)
Assign a member of the vector directly.
Definition: vector.h:308
T &() limit(T &value, T &low, T &high)
Convenience macro to range restrict values.
Definition: generics.h:568
Mempager managed type factory for pager pool objects.
Definition: memory.h:1259
vectorof(vectorsize_t size)
Create an empty vector of allocated size for specified type.
Definition: vector.h:445
Vector & operator+(Vector &vector)
Concatenate fixed typed vector in an expression.
Definition: vector.h:746
Vector & operator+(Vector &vector)
Concatenate typed vector in an expression.
Definition: vector.h:480
void release(SharedAccess &object)
Convenience function to unlock shared object through it&#39;s protocol.
Definition: access.h:260
void operator()(ObjectProtocol *pointer)
Append a member to the vector directly.
Definition: vector.h:323
T * create(timeout_t timeout)
Create a typed object from the heap.
Definition: vector.h:655
A templated vector for a list of a specific Object subtype.
Definition: vector.h:433
void release(T *object)
Release (return) a typed object back to the pager heap for re-use.
Definition: vector.h:669
T * begin(void)
Get the first typed object pointer contained in the vector.
Definition: vector.h:465
A mempager source of reusable objects.
Definition: vector.h:77
T * create(void)
Create a typed object from the heap.
Definition: vector.h:543
T * begin(void)
Get the first typed object pointer contained in the fixed vector.
Definition: vector.h:731
T * create(void)
Get a typed object from the pager heap.
Definition: vector.h:636
A redirection base class for the memory protocol.
Definition: protocols.h:103
An array of reusable types.
Definition: vector.h:491
Vector & operator+(Vector &vector)
Concatenate into our existing vector from assignment list.
Definition: vector.h:344
array_reuse(unsigned count)
Create private heap of reusable objects of specified type.
Definition: vector.h:498
Thread classes and sychronization objects.
void release(T *object)
Release (return) a typed object back to the heap for re-use.
Definition: vector.h:568
void operator++(void)
Increase retention operator.
Definition: protocols.h:570
T * operator()(vectorsize_t position)
Retrieve a typed member of the fixed vector directly.
Definition: vector.h:724
Reusable objects for forming private heaps.
Definition: linked.h:152
void operator=(Vector &vector)
Assign (copy) into our existing vector from another vector.
Definition: vector.h:330
T * operator()(vectorsize_t position)
Retrieve a typed member of the vector directly.
Definition: vector.h:458
bool operator!() const
Test if no objects are available for reuse or the pager.
Definition: vector.h:619
virtual bool resize(vectorsize_t size)
Re-size &amp; re-allocate the total (allocated) size of the vector.
void release(void)
Decrease reference count when released.
A base class for reference counted objects.
Definition: object.h:55
bool operator!() const
Test if the entire heap has been allocated.
Definition: vector.h:520
T * request(void)
Request immediately next available typed object from the heap.
Definition: vector.h:527
Allocated vector list of a specified type.
Definition: vector.h:697
T &() max(T &o1, T &o2)
Convenience function to return max of two objects.
Definition: generics.h:543
ObjectProtocol * operator[](int index)
Return a pointer from the vector by array reference.
Definition: vector.h:300
T * operator*()
Get a typed object from the pager heap by type casting reference.
Definition: vector.h:677
T * end(void)
Get the last typed object pointer contained in the vector.
Definition: vector.h:472
vectorof()
Create an empty vector for specified type.
Definition: vector.h:439
void add(Vector &vector)
Add (append) an existing vector to our vector.
Definition: vector.h:293
const T & at(int index)
Get object pointer of specified type from fixed vector.
Definition: vector.h:713
static const vectorsize_t npos
npos is a constant for an &quot;invalid&quot; position value.
Definition: vector.h:151
A managed vector for generic object pointers.
Definition: vector.h:108
array_reuse(unsigned count, void *memory)
Create reusable objects of specific type in preallocated memory.
Definition: vector.h:506
void operator=(Vector &vector)
Assign an existing vector into our fixed vector list.
Definition: vector.h:422
T * request(void)
Request immediately next available typed object from the pager heap.
Definition: vector.h:662
void operator+=(Vector &vector)
Append into our existing vector from another vector.
Definition: vector.h:337
Class for resource bound memory pools between threads.
Definition: thread.h:678