libs/interprocess/example/doc_vectorstream.cpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2006-2009. Distributed under the Boost
   4 // Software License, Version 1.0. (See accompanying file
   5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // See http://www.boost.org/libs/interprocess for documentation.
   8 //
   9 //////////////////////////////////////////////////////////////////////////////
  10 #include <boost/interprocess/detail/config_begin.hpp>
  11 #include <boost/interprocess/detail/workaround.hpp>
  12 //[doc_vectorstream
  13 #include <boost/interprocess/containers/vector.hpp>
  14 #include <boost/interprocess/containers/string.hpp>
  15 #include <boost/interprocess/allocators/allocator.hpp>
  16 #include <boost/interprocess/managed_shared_memory.hpp>
  17 #include <boost/interprocess/streams/vectorstream.hpp>
  18 #include <iterator>
  19 //<-
  20 #include "../test/get_process_id_name.hpp"
  21 //->
  22
  23 using namespace boost::interprocess;
  24
  25 typedef allocator<int, managed_shared_memory::segment_manager>
  26    IntAllocator;
  27 typedef allocator<char, managed_shared_memory::segment_manager>
  28    CharAllocator;
  29 typedef vector<int, IntAllocator>   MyVector;
  30 typedef basic_string
  31    <char, std::char_traits<char>, CharAllocator>   MyString;
  32 typedef basic_vectorstream<MyString>               MyVectorStream;
  33
  34 int main ()
  35 {
  36    //Remove shared memory on construction and destruction
  37    struct shm_remove
  38    {
  39    //<-
  40    #if 1
  41       shm_remove() { shared_memory_object::remove(test::get_process_id_name()); }
  42       ~shm_remove(){ shared_memory_object::remove(test::get_process_id_name()); }
  43    #else
  44    //->
  45       shm_remove() { shared_memory_object::remove("MySharedMemory"); }
  46       ~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
  47    //<-
  48    #endif
  49    //->
  50    } remover;
  51
  52    //<-
  53    #if 1
  54    managed_shared_memory segment(
  55       create_only,
  56       test::get_process_id_name(), //segment name
  57       65536);           //segment size in bytes
  58    #else
  59    //->
  60    managed_shared_memory segment(
  61       create_only,
  62       "MySharedMemory", //segment name
  63       65536);           //segment size in bytes
  64    //<-
  65    #endif
  66    //->
  67
  68    //Construct shared memory vector
  69    MyVector *myvector =
  70       segment.construct<MyVector>("MyVector")
  71       (IntAllocator(segment.get_segment_manager()));
  72
  73    //Fill vector
  74    myvector->reserve(100);
  75    for(int i = 0; i < 100; ++i){
  76       myvector->push_back(i);
  77    }
  78
  79    //Create the vectorstream. To create the internal shared memory
  80    //basic_string we need to pass the shared memory allocator as
  81    //a constructor argument
  82    MyVectorStream myvectorstream(CharAllocator(segment.get_segment_manager()));
  83
  84    //Reserve the internal string
  85    myvectorstream.reserve(100*5);
  86
  87    //Write all vector elements as text in the internal string
  88    //Data will be directly written in shared memory, because
  89    //internal string's allocator is a shared memory allocator
  90    for(std::size_t i = 0, max = myvector->size(); i < max; ++i){
  91       myvectorstream << (*myvector)[i] << std::endl;
  92    }
  93
  94    //Auxiliary vector to compare original data
  95    MyVector *myvector2 =
  96       segment.construct<MyVector>("MyVector2")
  97       (IntAllocator(segment.get_segment_manager()));
  98
  99    //Avoid reallocations
 100    myvector2->reserve(100);
 101
 102    //Extract all values from the internal
 103    //string directly to a shared memory vector.
 104    std::istream_iterator<int> it(myvectorstream), itend;
 105    std::copy(it, itend, std::back_inserter(*myvector2));
 106
 107    //Compare vectors
 108    assert(std::equal(myvector->begin(), myvector->end(), myvector2->begin()));
 109
 110    //Create a copy of the internal string
 111    MyString stringcopy (myvectorstream.vector());
 112
 113    //Now we create a new empty shared memory string...
 114    MyString *mystring =
 115       segment.construct<MyString>("MyString")
 116       (CharAllocator(segment.get_segment_manager()));
 117
 118    //...and we swap vectorstream's internal string
 119    //with the new one: after this statement mystring
 120    //will be the owner of the formatted data.
 121    //No reallocations, no data copies
 122    myvectorstream.swap_vector(*mystring);
 123
 124    //Let's compare both strings
 125    assert(stringcopy == *mystring);
 126
 127    //Done, destroy and delete vectors and string from the segment
 128    segment.destroy_ptr(myvector2);
 129    segment.destroy_ptr(myvector);
 130    segment.destroy_ptr(mystring);
 131    return 0;
 132 }
 133 //]
 134 #include <boost/interprocess/detail/config_end.hpp>