29 #ifndef _UCOMMON_MAPPED_H_
30 #define _UCOMMON_MAPPED_H_
32 #ifndef _UCOMMON_LINKED_H_
36 #ifndef _UCOMMON_THREAD_H_
40 #ifndef _UCOMMON_STRING_H_
78 void create(
const char *name,
size_t size = (
size_t)0);
84 virtual void *invalid(
void)
const;
89 virtual void fault(
void)
const;
124 static void remove(
const char *name);
130 inline operator bool()
const
131 {
return (size != 0);};
138 {
return (size == 0);};
147 void *sbrk(
size_t size);
154 void *offset(
size_t offset)
const;
164 bool copy(
size_t offset,
void *buffer,
size_t size)
const;
187 static void disable(
void);
209 inline void create(
const char *fname,
unsigned count)
225 MappedReuse(
const char *name,
size_t size,
unsigned count);
282 inline void create(
const char *fn,
unsigned members)
283 {MappedMemory::create(fn, members *
sizeof(T));};
302 {
new((caddr_t)offset(0)) T[size /
sizeof(T)];};
309 {
return sbrk(
sizeof(T));};
317 {
return static_cast<T*
>(offset(member *
sizeof(T)));}
324 {
return static_cast<T*
>(sbrk(
sizeof(T)));};
332 {
return *(operator()(member));};
339 {
return (
unsigned)(size /
sizeof(T));};
372 {
new((caddr_t)pos(0)) T[size /
sizeof(T)];};
378 inline operator bool()
const
379 {
return MappedReuse::avail();};
386 {
return !MappedReuse::avail();};
394 {
return mapped_reuse::get();};
402 {
return mapped_reuse::get();};
409 inline T *
pos(
size_t member)
410 {
return static_cast<T*
>(MappedReuse::offset(member *
sizeof(T)));};
418 {
return static_cast<T*
>(MappedReuse::get());};
428 {
return static_cast<T*
>(MappedReuse::getTimed(timeout));};
436 {
return static_cast<T*
>(MappedReuse::request());};
444 {MappedReuse::removeLocked(
object);};
452 {
return static_cast<T*
>(MappedReuse::getLocked());};
486 {
return static_cast<const T*
>(offset(member *
sizeof(T)));}
494 {
return *(operator()(member));};
496 inline volatile const T *
get(
unsigned member)
497 {
return static_cast<const T*
>(offset(member *
sizeof(T)));};
499 inline void copy(
unsigned member, T& buffer)
507 {
return (
unsigned)(size /
sizeof(T));};
mapped_view(const char *name)
Map existing named memory segment.
mapped_reuse(const char *name, unsigned number)
Construct mapped reuse array of typed objects.
size_t len(void)
Get size of mapped segment.
Class for resource bound memory pools between threads.
bool operator!() const
Test if map is inactive.
T & operator[](unsigned member)
Reference typed object of vector in mapped segment.
Linked objects, lists, templates, and containers.
Template class to map typed vector into shared memory.
void release(T *object)
Used to release a typed object back to the reuse typed object pool.
T * getLocked(void)
Used to get a typed object from the reuse pool when the mutex lock is already held.
void * addLock(void)
Add mapped space while holding lock for one object.
void removeLocked(T *object)
Used to return a typed object to the reuse pool when the mutex lock is already held.
T * getTimed(timeout_t timeout)
Request a typed reusable object from the free list or mapped space.
bool operator!() const
Check whether there are typed objects available to be allocated.
mapped_array(const char *name, unsigned number)
Construct mapped vector array of typed objects.
Class to access a named mapped segment published from another process.
caddr_t addr(void)
Get starting address of mapped segment.
T * pos(size_t member)
Get typed object from a specific member offset within the mapped segment.
void create(const char *name, size_t size=(size_t) 0)
Supporting function to construct a new or access an existing shared memory segment.
A common string class and character string support functions.
T * operator*()
Request a typed reusable object from the free list or mapped space by pointer reference.
unsigned count(void)
Get count of typed member objects held in this map.
ObjectProtocol * copy(ObjectProtocol *object)
Convenience function to access object copy.
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
unsigned long timeout_t
Typedef for millisecond timer values.
void initialize(void)
Initialize typed data in mapped array.
T * operator()(unsigned member)
Get typed pointer to member object of vector in mapped segment.
Thread classes and sychronization objects.
Reusable objects for forming private heaps.
volatile const T & operator[](unsigned member)
Reference typed member object in the mapped segment.
Template class to map typed reusable objects into shared memory heap.
Map a reusable allocator over a named shared memory segment.
volatile const T * operator()(unsigned member)
Access typed member object in the mapped segment.
Generic non-recursive exclusive lock class.
T * operator()(void)
Allocate mapped space for one object.
unsigned max(void)
Get member size of typed objects that can be held in mapped vector.
T * request(void)
Request a typed reusable object from the free list or mapped space.
void initialize(void)
Initialize typed data in mapped array.
Construct or access a named section of memory.