Boost C++ Libraries

template<typename MemoryMappable> 
  mapped_region(const MemoryMappable & mapping, mode_t mode, 
                offset_t offset = 0, std::size_t size = 0, 
                const void * address = 0);

Creates a mapping region of the mapped memory "mapping", starting in offset "offset", and the mapping's size will be "size". The mapping can be opened for read only, read-write or copy-on-write.

If an address is specified, both the offset and the address must be multiples of the page size.

The OS could allocate more pages than size/page_size(), but get_address() will always return the address passed in this function (if not null) and get_size() will return the specified size.

mapped_region();

Default constructor. Address will be 0 (nullptr). Size will be 0. Does not throw

mapped_region(mapped_region && other);

Move constructor. *this will be constructed taking ownership of "other"'s region and "other" will be left in default constructor state.

mapped_region& operator=(mapped_region && other);

Move assignment. If *this owns a memory mapped region, it will be destroyed and it will take ownership of "other"'s memory mapped region.

~mapped_region();

Destroys the mapped region. Does not throw

std::size_t get_size() const;

void * get_address() const;

Returns the base address of the mapping. Never throws.

mode_t get_mode() const;

Returns the mode of the mapping used to construct the mapped region. Never throws.

bool flush(std::size_t mapping_offset = 0, std::size_t numbytes = 0, 
           bool async = true);

Flushes to the disk a byte range within the mapped memory. If 'async' is true, the function will return before flushing operation is completed If 'async' is false, function will return once data has been written into the underlying device (i.e., in mapped files OS cached information is written to disk). Never throws. Returns false if operation could not be performed.

void swap(mapped_region & other);

Swaps the mapped_region with another mapped region

static std::size_t get_page_size();

Returns the size of the page. This size is the minimum memory that will be used by the system when mapping a memory mappable source and will restrict the address and the offset to map.