| Home | Libraries | People | FAQ | More

## Class mapped_region

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.