title: serialization using a memory mapped file
body: <p>I want to serialize my class objects on a memory mapped file but turns out boost serialization only works with file streams. Here is an example:</p>
  
  <pre><code>class gps_position
  {
  private:
      friend class boost::serialization::access;
      // When the class Archive corresponds to an output archive, the
      // &amp; operator is defined similar to &lt;&lt;.  Likewise, when the class Archive
      // is a type of input archive the &amp; operator is defined similar to &gt;&gt;.
      template&lt;class Archive&gt;
      void serialize(Archive &amp; ar, const unsigned int version)
      {
          ar &amp; degrees;
          ar &amp; minutes;
          ar &amp; seconds;
      }
      int degrees;
      int minutes;
      float seconds;
  public:
      gps_position(){};
      gps_position(int d, int m, float s) :
          degrees(d), minutes(m), seconds(s)
      {}
  };
  
  int main() {
      // create and open a character archive for output
      std::ofstream ofs("filename");
  
      // create class instance
      const gps_position g(35, 59, 24.567f);
  
      // save data to archive
      {
          boost::archive::text_oarchive oa(ofs);
          // write class instance to archive
          oa &lt;&lt; g;
          // archive and stream closed when destructors are called
      }
  
      // ... some time later restore the class instance to its orginal state
      gps_position newg;
      {
          // create and open an archive for input
          std::ifstream ifs("filename");
          boost::archive::text_iarchive ia(ifs);
          // read class state from archive
          ia &gt;&gt; newg;
          // archive and stream closed when destructors are called
      }
      return 0;
  }
  </code></pre>
  
  <p>Is there a away it can be done over memory mapped files. I am using windows API CreateFileMapping and MapViewOfFile for memory mapping.</p>
  
  <p>edit:</p>
  
  <p>This is what I tried to do using boost iostream library and memory mapped files.</p>
  
  <pre><code>namespace io = boost::iostreams;
  typedef io::stream_buffer &lt; io::mapped_file_source &gt; in_streambuf;
  typedef io::stream_buffer &lt; io::mapped_file_sink &gt; out_streambuf;
  
  int main() {
      // create and open a character archive for output
      //  std::ofstream ofs("filename");  /*commented this */
  
      boost::iostreams::mapped_file_params params;
          params.path  = "filepath";
      params.flags = io::mapped_file::mapmode::readwrite;
  
      out_streambuf obuf(params);
      std::ostream ofs(&amp;obuf);
  
      // create class instance
      const gps_position g(35, 59, 24.567f);
  
      // save data to archive
      {
          boost::archive::text_oarchive oa(ofs);
          // write class instance to archive
          oa &lt;&lt; g;
          // archive and stream closed when destructors are called
      }
  
      // ... some time later restore the class instance to its orginal state
      gps_position newg;
      {
          // create and open an archive for input
      in_streambuf ibuf(params);
      std::istream ifs(&amp;ibuf);
  
          //std::ifstream ifs("filename");  /* commented this */
  
          boost::archive::text_iarchive ia(ifs);
  
          // read class state from archive
  
          ia &gt;&gt; newg;
          // archive and stream closed when destructors are called
      }
      return 0;
  }
  </code></pre>
  
  <p>Now I am not too familiar with boost but this code fails at run time. So, any help is really appreciated. The failure happens here itself "out_streambuf obuf(params);".
  Thanks guys!</p>