30#ifndef _UCOMMON_MAPPED_H_
31#define _UCOMMON_MAPPED_H_
33#ifndef _UCOMMON_LINKED_H_
37#ifndef _UCOMMON_THREAD_H_
41#ifndef _UCOMMON_STRING_H_
59class __EXPORT MappedMemory
66 __DELETE_COPY(MappedMemory);
81 void create(
const char *name,
size_t size = (
size_t)0);
122 inline operator bool()
const
123 {
return (size != 0);}
130 {
return (size == 0);}
162 inline size_t len(
void)
const
191class __EXPORT MappedReuse :
protected ReusableAllocator,
protected MappedMemory
198 __DELETE_DEFAULTS(MappedReuse);
201 MappedReuse(
size_t osize);
203 inline void create(
const char *fname,
unsigned count)
271class mapped_array :
public MappedMemory
274 __DELETE_COPY(mapped_array);
277 inline mapped_array() : MappedMemory() {}
279 inline void create(
const char *fn,
unsigned members)
292 MappedMemory(name, number * sizeof(T)) {}
299 {
new((caddr_t)
offset(0)) T[size /
sizeof(T)];}
306 {
return sbrk(
sizeof(T));}
314 {
return static_cast<T*
>(
offset(member *
sizeof(T)));}
321 {
return static_cast<T*
>(
sbrk(
sizeof(T)));}
335 inline unsigned max(
void)
const
336 {
return (
unsigned)(size /
sizeof(T));}
347class mapped_reuse :
public MappedReuse
350 __DELETE_COPY(mapped_reuse);
353 inline mapped_reuse() :
354 MappedReuse(
sizeof(T)) {}
365 MappedReuse(name, sizeof(T), number) {}
372 {
new((caddr_t)
pos(0)) T[size /
sizeof(T)];}
378 inline operator bool()
const
409 inline T *
pos(
size_t member)
469class mapped_view :
protected MappedMemory
472 __DELETE_DEFAULTS(mapped_view);
481 MappedMemory(name) {}
489 {
return static_cast<const T*
>(
offset(member *
sizeof(T)));}
499 inline volatile const T *get(
unsigned member)
500 {
return static_cast<const T*
>(
offset(member *
sizeof(T)));}
502 inline void copy(
unsigned member, T& buffer)
510 {
return (
unsigned)(size /
sizeof(T));}
Linked objects, lists, templates, and containers.
Common namespace for all ucommon objects.
Mutex mutex_t
Convenience type for using exclusive mutex locks.
Reusable objects for forming private heaps.
static void remove(const char *name)
Destroy a previously existing memory segment under the specified name.
bool copy(size_t offset, void *buffer, size_t size) const
Copy memory from specific offset within the mapped memory segment.
void * offset(size_t offset) const
Get memory from a specific offset within the mapped memory segment.
caddr_t addr(void)
Get starting address of mapped segment.
virtual ~MappedMemory()
Unmap memory segment.
void * sbrk(size_t size)
Extend size of managed heap on shared memory segment.
void release(void)
Unmap memory segment.
bool operator!() const
Test if map is inactive.
void create(const char *name, size_t size=(size_t) 0)
Supporting function to construct a new or access an existing shared memory segment.
MappedMemory(const char *name, size_t size)
Construct a read/write access mapped shared segment of memory of a known size.
MappedMemory(const char *name)
Provide read-only mapped access to an existing named shared memory segment.
size_t len(void) const
Get size of mapped segment.
static void disable(void)
An API that allows "disabling" of publishing shared memory maps.
MappedReuse(const char *name, size_t size, unsigned count)
Construct a named memory segment for use with managed fixed size reusable objects.
ReusableObject * getTimed(timeout_t timeout)
Request a reusable object from the free list or mapped space.
void removeLocked(ReusableObject *object)
Used to return an object to the reuse pool when the mutex lock is already held.
ReusableObject * getLocked(void)
Used to get an object from the reuse pool when the mutex lock is already held.
ReusableObject * request(void)
Request a reusable object from the free list or mapped space.
ReusableObject * get(void)
Request a reusable object from the free list or mapped space.
bool avail(void) const
Check whether there are objects available to be allocated.
T * operator()(unsigned member)
Get typed pointer to member object of vector in mapped segment.
T * operator()(void)
Allocate mapped space for one object.
T & operator[](unsigned member)
Reference typed object of vector in mapped segment.
mapped_array(const char *name, unsigned number)
Construct mapped vector array of typed objects.
unsigned max(void) const
Get member size of typed objects that can be held in mapped vector.
void initialize(void)
Initialize typed data in mapped array.
void * addLock(void)
Add mapped space while holding lock for one object.
T * get(void)
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.
void release(T *object)
Used to release a typed object back to the reuse typed object pool.
void initialize(void)
Initialize typed data in mapped array.
T * request(void)
Request a typed reusable object from the free list or mapped space.
T * getLocked(void)
Used to get a typed object from the reuse pool when the mutex lock is already held.
T * pos(size_t member)
Get typed object from a specific member offset within the mapped segment.
mapped_reuse(const char *name, unsigned number)
Construct mapped reuse array of typed objects.
T * getTimed(timeout_t timeout)
Request a typed reusable object from the free list or mapped space.
void removeLocked(T *object)
Used to return a typed object to the reuse pool when the mutex lock is already held.
T * operator*()
Request a typed reusable object from the free list or mapped space by pointer reference.
mapped_view(const char *name)
Map existing named memory segment.
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.
unsigned count(void) const
Get count of typed member objects held in this map.
void release(ReusableObject *object)
Release resuable object.
A common string class and character string support functions.
Thread classes and sychronization objects.