27 #ifndef _UCOMMON_VECTOR_H_
28 #define _UCOMMON_VECTOR_H_
30 #ifndef _UCOMMON_THREAD_H_
36 typedef unsigned short vectorsize_t;
49 unsigned count,
limit, used;
54 ArrayReuse(
size_t objsize,
unsigned c,
void *memory);
63 bool avail(
void)
const;
80 unsigned limit, count;
87 bool avail(
void)
const;
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());}
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)
450 inline const T& at(
int index)
451 {
return static_cast<const T&
>(
Vector::get(index));}
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)));}
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());}
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)
T &() limit(T &value, T &low, T &high)
Convenience macro to range restrict values.
vectorbuf()
Construct fixed sized vector object in heap or stack.
void operator+=(Vector &vector)
Append into our existing vector from another vector.
T * get(void)
Get a typed object from the heap.
T * create(void)
Get a typed object from the pager heap.
vectorof()
Create an empty vector for specified type.
A common base class for all managed objects.
A base class for reference counted objects.
T * get(void)
Get a typed object from the pager heap.
void release(T *object)
Release (return) a typed object back to the heap for re-use.
T * operator*()
Get a typed object from the pager heap by type casting reference.
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
T * create(void)
Create a typed object from the heap.
A redirection base class for the memory protocol.
void add(Vector &vector)
Add (append) an existing vector to our vector.
array_reuse(unsigned count, void *memory)
Create reusable objects of specific type in preallocated memory.
Allocated vector list of a specified type.
Common namespace for all ucommon objects.
array_reuse(unsigned count)
Create private heap of reusable objects of specified type.
void operator()(vectorsize_t position, ObjectProtocol *pointer)
Assign a member of the vector directly.
T * create(timeout_t timeout)
Create a typed object from the heap.
bool operator!() const
Test if no objects are available for reuse or the pager.
Vector with fixed size member list.
ObjectProtocol * end(void) const
Get the last object pointer contained in the vector.
void set(Vector &vector)
Set (duplicate) an existing vector into our vector.
Generic smart pointer class.
Mempager managed type factory for pager pool objects.
T * create(timeout_t timeout)
Create a typed object from the heap.
T * operator*()
Get a typed object from the heap by pointer reference.
A templated vector for a list of a specific Object subtype.
A managed vector for generic object pointers.
paged_reuse(mempager *pager, unsigned count)
Create a managed reusable typed object pool.
static const vectorsize_t npos
npos is a constant for an "invalid" position value.
Thread classes and sychronization objects.
ObjectProtocol * get(int index) const
Get an object pointer from a specified member of the vector.
void release(T *object)
Release (return) a typed object back to the pager heap for re-use.
void release(ReusableObject *object)
Release resuable object.
T * end(void)
Get the last typed object pointer contained in the vector.
Class for resource bound memory pools between threads.
bool operator!() const
Test if the entire heap has been allocated.
vectorsize_t size(void) const
Get the effective allocation space used by the vector.
ObjectProtocol * operator[](int index)
Return a pointer from the vector by array reference.
ObjectProtocol * begin(void) const
Get the first object pointer contained in the vector.
T &() max(T &o1, T &o2)
Convenience function to return max of two objects.
void operator()(ObjectProtocol *pointer)
Append a member to the vector directly.
An array of reusable objects.
ObjectProtocol * operator()(vectorsize_t position)
Retrieve a member of the vector directly.
T * operator()(vectorsize_t position)
Retrieve a typed member of the fixed vector directly.
T * operator()(vectorsize_t position)
Retrieve a typed member of the vector directly.
T * end(void)
Get the last typed object pointer contained in the fixed vector.
Reusable objects for forming private heaps.
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.
T * begin(void)
Get the first typed object pointer contained in the fixed vector.
A reusable private pool of reusable types.
void operator=(Vector &vector)
Assign (copy) into our existing vector from another vector.
T * request(void)
Request immediately next available typed object from the pager heap.
T * begin(void)
Get the first typed object pointer contained in the vector.
T * request(void)
Request immediately next available typed object from the heap.
const T & at(int index)
Get object pointer of specified type from fixed vector.
A managed private heap for small allocations.
unsigned long timeout_t
Typedef for millisecond timer values.
An array of reusable types.
void operator=(Vector &vector)
Assign an existing vector into our fixed vector list.
A mempager source of reusable objects.
Vector & operator+(Vector &vector)
Concatenate typed vector in an expression.
Vector & operator+(Vector &vector)
Concatenate into our existing vector from assignment list.
void add(ObjectProtocol **list)
Add (append) a NULL terminated list of objects to the vector.