| Home | Libraries | People | FAQ | More

## Class template basic_managed_xsi_shared_memory

boost::interprocess::basic_managed_xsi_shared_memory

## Synopsis

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

    template<typename CharType, typename AllocationAlgorithm,
             template< class IndexConfig > class IndexType>
    class basic_managed_xsi_shared_memory {
    public:
      // types
      typedef unspecified base2_t;
      typedef unspecified base_t;
      typedef unspecified create_open_func_t;

      // construct/copy/destruct
      basic_managed_xsi_shared_memory();
      basic_managed_xsi_shared_memory(create_only_t, const xsi_key &, std::size_t,
                                      const void * = 0,
                                      const permissions & = permissions());
      basic_managed_xsi_shared_memory(open_or_create_t, const xsi_key &,
                                      std::size_t, const void * = 0,
                                      const permissions & = permissions());
      basic_managed_xsi_shared_memory(open_read_only_t, const xsi_key &,
                                      const void * = 0);
      basic_managed_xsi_shared_memory(open_only_t, const xsi_key &,
                                      const void * = 0);
      basic_managed_xsi_shared_memory(basic_managed_xsi_shared_memory &&);
      basic_managed_xsi_shared_memory&
      operator=(basic_managed_xsi_shared_memory &&);
      ~basic_managed_xsi_shared_memory();

      // public member functions
      basic_managed_xsi_shared_memory * get_this_pointer();
      void swap(basic_managed_xsi_shared_memory &);
      int get_shmid() const;
      template<typename T> std::pair< T *, std::size_t > find(char_ptr_holder_t);

      // public static functions
      static bool remove(int);
    };

## Description

A basic X/Open System Interface (XSI) shared memory named object creation class. Initializes the shared memory segment. Inherits all basic functionality from basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>

### `basic_managed_xsi_shared_memory` public construct/copy/destruct

1.     basic_managed_xsi_shared_memory();

   Default constructor. Does nothing. Useful in combination with move semantics

2.     basic_managed_xsi_shared_memory(create_only_t create_only,
                                       const xsi_key & key, std::size_t size,
                                       const void * addr = 0,
                                       const permissions & perm = permissions());

   Creates shared memory and creates and places the segment manager. This can throw.

3.     basic_managed_xsi_shared_memory(open_or_create_t open_or_create,
                                       const xsi_key & key, std::size_t size,
                                       const void * addr = 0,
                                       const permissions & perm = permissions());

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

4.     basic_managed_xsi_shared_memory(open_read_only_t, const xsi_key & key,
                                       const void * addr = 0);

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

5.     basic_managed_xsi_shared_memory(open_only_t open_only, const xsi_key & key,
                                       const void * addr = 0);

   Connects to a created shared memory and its segment manager. This can throw.

6.     basic_managed_xsi_shared_memory(basic_managed_xsi_shared_memory && moved);

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

7.     basic_managed_xsi_shared_memory&
       operator=(basic_managed_xsi_shared_memory && moved);

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

8.     ~basic_managed_xsi_shared_memory();

   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_xsi_shared_memory` public member functions

1.     basic_managed_xsi_shared_memory * get_this_pointer();

2.     void swap(basic_managed_xsi_shared_memory & other);

   Swaps the ownership of the managed shared memories managed by *this and other. Never throws.

3.     int get_shmid() const;

4.     template<typename T>
         std::pair< T *, std::size_t > find(char_ptr_holder_t name);

   @ Tries to find a previous named allocation address. Returns a memory buffer and the object count. If not found returned pointer is 0. Never throws.

### `basic_managed_xsi_shared_memory` public static functions

1.     static bool remove(int shmid);

   Erases a XSI shared memory object identified by shmid from the system. Returns false on error. Never throws