Class template basic_managed_mapped

Class template basic_managed_mapped_file

boost::interprocess::basic_managed_mapped_file

Synopsis

// In header: <boost/interprocess/managed_mapped_file.hpp>

template<typename CharType, typename AllocationAlgorithm, 
         template< class IndexConfig > class IndexType> 
class basic_managed_mapped_file {
public:
  // types
  typedef implementation_defined size_type;

  // construct/copy/destruct
  basic_managed_mapped_file();
  basic_managed_mapped_file(create_only_t, const char *, size_type, 
                            const void * = 0, 
                            const permissions & = permissions());
  basic_managed_mapped_file(open_or_create_t, const char *, size_type, 
                            const void * = 0, 
                            const permissions & = permissions());
  basic_managed_mapped_file(open_only_t, const char *, const void * = 0);
  basic_managed_mapped_file(open_copy_on_write_t, const char *, 
                            const void * = 0);
  basic_managed_mapped_file(open_read_only_t, const char *, const void * = 0);
  basic_managed_mapped_file(basic_managed_mapped_file &&);
  basic_managed_mapped_file & operator=(basic_managed_mapped_file &&);
  ~basic_managed_mapped_file();

  // public member functions
  void swap(basic_managed_mapped_file &);
  bool flush();

  // public static functions
  static bool grow(const char *, size_type);
  static bool shrink_to_fit(const char *);
};

Description

A basic mapped file named object creation class. Initializes the mapped file. Inherits all basic functionality from basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>

`basic_managed_mapped_file` public types

typedef implementation_defined size_type;

Unsigned integral type enough to represent the size of a basic_managed_mapped_file.

`basic_managed_mapped_file` public construct/copy/destruct

```
basic_managed_mapped_file();
```
Creates mapped file and creates and places the segment manager. This can throw.

basic_managed_mapped_file(create_only_t, const char * name, size_type size, 
                          const void * addr = 0, 
                          const permissions & perm = permissions());

Creates mapped file and creates and places the segment manager. This can throw.

basic_managed_mapped_file(open_or_create_t, const char * name, size_type size, 
                          const void * addr = 0, 
                          const permissions & perm = permissions());

Creates mapped file and creates and places the segment manager if segment was not created. If segment was created it connects to the segment. This can throw.

basic_managed_mapped_file(open_only_t, const char * name, 
                          const void * addr = 0);

Connects to a created mapped file and its segment manager. This can throw.

basic_managed_mapped_file(open_copy_on_write_t, const char * name, 
                          const void * addr = 0);

Connects to a created mapped file and its segment manager in copy_on_write mode. This can throw.

basic_managed_mapped_file(open_read_only_t, const char * name, 
                          const void * addr = 0);

Connects to a created mapped file and its segment manager in read-only mode. This can throw.

```
basic_managed_mapped_file(basic_managed_mapped_file && moved);
```
Moves the ownership of "moved"'s managed memory to *this. Does not throw

basic_managed_mapped_file & operator=(basic_managed_mapped_file && moved);

Moves the ownership of "moved"'s managed memory to *this. Does not throw

```
~basic_managed_mapped_file();
```
Destroys *this and indicates that the calling process is finished using the resource. The destructor function will deallocate any system resources allocated by the system for use by this process for this resource. The resource can still be opened again calling the open constructor overload. To erase the resource from the system use remove().

`basic_managed_mapped_file` public member functions

```
void swap(basic_managed_mapped_file & other);
```
Swaps the ownership of the managed mapped memories managed by *this and other. Never throws.
```
bool flush();
```
Flushes cached data to file. Never throws

`basic_managed_mapped_file` public static functions

```
static bool grow(const char * filename, size_type extra_bytes);
```
Tries to resize mapped file so that we have room for more objects.

This function is not synchronized so no other thread or process should be reading or writing the file
```
static bool shrink_to_fit(const char * filename);
```
Tries to resize mapped file to minimized the size of the file.

This function is not synchronized so no other thread or process should be reading or writing the file