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));};
T * getLocked(void)
Used to get a typed object from the reuse pool when the mutex lock is already held.
T * request(void)
Request a typed reusable object from the free list or mapped space.
T & operator[](unsigned member)
Reference typed object of vector in mapped segment.
size_t len(void)
Get size of mapped segment.
void initialize(void)
Initialize typed data in mapped array.
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
void * addLock(void)
Add mapped space while holding lock for one object.
T * getTimed(timeout_t timeout)
Request a typed reusable object from the free list or mapped space.
Linked objects, lists, templates, and containers.
T * operator()(unsigned member)
Get typed pointer to member object of vector in mapped segment.
Generic non-recursive exclusive lock class.
void create(const char *name, size_t size=(size_t) 0)
Supporting function to construct a new or access an existing shared memory segment.
Template class to map typed vector into shared memory.
mapped_array(const char *name, unsigned number)
Construct mapped vector array of typed objects.
mapped_reuse(const char *name, unsigned number)
Construct mapped reuse array of typed objects.
Thread classes and sychronization objects.
caddr_t addr(void)
Get starting address of mapped segment.
A common string class and character string support functions.
Class for resource bound memory pools between threads.
bool operator!() const
Test if map is inactive.
volatile const T & operator[](unsigned member)
Reference typed member object in the mapped segment.
volatile const T * operator()(unsigned member)
Access typed member object in the mapped segment.
Reusable objects for forming private heaps.
void removeLocked(T *object)
Used to return a typed object to the reuse pool when the mutex lock is already held.
ObjectProtocol * copy(ObjectProtocol *object)
Convenience function to access object copy.
void release(T *object)
Used to release a typed object back to the reuse typed object pool.
Map a reusable allocator over a named shared memory segment.
Class to access a named mapped segment published from another process.
mapped_view(const char *name)
Map existing named memory segment.
unsigned max(void)
Get member size of typed objects that can be held in mapped vector.
T * pos(size_t member)
Get typed object from a specific member offset within the mapped segment.
unsigned long timeout_t
Typedef for millisecond timer values.
T * operator()(void)
Allocate mapped space for one object.
bool operator!() const
Check whether there are typed objects available to be allocated.
void initialize(void)
Initialize typed data in mapped array.
Construct or access a named section of memory.
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.
Template class to map typed reusable objects into shared memory heap.