27 #ifndef _UCOMMON_VECTOR_H_
28 #define _UCOMMON_VECTOR_H_
30 #ifndef _UCOMMON_THREAD_H_
34 typedef unsigned short vectorsize_t;
49 unsigned count,
limit, used;
54 ArrayReuse(
size_t objsize,
unsigned c,
void *memory);
80 unsigned limit, count;
115 vectorsize_t
max, len;
119 array(vectorsize_t size);
125 void inc(vectorsize_t adj);
126 void dec(vectorsize_t adj);
132 array *create(vectorsize_t size)
const;
135 virtual void cow(vectorsize_t adj = 0);
138 friend class Vector::array;
151 static const vectorsize_t
npos;
162 Vector(vectorsize_t size);
184 vectorsize_t len(
void)
const;
191 vectorsize_t size(
void)
const;
206 vectorsize_t
get(
void **mem, vectorsize_t
max)
const;
235 void split(vectorsize_t position);
243 void rsplit(vectorsize_t position);
280 virtual bool resize(vectorsize_t size);
287 {set(vector.list());};
294 {add(vector.list());};
301 {
return get(index);};
309 {set(position, pointer);};
317 {
return get(position);};
331 {set(vector.list());};
338 {add(vector.list());};
345 {add(vector.list());
return *
this;};
359 void operator^=(
Vector &vector);
375 void operator+=(vectorsize_t count);
381 void operator-=(vectorsize_t count);
388 static vectorsize_t size(
void **list);
399 bool resize(vectorsize_t size);
400 void cow(vectorsize_t adj = 0);
403 friend class Vector::array;
447 inline T& operator[](
int index)
448 {
return static_cast<T&
>(Vector::get(index));};
450 inline const T& at(
int index)
451 {
return static_cast<const T&
>(Vector::get(index));};
459 {
return static_cast<T *
>(Vector::get(position));};
466 {
return static_cast<T *
>(Vector::begin());};
473 {
return static_cast<T *
>(Vector::end());};
481 {Vector::add(vector);
return static_cast<Vector &
>(*this);};
513 inline operator bool()
const
528 {
return static_cast<T*
>(ArrayReuse::request());};
536 {
return static_cast<T*
>(ArrayReuse::get());};
544 {
return init<T>(
static_cast<T*
>(ArrayReuse::get()));};
553 {
return static_cast<T*
>(ArrayReuse::get(timeout));};
562 {
return init<T>(
static_cast<T*
>(ArrayReuse::get(timeout)));};
577 {
return array_reuse::get();};
585 {
return array_reuse::get();};
612 inline operator bool()
const
613 {
return PagerReuse::avail();};
620 {
return !PagerReuse::avail();};
628 {
return static_cast<T*
>(PagerReuse::get());};
637 {
return init<T>(
static_cast<T*
>(PagerReuse::get()));};
646 {
return static_cast<T*
>(PagerReuse::get(timeout));};
656 {
return init<T>(
static_cast<T*
>(PagerReuse::get(timeout)));};
663 {
return static_cast<T*
>(PagerReuse::request());};
678 {
return paged_reuse::get();};
686 {
return paged_reuse::get();};
696 template<
typename T, vector
size_t S>
700 char buffer[
sizeof(array) + (S *
sizeof(
void *))];
713 inline const T&
at(
int index)
714 {
return static_cast<const T&
>(Vector::get(index));};
716 inline T& operator[](
int index)
717 {
return static_cast<T&
>(Vector::get(index));};
725 {
return static_cast<T *
>(Vector::get(position));};
732 {
return static_cast<T *
>(Vector::begin());};
739 {
return static_cast<T *
>(Vector::end());};
747 {Vector::add(vector);
return static_cast<Vector &
>(*this);};
Vector & operator+(Vector &vector)
Concatenate typed vector in an expression.
T * operator()(vectorsize_t position)
Retrieve a typed member of the fixed vector directly.
bool operator!() const
Test if no objects are available for reuse or the pager.
const T & at(int index)
Get object pointer of specified type from fixed vector.
T * end(void)
Get the last typed object pointer contained in the fixed vector.
void set(Vector &vector)
Set (duplicate) an existing vector into our vector.
T * operator*()
Get a typed object from the pager heap by type casting reference.
A base class for reference counted objects.
void release(T *object)
Release (return) a typed object back to the heap for re-use.
void operator++(void)
Increase retention operator.
T * begin(void)
Get the first typed object pointer contained in the fixed vector.
T * operator()(vectorsize_t position)
Retrieve a typed member of the vector directly.
A mempager source of reusable objects.
T * create(void)
Create a typed object from the heap.
A managed private heap for small allocations.
vectorof(vectorsize_t size)
Create an empty vector of allocated size for specified type.
T * create(void)
Get a typed object from the pager heap.
void operator()(vectorsize_t position, ObjectProtocol *pointer)
Assign a member of the vector directly.
array_reuse(unsigned count, void *memory)
Create reusable objects of specific type in preallocated memory.
A templated vector for a list of a specific Object subtype.
T &() max(T &o1, T &o2)
Convenience function to return max of two objects.
array_reuse(unsigned count)
Create private heap of reusable objects of specified type.
void add(Vector &vector)
Add (append) an existing vector to our vector.
void operator--(void)
Decrease retention operator.
T * create(timeout_t timeout)
Create a typed object from the heap.
void operator()(ObjectProtocol *pointer)
Append a member to the vector directly.
T * create(timeout_t timeout)
Create a typed object from the heap.
A redirection base class for the memory protocol.
static const vectorsize_t npos
npos is a constant for an "invalid" position value.
T * operator*()
Get a typed object from the heap by pointer reference.
virtual void dealloc(void)
Dealloc object no longer referenced.
A common base class for all managed objects.
Allocated vector list of a specified type.
Vector & operator+(Vector &vector)
Concatenate fixed typed vector in an expression.
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
Reusable objects for forming private heaps.
bool operator!() const
Test if the entire heap has been allocated.
T &() limit(T &value, T &low, T &high)
Convenience macro to range restrict values.
Generic smart pointer class.
An array of reusable objects.
vectorof()
Create an empty vector for specified type.
ObjectProtocol * operator[](int index)
Return a pointer from the vector by array reference.
vectorbuf()
Construct fixed sized vector object in heap or stack.
virtual bool resize(vectorsize_t size)
Re-size & re-allocate the total (allocated) size of the vector.
Vector with fixed size member list.
paged_reuse(mempager *pager, unsigned count)
Create a managed reusable typed object pool.
Thread classes and sychronization objects.
void operator=(Vector &vector)
Assign (copy) into our existing vector from another vector.
Class for resource bound memory pools between threads.
void release(void)
Decrease reference count when released.
Mempager managed type factory for pager pool objects.
unsigned long timeout_t
Typedef for millisecond timer values.
T * request(void)
Request immediately next available typed object from the heap.
A managed vector for generic object pointers.
ObjectProtocol * operator()(vectorsize_t position)
Retrieve a member of the vector directly.
void release(T *object)
Release (return) a typed object back to the pager heap for re-use.
void operator=(Vector &vector)
Assign an existing vector into our fixed vector list.
T * request(void)
Request immediately next available typed object from the pager heap.
An array of reusable types.
A reusable private pool of reusable types.
Vector & operator+(Vector &vector)
Concatenate into our existing vector from assignment list.
T * end(void)
Get the last typed object pointer contained in the vector.
void set(vectorsize_t position, ObjectProtocol *pointer)
Set a member of the vector to an object.
T * begin(void)
Get the first typed object pointer contained in the vector.
void operator+=(Vector &vector)
Append into our existing vector from another vector.