UCommon
vector.h
Go to the documentation of this file.
1 // Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
2 // Copyright (C) 2015 Cherokees of Idaho.
3 //
4 // This file is part of GNU uCommon C++.
5 //
6 // GNU uCommon C++ is free software: you can redistribute it and/or modify
7 // it under the terms of the GNU Lesser General Public License as published
8 // by the Free Software Foundation, either version 3 of the License, or
9 // (at your option) any later version.
10 //
11 // GNU uCommon C++ is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public License
17 // along with GNU uCommon C++. If not, see <http://www.gnu.org/licenses/>.
18 
28 #ifndef _UCOMMON_VECTOR_H_
29 #define _UCOMMON_VECTOR_H_
30 
31 #ifndef _UCOMMON_THREAD_H_
32 #include <ucommon/thread.h>
33 #endif
34 
35 namespace ucommon {
36 
37 typedef unsigned short vectorsize_t;
38 
46 class __EXPORT ArrayReuse : public ReusableAllocator
47 {
48 private:
49  size_t objsize;
50  unsigned count, limit, used;
51  caddr_t mem;
52 
53 protected:
54  ArrayReuse(size_t objsize, unsigned c);
55  ArrayReuse(size_t objsize, unsigned c, void *memory);
56 
57 public:
61  ~ArrayReuse();
62 
63 protected:
64  bool avail(void) const;
65 
66  ReusableObject *get(timeout_t timeout);
67  ReusableObject *get(void);
68  ReusableObject *request(void);
69 };
70 
78 class __EXPORT PagerReuse : protected MemoryRedirect, protected ReusableAllocator
79 {
80 private:
81  unsigned limit, count;
82  size_t osize;
83 
84 protected:
85  PagerReuse(mempager *pager, size_t objsize, unsigned count);
86  ~PagerReuse();
87 
88  bool avail(void) const;
89  ReusableObject *get(void);
90  ReusableObject *get(timeout_t timeout);
91  ReusableObject *request(void);
92 };
93 
109 class __EXPORT Vector
110 {
111 public:
112  class __EXPORT array : public CountedObject
113  {
114  public:
115 #pragma pack(1)
116  vectorsize_t max, len;
117  ObjectProtocol *list[1];
118 #pragma pack()
119 
120  array(vectorsize_t size);
121  void dealloc(void);
122  void set(ObjectProtocol **items);
123  void add(ObjectProtocol **list);
124  void add(ObjectProtocol *obj);
125  void purge(void);
126  void inc(vectorsize_t adj);
127  void dec(vectorsize_t adj);
128  };
129 
130 protected:
131  array *data;
132 
133  array *create(vectorsize_t size) const;
134 
135  virtual void release(void);
136  virtual void cow(vectorsize_t adj = 0);
137  ObjectProtocol **list(void) const;
138 
139  friend class Vector::array;
140 
141 protected:
146  virtual ObjectProtocol *invalid(void) const;
147 
148 public:
152  static const vectorsize_t npos;
153 
157  Vector();
158 
163  Vector(vectorsize_t size);
164 
174  Vector(ObjectProtocol **items, vectorsize_t size = 0);
175 
179  virtual ~Vector();
180 
185  vectorsize_t len(void) const;
186 
192  vectorsize_t size(void) const;
193 
199  ObjectProtocol *get(int index) const;
200 
207  vectorsize_t get(void **mem, vectorsize_t max) const;
208 
214  ObjectProtocol *begin(void) const;
215 
221  ObjectProtocol *end(void) const;
222 
229  vectorsize_t find(ObjectProtocol *pointer, vectorsize_t offset = 0) const;
230 
236  void split(vectorsize_t position);
237 
244  void rsplit(vectorsize_t position);
245 
252  void set(vectorsize_t position, ObjectProtocol *pointer);
253 
258  void set(ObjectProtocol **list);
259 
264  void add(ObjectProtocol **list);
265 
270  void add(ObjectProtocol *pointer);
271 
275  void clear(void);
276 
281  virtual bool resize(vectorsize_t size);
282 
287  inline void set(Vector &vector) {
288  set(vector.list());
289  }
290 
295  inline void add(Vector &vector) {
296  add(vector.list());
297  }
298 
303  inline ObjectProtocol *operator[](int index) {
304  return get(index);
305  }
306 
312  inline void operator()(vectorsize_t position, ObjectProtocol *pointer) {
313  set(position, pointer);
314  }
315 
321  inline ObjectProtocol *operator()(vectorsize_t position) {
322  return get(position);
323  }
324 
330  add(pointer);
331  }
332 
337  inline void operator=(Vector &vector) {
338  set(vector.list());
339  }
340 
345  inline void operator+=(Vector &vector) {
346  add(vector.list());
347  }
348 
353  inline Vector& operator+(Vector &vector) {
354  add(vector.list());
355  return *this;
356  }
357 
362  Vector &operator^(Vector &vector);
363 
370  void operator^=(Vector &vector);
371 
375  void operator++();
376 
380  void operator--();
381 
386  void operator+=(vectorsize_t count);
387 
392  void operator-=(vectorsize_t count);
393 
399  static vectorsize_t size(void **list);
400 };
401 
407 class __EXPORT MemVector : public Vector
408 {
409 private:
410  bool resize(vectorsize_t size);
411  void cow(vectorsize_t adj = 0);
412  void release(void);
413 
414  friend class Vector::array;
415 
416 public:
422  MemVector(void *pointer, vectorsize_t size);
423 
427  ~MemVector();
428 
433  inline void operator=(Vector &vector) {
434  set(vector);
435  }
436 
437 };
438 
444 template<class T>
445 class vectorof : public Vector
446 {
447 public:
451  inline vectorof() : Vector() {}
452 
457  inline vectorof(vectorsize_t size) : Vector(size) {}
458 
459  inline T& operator[](int index) {
460  return static_cast<T&>(Vector::get(index));
461  }
462 
463  inline const T& at(int index) {
464  return immutable_cast<T&>(Vector::get(index));
465  }
466 
472  inline T *operator()(vectorsize_t position) {
473  return static_cast<T *>(Vector::get(position));
474  }
475 
480  inline T *begin(void) {
481  return static_cast<T *>(Vector::begin());
482  }
483 
488  inline T *end(void) {
489  return static_cast<T *>(Vector::end());
490  }
491 
497  inline Vector &operator+(Vector &vector) {
498  Vector::add(vector);
499  return static_cast<Vector &>(*this);
500  }
501 };
502 
509 template<class T>
510 class array_reuse : protected ArrayReuse
511 {
512 public:
517  inline array_reuse(unsigned count) :
518  ArrayReuse(sizeof(T), count) {}
519 
525  inline array_reuse(unsigned count, void *memory) :
526  ArrayReuse(sizeof(T), count, memory) {}
527 
532  inline operator bool() const {
533  return avail();
534  }
535 
540  inline bool operator!() const {
541  return !avail();
542  }
543 
548  inline T* request(void) {
549  return static_cast<T*>(ArrayReuse::request());
550  }
551 
557  inline T* get(void) {
558  return static_cast<T*>(ArrayReuse::get());
559  }
560 
566  inline T* create(void) {
567  return init<T>(static_cast<T*>(ArrayReuse::get()));
568  }
569 
576  inline T* get(timeout_t timeout) {
577  return static_cast<T*>(ArrayReuse::get(timeout));
578  }
579 
586  inline T* create(timeout_t timeout) {
587  return init<T>(static_cast<T*>(ArrayReuse::get(timeout)));
588  }
589 
594  inline void release(T *object) {
595  ArrayReuse::release(object);
596  }
597 
603  inline operator T*() {
604  return array_reuse::get();
605  }
606 
612  inline T *operator*() {
613  return array_reuse::get();
614  }
615 };
616 
623 template <class T>
624 class paged_reuse : protected PagerReuse
625 {
626 public:
634  inline paged_reuse(mempager *pager, unsigned count) :
635  PagerReuse(pager, sizeof(T), count) {}
636 
641  inline operator bool() const {
642  return PagerReuse::avail();
643  }
644 
649  inline bool operator!() const {
650  return !PagerReuse::avail();
651  }
652 
658  inline T *get(void) {
659  return static_cast<T*>(PagerReuse::get());
660  }
661 
668  inline T *create(void) {
669  return init<T>(static_cast<T*>(PagerReuse::get()));
670  }
671 
678  inline T *get(timeout_t timeout) {
679  return static_cast<T*>(PagerReuse::get(timeout));
680  }
681 
689  inline T *create(timeout_t timeout) {
690  return init<T>(static_cast<T*>(PagerReuse::get(timeout)));
691  }
692 
697  inline T *request(void) {
698  return static_cast<T*>(PagerReuse::request());
699  }
700 
705  inline void release(T *object) {
706  PagerReuse::release(object);
707  }
708 
714  inline T *operator*() {
715  return paged_reuse::get();
716  }
717 
723  inline operator T*() {
724  return paged_reuse::get();
725  }
726 };
727 
735 template<typename T, vectorsize_t S>
736 class vectorbuf : public MemVector
737 {
738 private:
739  char buffer[sizeof(array) + (S * sizeof(void *))];
740 
741 public:
745  inline vectorbuf() : MemVector(buffer, S) {}
746 
752  inline const T& at(int index) {
753  return immutable_cast<T&>(Vector::get(index));
754  }
755 
756  inline T& operator[](int index) {
757  return static_cast<T&>(Vector::get(index));
758  }
759 
765  inline T *operator()(vectorsize_t position) {
766  return static_cast<T *>(Vector::get(position));
767  }
768 
773  inline T *begin(void) {
774  return static_cast<T *>(Vector::begin());
775  }
776 
781  inline T *end(void) {
782  return static_cast<T *>(Vector::end());
783  }
784 
790  inline Vector &operator+(Vector &vector) {
791  Vector::add(vector); return static_cast<Vector &>(*this);
792  }
793 };
794 
795 } // namespace ucommon
796 
797 #endif
bool operator!() const
Test if no objects are available for reuse or the pager.
Definition: vector.h:649
T * get(void)
Get a typed object from the heap.
Definition: vector.h:557
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
Definition: access.h:280
vectorsize_t size(void) const
Get the effective allocation space used by the vector.
void release(ReusableObject *object)
Release resuable object.
Thread classes and sychronization objects.
T * operator*()
Get a typed object from the pager heap by type casting reference.
Definition: vector.h:714
A base class for reference counted objects.
Definition: object.h:56
void release(T *object)
Release (return) a typed object back to the heap for re-use.
Definition: vector.h:594
T * get(void)
Get a typed object from the pager heap.
Definition: vector.h:658
static const vectorsize_t npos
npos is a constant for an "invalid" position value.
Definition: vector.h:152
A mempager source of reusable objects.
Definition: vector.h:78
ObjectProtocol * operator()(vectorsize_t position)
Retrieve a member of the vector directly.
Definition: vector.h:321
T * create(void)
Create a typed object from the heap.
Definition: vector.h:566
A managed private heap for small allocations.
Definition: memory.h:192
T * create(void)
Get a typed object from the pager heap.
Definition: vector.h:668
void add(ObjectProtocol **list)
Add (append) a NULL terminated list of objects to the vector.
array_reuse(unsigned count, void *memory)
Create reusable objects of specific type in preallocated memory.
Definition: vector.h:525
array_reuse(unsigned count)
Create private heap of reusable objects of specified type.
Definition: vector.h:517
vectorbuf()
Construct fixed sized vector object in heap or stack.
Definition: vector.h:745
T * create(timeout_t timeout)
Create a typed object from the heap.
Definition: vector.h:689
T * end(void)
Get the last typed object pointer contained in the fixed vector.
Definition: vector.h:781
A managed vector for generic object pointers.
Definition: vector.h:109
void operator+=(Vector &vector)
Append into our existing vector from another vector.
Definition: vector.h:345
T * operator()(vectorsize_t position)
Retrieve a typed member of the fixed vector directly.
Definition: vector.h:765
T * create(timeout_t timeout)
Create a typed object from the heap.
Definition: vector.h:586
A redirection base class for the memory protocol.
Definition: protocols.h:104
T * operator*()
Get a typed object from the heap by pointer reference.
Definition: vector.h:612
A common base class for all managed objects.
Definition: protocols.h:545
T * begin(void)
Get the first typed object pointer contained in the fixed vector.
Definition: vector.h:773
Reusable objects for forming private heaps.
Definition: linked.h:158
bool operator!() const
Test if the entire heap has been allocated.
Definition: vector.h:540
ObjectProtocol * begin(void) const
Get the first object pointer contained in the vector.
Generic smart pointer class.
Definition: generics.h:54
An array of reusable objects.
Definition: vector.h:46
Vector & operator+(Vector &vector)
Concatenate into our existing vector from assignment list.
Definition: vector.h:353
ObjectProtocol * get(int index) const
Get an object pointer from a specified member of the vector.
Vector with fixed size member list.
Definition: vector.h:407
T &() limit(T &value, T &low, T &high)
Convenience macro to range restrict values.
Definition: generics.h:437
Common namespace for all ucommon objects.
Definition: access.h:47
T * begin(void)
Get the first typed object pointer contained in the vector.
Definition: vector.h:480
Vector & operator+(Vector &vector)
Concatenate typed vector in an expression.
Definition: vector.h:497
paged_reuse(mempager *pager, unsigned count)
Create a managed reusable typed object pool.
Definition: vector.h:634
ObjectProtocol * end(void) const
Get the last object pointer contained in the vector.
Class for resource bound memory pools between threads.
Definition: thread.h:704
const T & at(int index)
Get object pointer of specified type from fixed vector.
Definition: vector.h:752
Mempager managed type factory for pager pool objects.
Definition: memory.h:1345
Vector & operator+(Vector &vector)
Concatenate fixed typed vector in an expression.
Definition: vector.h:790
T * end(void)
Get the last typed object pointer contained in the vector.
Definition: vector.h:488
void set(Vector &vector)
Set (duplicate) an existing vector into our vector.
Definition: vector.h:287
A templated vector for a list of a specific Object subtype.
Definition: vector.h:445
T * request(void)
Request immediately next available typed object from the heap.
Definition: vector.h:548
vectorof()
Create an empty vector for specified type.
Definition: vector.h:451
vectorof(vectorsize_t size)
Create an empty vector of allocated size for specified type.
Definition: vector.h:457
void operator()(vectorsize_t position, ObjectProtocol *pointer)
Assign a member of the vector directly.
Definition: vector.h:312
ObjectProtocol * operator[](int index)
Return a pointer from the vector by array reference.
Definition: vector.h:303
T * operator()(vectorsize_t position)
Retrieve a typed member of the vector directly.
Definition: vector.h:472
T &() max(T &o1, T &o2)
Convenience function to return max of two objects.
Definition: generics.h:414
void release(T *object)
Release (return) a typed object back to the pager heap for re-use.
Definition: vector.h:705
void add(Vector &vector)
Add (append) an existing vector to our vector.
Definition: vector.h:295
void operator=(Vector &vector)
Assign an existing vector into our fixed vector list.
Definition: vector.h:433
T * request(void)
Request immediately next available typed object from the pager heap.
Definition: vector.h:697
An array of reusable types.
Definition: vector.h:510
A reusable private pool of reusable types.
Definition: vector.h:624
void operator=(Vector &vector)
Assign (copy) into our existing vector from another vector.
Definition: vector.h:337
void operator()(ObjectProtocol *pointer)
Append a member to the vector directly.
Definition: vector.h:329
Allocated vector list of a specified type.
Definition: vector.h:736