Rudiments
Public Member Functions | Static Public Member Functions | List of all members
sharedmemory Class Reference

Public Member Functions

 sharedmemory ()
 
 ~sharedmemory ()
 
bool create (key_t key, size_t size, mode_t permissions)
 
bool attach (key_t key, size_t size)
 
bool createOrAttach (key_t key, size_t size, mode_t permissions)
 
void dontRemove ()
 
bool forceRemove ()
 
int32_t getId () const
 
void * getPointer () const
 
bool setUserName (const char *username)
 
bool setGroupName (const char *groupname)
 
bool setUserId (uid_t uid)
 
bool setGroupId (gid_t gid)
 
bool setPermissions (mode_t permissions)
 
const char * getUserName ()
 
const char * getGroupName ()
 
uid_t getUserId ()
 
gid_t getGroupId ()
 
mode_t getPermissions ()
 

Static Public Member Functions

static bool supported ()
 

Detailed Description

Shared memory segments allow multiple processes to access a common address space.

Shared memory can be used for interprocess communication and is generally faster than using fifo's or unix sockets.

To synchronize access to shared memory, use the semaphoreset class.

A shared memory segment is owned by a user and group and has access permissions just like a file.

Constructor & Destructor Documentation

◆ sharedmemory()

sharedmemory::sharedmemory ( )

Creates an instance of the sharedmemory class.

◆ ~sharedmemory()

sharedmemory::~sharedmemory ( )

Deletes this instance of the sharedmemory class. Removes the shared memory segment if it was created by this class. If it was just attached to, it is not removed.

Member Function Documentation

◆ attach()

bool sharedmemory::attach ( key_t  key,
size_t  size 
)

Attaches to a shared memory segment of "size" bytes, identified by "key".

◆ create()

bool sharedmemory::create ( key_t  key,
size_t  size,
mode_t  permissions 
)

Creates a shared memory segment of "size" bytes, identified by "key". "key" should be generated using the ftok function. "permissions" sets the access permissions for the segment.

◆ createOrAttach()

bool sharedmemory::createOrAttach ( key_t  key,
size_t  size,
mode_t  permissions 
)

Attempts to create the shared memory segment identified by "key". If this fails, it attempts to attach to a shared memory segment identified by "key".

◆ dontRemove()

void sharedmemory::dontRemove ( )

Instructs the destructor not to remove the shared memory segment if it was created during a call to create() or createOrAttach(). This is useful if an application creates a shared memory segment then forks and wants to delete the shared memory segment in the forked process but does not want the segment removed from the system.

◆ forceRemove()

bool sharedmemory::forceRemove ( )

Instructs the destructor to remove the shared memory segment whether it was created or just attached to.

◆ getGroupId()

gid_t sharedmemory::getGroupId ( )

Returns the group id of the group that owns this shared memory segment.

◆ getGroupName()

const char* sharedmemory::getGroupName ( )

Returns the name of the group that owns this shared memory segment

Note that getGroupName() uses the groupentry class. If you are using this method in a multithreaded application, you may need to supply the groupentry class a mutex. See groupentry.h for more detail.

◆ getId()

int32_t sharedmemory::getId ( ) const

Returns the internal id for the shared memory segment.

◆ getPermissions()

mode_t sharedmemory::getPermissions ( )

Returns the access permissions for this shared memory segment.

◆ getPointer()

void* sharedmemory::getPointer ( ) const

Returns a pointer to the shared memory segment. Data may be read from or written to the segment using this pointer.

◆ getUserId()

uid_t sharedmemory::getUserId ( )

Returns the user id of the user that owns this shared memory segment.

◆ getUserName()

const char* sharedmemory::getUserName ( )

Returns the name of the user that owns this shared memory segment

Note that getUserName() uses the userentry class. If you are using this method in a multithreaded application, you may need to supply the userentry class a mutex. See userentry.h for more detail.

◆ setGroupId()

bool sharedmemory::setGroupId ( gid_t  gid)

Makes this shared memory segment owned by the group identified by gid.

◆ setGroupName()

bool sharedmemory::setGroupName ( const char *  groupname)

Makes this shared memory segment owned by the group "groupname".

Note that setGroupName() uses the groupentry class. If you are using this method in a multithreaded application, you may need to supply the groupentry class a mutex. See groupentry.h for more detail.

◆ setPermissions()

bool sharedmemory::setPermissions ( mode_t  permissions)

Sets the access permissions for this shared memory segment to "permissions".

◆ setUserId()

bool sharedmemory::setUserId ( uid_t  uid)

Makes this shared memory segment owned by the user identified by uid.

◆ setUserName()

bool sharedmemory::setUserName ( const char *  username)

Makes this shared memory segment owned by the user "username".

Note that setUserName() uses the userentry class. If you are using this method in a multithreaded application, you may need to supply the userentry class a mutex. See userentry.h for more detail.

◆ supported()

static bool sharedmemory::supported ( )
static

Returns true if the platform supports shared memory and false otherwise.