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);};
T * create(timeout_t timeout)
Create a typed object from the heap.
vectorbuf()
Construct fixed sized vector object in heap or stack.
A reusable private pool of reusable types.
paged_reuse(mempager *pager, unsigned count)
Create a managed reusable typed object pool.
A common base class for all managed objects.
void set(Vector &vector)
Set (duplicate) an existing vector into our vector.
Vector with fixed size member list.
An array of reusable objects.
Generic smart pointer class.
T * operator*()
Get a typed object from the heap by pointer reference.
unsigned long timeout_t
Typedef for millisecond timer values.
A managed private heap for small allocations.
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.
T * end(void)
Get the last typed object pointer contained in the fixed vector.
void operator--(void)
Decrease retention operator.
void operator()(vectorsize_t position, ObjectProtocol *pointer)
Assign a member of the vector directly.
T &() limit(T &value, T &low, T &high)
Convenience macro to range restrict values.
Mempager managed type factory for pager pool objects.
vectorof(vectorsize_t size)
Create an empty vector of allocated size for specified type.
Vector & operator+(Vector &vector)
Concatenate fixed typed vector in an expression.
Vector & operator+(Vector &vector)
Concatenate typed vector in an expression.
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
void operator()(ObjectProtocol *pointer)
Append a member to the vector directly.
T * create(timeout_t timeout)
Create a typed object from the heap.
A templated vector for a list of a specific Object subtype.
void release(T *object)
Release (return) a typed object back to the pager heap for re-use.
T * begin(void)
Get the first typed object pointer contained in the vector.
A mempager source of reusable objects.
T * create(void)
Create a typed object from the heap.
T * begin(void)
Get the first typed object pointer contained in the fixed vector.
T * create(void)
Get a typed object from the pager heap.
A redirection base class for the memory protocol.
An array of reusable types.
Vector & operator+(Vector &vector)
Concatenate into our existing vector from assignment list.
array_reuse(unsigned count)
Create private heap of reusable objects of specified type.
Thread classes and sychronization objects.
void release(T *object)
Release (return) a typed object back to the heap for re-use.
void operator++(void)
Increase retention operator.
T * operator()(vectorsize_t position)
Retrieve a typed member of the fixed vector directly.
Reusable objects for forming private heaps.
void operator=(Vector &vector)
Assign (copy) into our existing vector from another vector.
T * operator()(vectorsize_t position)
Retrieve a typed member of the vector directly.
bool operator!() const
Test if no objects are available for reuse or the pager.
virtual bool resize(vectorsize_t size)
Re-size & re-allocate the total (allocated) size of the vector.
void release(void)
Decrease reference count when released.
A base class for reference counted objects.
bool operator!() const
Test if the entire heap has been allocated.
T * request(void)
Request immediately next available typed object from the heap.
Allocated vector list of a specified type.
T &() max(T &o1, T &o2)
Convenience function to return max of two objects.
ObjectProtocol * operator[](int index)
Return a pointer from the vector by array reference.
T * operator*()
Get a typed object from the pager heap by type casting reference.
T * end(void)
Get the last typed object pointer contained in the vector.
vectorof()
Create an empty vector for specified type.
void add(Vector &vector)
Add (append) an existing vector to our vector.
const T & at(int index)
Get object pointer of specified type from fixed vector.
static const vectorsize_t npos
npos is a constant for an "invalid" position value.
A managed vector for generic object pointers.
array_reuse(unsigned count, void *memory)
Create reusable objects of specific type in preallocated memory.
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.
void operator+=(Vector &vector)
Append into our existing vector from another vector.
Class for resource bound memory pools between threads.