20 #ifndef __JackShmMem__    21 #define __JackShmMem__    24 #include "JackError.h"    25 #include "JackCompilerDeps.h"    31 #include "JackShmMem_os.h"    36 void LockMemoryImp(
void* ptr, 
size_t size);
    37 void InitLockMemoryImp(
void* ptr, 
size_t size);
    38 void UnlockMemoryImp(
void* ptr, 
size_t size);
    40 void UnlockAllMemory();
    58         void* 
operator new(
size_t size)
    61             return calloc(1, size);
    64         void operator delete(
void* ptr, 
size_t size)
    71             LockMemoryImp(
this, fSize);
    76             UnlockMemoryImp(
this, fSize);
   102         char* GetShmAddress()
   104             return (
char*)fInfo.ptr.attached_at;
   109             LockMemoryImp(
this, fInfo.size);
   114             UnlockMemoryImp(
this, fInfo.size);
   135         void* 
operator new(
size_t size);
   136         void* 
operator new(
size_t size, 
void* memory);
   138         void operator delete(
void* p, 
size_t size);
   139                 void operator delete(
void* p);
   156         void Init(
int index, 
const char* server_name = JACK_DEFAULT_SERVER_NAME)
   158             if (fInfo.index < 0 && index >= 0) {
   159                 jack_log(
"JackShmReadWritePtr::Init %ld %d", index, fInfo.index);
   160                 if (jack_initialize_shm(server_name) < 0) {
   161                     throw std::bad_alloc();
   164                 if (jack_attach_lib_shm(&fInfo)) {
   165                     throw std::bad_alloc();
   167                 GetShmAddress()->LockMemory();
   178             fInfo.ptr.attached_at = (
char*)NULL;
   183             Init(index, server_name);
   189                jack_error(
"JackShmReadWritePtr::~JackShmReadWritePtr - Init not done for %d, skipping unlock", fInfo.index);                              
   192             if (fInfo.index >= 0) {
   193                 jack_log(
"JackShmReadWritePtr::~JackShmReadWritePtr %d", fInfo.index);
   194                 GetShmAddress()->UnlockMemory();
   195                 jack_release_lib_shm(&fInfo);
   200         T* operator->()
 const   202             return (T*)fInfo.ptr.attached_at;
   207             return (T*)fInfo.ptr.attached_at;
   216         void SetShmIndex(
int index, 
const char* server_name)
   218             Init(index, server_name);
   228             return (T*)fInfo.ptr.attached_at;
   245         void Init(
int index, 
const char* server_name = JACK_DEFAULT_SERVER_NAME)
   247             if (fInfo.index < 0 && index >= 0) {
   248                 jack_log(
"JackShmReadWritePtr1::Init %ld %d", index, fInfo.index);
   249                 if (jack_initialize_shm(server_name) < 0) {
   250                     throw std::bad_alloc();
   253                 if (jack_attach_lib_shm(&fInfo)) {
   254                     throw std::bad_alloc();
   256                 GetShmAddress()->LockMemory();
   263                 jack_destroy_shm(&fInfo);
   273             fInfo.ptr.attached_at = NULL;
   278             Init(index, server_name);
   284                jack_error(
"JackShmReadWritePtr1::~JackShmReadWritePtr1 - Init not done for %d, skipping unlock", fInfo.index);                              
   287             if (fInfo.index >= 0) {
   288                 jack_log(
"JackShmReadWritePtr1::~JackShmReadWritePtr1 %d", fInfo.index);
   289                 GetShmAddress()->UnlockMemory();
   290                 jack_release_lib_shm(&fInfo);
   295         T* operator->()
 const   297             return (T*)fInfo.ptr.attached_at;
   302             return (T*)fInfo.ptr.attached_at;
   311         void SetShmIndex(
int index, 
const char* server_name)
   313             Init(index, server_name);
   323             return (T*)fInfo.ptr.attached_at;
   340         void Init(
int index, 
const char* server_name = JACK_DEFAULT_SERVER_NAME)
   342             if (fInfo.index < 0 && index >= 0) {
   343                 jack_log(
"JackShmPtrRead::Init %ld %d", index, fInfo.index);
   344                 if (jack_initialize_shm(server_name) < 0) {
   345                     throw std::bad_alloc();
   348                 if (jack_attach_lib_shm_read(&fInfo)) {
   349                     throw std::bad_alloc();
   351                 GetShmAddress()->LockMemory();
   362             fInfo.ptr.attached_at = NULL;
   367             Init(index, server_name);
   373                jack_error(
"JackShmReadPtr::~JackShmReadPtr - Init not done for %ld, skipping unlock", fInfo.index);                              
   376             if (fInfo.index >= 0) {
   377                 jack_log(
"JackShmPtrRead::~JackShmPtrRead %ld", fInfo.index);
   378                 GetShmAddress()->UnlockMemory();
   379                 jack_release_lib_shm(&fInfo);
   384         T* operator->()
 const   386             return (T*)fInfo.ptr.attached_at;
   391             return (T*)fInfo.ptr.attached_at;
   400         void SetShmIndex(
int index, 
const char* server_name)
   402             Init(index, server_name);
   412             return (T*)fInfo.ptr.attached_at;
 
Pointer on shared memory segment in the client side. 
SERVER_EXPORT void jack_error(const char *fmt,...)
A class which objects possibly want to be allocated in shared memory derives from this class...
Pointer on shared memory segment in the client side. 
Pointer on shared memory segment in the client side: destroy the segment (used client control) ...
The base class for shared memory management. 
SERVER_EXPORT void jack_log(const char *fmt,...)