Class shared_memory::array

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

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_