CLASS MAPPED_REGION(3)

NAME
boost::interprocess::mapped_region

SYNOPSIS

// In header: <boost/interprocess/mapped_region.hpp>
class mapped_region {
public:
  // member classes/structs/unions
  template<int dummy>
  struct page_size_holder {
    // public static functions
    static std::size_t get_page_size();
    static const std::size_t PageSize;
  };
  // construct/copy/destruct
  template<typename MemoryMappable>
    mapped_region(const MemoryMappable &, mode_t, offset_t = 0,
                  std::size_t = 0, const void * = 0);
  mapped_region();
  mapped_region(mapped_region &&);
  mapped_region& operator=(mapped_region &&);
  ~mapped_region();
  // public member functions
  std::size_t get_size() const;
  void * get_address() const;
  offset_t get_offset() const;
  mode_t get_mode() const;
  bool flush(std::size_t = 0, std::size_t = 0);
  void swap(mapped_region &);
  void priv_close();
  void dont_close_on_destruction();
  // public static functions
  static std::size_t get_page_size();
  void * m_base;
  std::size_t m_size;
  offset_t m_offset;
  offset_t m_extra_offset;
  mode_t m_mode;
  bool m_is_xsi;
};

DESCRIPTION

The mapped_region class represents a portion or region created from a memory_mappable object.

  mapped_region public construct/copy/destruct

    1.

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

    @ //Non-copyable 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_only" or read-write "read_write.

    2.

    mapped_region();

    Default constructor. Address and size and offset will be 0. Does not throw

    3.

    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.

    4.

    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.

    5.

    ~mapped_region();

    Destroys the mapped region. Does not throw

  mapped_region public member functions

    1.

    std::size_t get_size() const;

    Returns the size of the mapping. Note for windows users: If windows_shared_memory is mapped using 0 as the size, it returns 0 because the size is unknown. Never throws.

    2.

    void * get_address() const;

    Returns the base address of the mapping. Never throws.

    3.

    offset_t get_offset() const;

    Returns the offset of the mapping from the beginning of the mapped memory. Never throws.

    4.

    mode_t get_mode() const;

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

    5.

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

    Flushes to the disk a byte range within the mapped memory. Never throws

    6.

    void swap(mapped_region & other);

    Swaps the mapped_region with another mapped region

    7.

    void priv_close();

    @ private: Closes a previously opened memory mapping. Never throws

    8.

    void dont_close_on_destruction();

  mapped_region public static functions

    1.

    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.