File array.hpp¶

namespace shared_memory¶

All templated types in this namespaces are elementary types: int, double, float, char*, …

Functions

void clear_array(std::string segment_id)¶

wipe the shared memory segment created by an instance of shared_memory::array, including mutexes, if any.

If there are no memory segment of this id, there will be no effect. If shared_memory::array instances are pointing to the wiped out segment, their get and set functions may hang indefinitely.

template<typename T, int SIZE = 0> class array : public internal::array_members<T, SIZE>

#include <array.hpp>

Implement a shared array stored on a shared memory segment.

Items hosted by the array may be of (1) fundamental type (e.g. int, double, char), (2) array of fundamental type (e.g. int[10]); or (3) instances of a class implementing a serializable function (see shared_memory::serializer).

Public Functions

array(std::string segment_id, std::size_t size, bool clear_on_destruction = true, bool multiprocess_safe = true)

Parameters:

segment_id – should be the same for all array pointing to the same shared memory segment
size – : number of elements to be stored by the array
clear_on_destruction – if true, the shared memory segment will be wiped on destruction of the array. Note that any other array pointing to this segment may hang indefinitely as a result. If no arrays pointing to the shared memory segment delete the segment, then users are expected to call shared_memory::clear_array. Failing to do so may result in new array pointing to a new memory segment of the same id to hang indefinitely at construction.
multiprocess_safe – if false, it is strongly adviced to protect accesses via a shared_memory::Mutex

~array(): wipe the related shared memory segment if clear_on_destruction is true (true by default)

array(const array<T, SIZE> &other): this array and other array will point to the same memory segment, and will have same values for clear_on_destruction and multiprocess_safe

array(array<T, SIZE> &&other) noexcept

This array will point to the share memory segment pointed at by other; and will have same value for multprocess_safe and clear_on_destruction.

Warning: even if other.clear_on_destruction is true, the segment memory will not be wiped on the destruction of other. The duty of deleting the shared memory is passed to the new instance, so to speak

array<T, SIZE> &operator=(array<T, SIZE> &&other) noexcept

This array will point to the share memory segment pointed at by other; and will have same value for multprocess_safe and clear_on_destruction.

Warning: even if other.clear_on_destruction is true, the segment memory will not be wiped on the destruction of other. The duty of deleting the shared memory is passed to the new instance, so to speak

void set(uint index, const T &t): set element t at index

void set(uint index, const T *t): set element t at index

void get(uint index, T &t): read element at index into t

void get(uint index, T *t): read element at index into t

std::size_t size() const: max number of elements in the array

std::string get_serialized(uint index)

return the serialized string representation of the element if T is a serializable class.

Throws a logic error otherwise.

void print(): print in terminal info about array’s memory usage

void *get_raw()

Private Functions

void init(FUNDAMENTAL)

void set(uint index, const T &t, FUNDAMENTAL)

void get(uint index, T &t, FUNDAMENTAL)

std::string get_serialized(uint index, FUNDAMENTAL)

void init(FUNDAMENTAL_ARRAY)

void set(uint index, const T &t, FUNDAMENTAL_ARRAY)

void get(uint index, T &t, FUNDAMENTAL_ARRAY)

std::string get_serialized(uint index, FUNDAMENTAL_ARRAY)

void init(SERIALIZABLE)

void set(uint index, const T &t, SERIALIZABLE)

void get(uint index, T &t, SERIALIZABLE)

std::string get_serialized(uint index, SERIALIZABLE)

Private Members

boost::interprocess::managed_shared_memory segment_manager_

std::string segment_id_

std::size_t size_

bool clear_on_destruction_

bool multiprocess_safe_

shared_memory::Mutex mutex_