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_ 59 class __EXPORT MappedMemory
66 __DELETE_COPY(MappedMemory);
81 void create(
const char *name,
size_t size = (
size_t)0);
90 MappedMemory(
const char *name,
size_t size);
98 MappedMemory(
const char *name);
103 virtual ~MappedMemory();
116 static void remove(
const char *name);
122 inline operator bool()
const 123 {
return (size != 0);}
129 inline bool operator!()
const 130 {
return (size == 0);}
139 void *sbrk(
size_t size);
146 void *offset(
size_t offset)
const;
156 bool copy(
size_t offset,
void *buffer,
size_t size)
const;
162 inline size_t len(
void)
const 169 inline caddr_t
addr(
void)
179 static void disable(
void);
191 class __EXPORT MappedReuse :
protected ReusableAllocator,
protected MappedMemory
198 __DELETE_DEFAULTS(MappedReuse);
201 MappedReuse(
size_t osize);
203 inline void create(
const char *fname,
unsigned count)
204 {MappedMemory::create(fname, count * objsize);}
219 MappedReuse(
const char *name,
size_t size,
unsigned count);
225 bool avail(
void)
const;
231 ReusableObject *request(
void);
238 ReusableObject *
get(void);
247 ReusableObject *getTimed(timeout_t timeout);
254 ReusableObject *getLocked(
void);
261 void removeLocked(ReusableObject *
object);
279 inline void create(
const char *fn,
unsigned members)
280 {MappedMemory::create(fn, members *
sizeof(T));}
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)));}
329 {
return *(operator()(member));}
335 inline unsigned max(
void)
const 336 {
return (
unsigned)(size /
sizeof(T));}
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 379 {
return MappedReuse::avail();}
386 {
return !MappedReuse::avail();}
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());}
459 {ReusableAllocator::release(
object);}
481 MappedMemory(name) {}
489 {
return static_cast<const T*
>(offset(member *
sizeof(T)));}
497 {
return *(operator()(member));}
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));}
mapped_view(const char *name)
Map existing named memory segment.
T * pos(size_t member)
Get typed object from a specific member offset within the mapped segment.
T * operator*()
Request a typed reusable object from the free list or mapped space by pointer reference.
A common string class and character string support functions.
void removeLocked(T *object)
Used to return a typed object to the reuse pool when the mutex lock is already held.
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.
T * operator()(void)
Allocate mapped space for one object.
void release(T *object)
Used to release a typed object back to the reuse typed object pool.
volatile const T * operator()(unsigned member)
Access typed member object in the mapped segment.
T copy(const T &src)
Convenience function to copy objects.
Map a reusable allocator over a named shared memory segment.
volatile const T & operator[](unsigned member)
Reference typed member object in the mapped segment.
Mutex mutex_t
Convenience type for using exclusive mutex locks.
void initialize(void)
Initialize typed data in mapped array.
T * operator()(unsigned member)
Get typed pointer to member object of vector in mapped segment.
mapped_reuse(const char *name, unsigned number)
Construct mapped reuse array of typed objects.
unsigned count(void) const
Get count of typed member objects held in this map.
unsigned max(void) const
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.
Common namespace for all ucommon objects.
void initialize(void)
Initialize typed data in mapped array.
Class to access a named mapped segment published from another process.
Linked objects, lists, templates, and containers.
const struct sockaddr * addr(Socket::address &address)
A convenience function to convert a socket address list into a socket address.
mapped_array(const char *name, unsigned number)
Construct mapped vector array of typed objects.
Thread classes and sychronization objects.
Template class to map typed reusable objects into shared memory heap.
T * getLocked(void)
Used to get a typed object from 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.
void * addLock(void)
Add mapped space while holding lock for one object.
T & operator[](unsigned member)
Reference typed object of vector in mapped segment.