doc/html/interprocess/streams.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Direct iostream formatting: vectorstream and bufferstream</title>
   5 <link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
   7 <link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
   8 <link rel="up" href="../interprocess.html" title="Chapter&#160;14.&#160;Boost.Interprocess">
   9 <link rel="prev" href="memory_algorithms.html" title="Memory allocation algorithms">
  10 <link rel="next" href="interprocess_smart_ptr.html" title="Ownership smart pointers">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
  15 <td align="center"><a href="../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="memory_algorithms.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../interprocess.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="interprocess_smart_ptr.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
  27 <a name="interprocess.streams"></a><a class="link" href="streams.html" title="Direct iostream formatting: vectorstream and bufferstream">Direct iostream formatting: vectorstream
  28     and bufferstream</a>
  29 </h2></div></div></div>
  30 <div class="toc"><dl class="toc">
  31 <dt><span class="section"><a href="streams.html#interprocess.streams.vectorstream">Formatting directly
  32       in your character vector: vectorstream</a></span></dt>
  33 <dt><span class="section"><a href="streams.html#interprocess.streams.bufferstream">Formatting directly
  34       in your character buffer: bufferstream</a></span></dt>
  35 </dl></div>
  36 <p>
  37       Shared memory, memory-mapped files and all <span class="bold"><strong>Boost.Interprocess</strong></span>
  38       mechanisms are focused on efficiency. The reason why shared memory is used
  39       is that it's the fastest IPC mechanism available. When passing text-oriented
  40       messages through shared memory, there is need to format the message. Obviously
  41       C++ offers the iostream framework for that work.
  42     </p>
  43 <p>
  44       Some programmers appreciate the iostream safety and design for memory formatting
  45       but feel that the stringstream family is far from efficient not when formatting,
  46       but when obtaining formatted data to a string, or when setting the string from
  47       which the stream will extract data. An example:
  48     </p>
  49 <pre class="programlisting"><span class="comment">//Some formatting elements</span>
  50 <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">my_text</span> <span class="special">=</span> <span class="string">"..."</span><span class="special">;</span>
  51 <span class="keyword">int</span> <span class="identifier">number</span><span class="special">;</span>
  52
  53 <span class="comment">//Data reader</span>
  54 <span class="identifier">std</span><span class="special">::</span><span class="identifier">istringstream</span> <span class="identifier">input_processor</span><span class="special">;</span>
  55
  56 <span class="comment">//This makes a copy of the string. If not using a</span>
  57 <span class="comment">//reference counted string, this is a serious overhead.</span>
  58 <span class="identifier">input_processor</span><span class="special">.</span><span class="identifier">str</span><span class="special">(</span><span class="identifier">my_text</span><span class="special">);</span>
  59
  60 <span class="comment">//Extract data</span>
  61 <span class="keyword">while</span><span class="special">(/*...*/){</span>
  62    <span class="identifier">input_processor</span> <span class="special">&gt;&gt;</span> <span class="identifier">number</span><span class="special">;</span>
  63 <span class="special">}</span>
  64
  65 <span class="comment">//Data writer</span>
  66 <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostringstream</span> <span class="identifier">output_processor</span><span class="special">;</span>
  67
  68 <span class="comment">//Write data</span>
  69 <span class="keyword">while</span><span class="special">(/*...*/){</span>
  70    <span class="identifier">output_processor</span> <span class="special">&lt;&lt;</span> <span class="identifier">number</span><span class="special">;</span>
  71 <span class="special">}</span>
  72
  73 <span class="comment">//This returns a temporary string. Even with return-value</span>
  74 <span class="comment">//optimization this is expensive.</span>
  75 <span class="identifier">my_text</span> <span class="special">=</span> <span class="identifier">input_processor</span><span class="special">.</span><span class="identifier">str</span><span class="special">();</span>
  76 </pre>
  77 <p>
  78       The problem is even worse if the string is a shared-memory string, because
  79       to extract data, we must copy the data first from shared-memory to a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
  80       and then to a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span></code>. To encode data in a shared
  81       memory string we should copy data from a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">stringstream</span></code>
  82       to a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code> and then to the shared-memory string.
  83     </p>
  84 <p>
  85       Because of this overhead, <span class="bold"><strong>Boost.Interprocess</strong></span>
  86       offers a way to format memory-strings (in shared memory, memory mapped files
  87       or any other memory segment) that can avoid all unneeded string copy and memory
  88       allocation/deallocations, while using all iostream facilities. <span class="bold"><strong>Boost.Interprocess</strong></span>
  89       <span class="bold"><strong>vectorstream</strong></span> and <span class="bold"><strong>bufferstream</strong></span>
  90       implement vector-based and fixed-size buffer based storage support for iostreams
  91       and all the formatting/locale hard work is done by standard <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_streambuf</span><span class="special">&lt;&gt;</span></code> and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_iostream</span><span class="special">&lt;&gt;</span></code> classes.
  92     </p>
  93 <div class="section">
  94 <div class="titlepage"><div><div><h3 class="title">
  95 <a name="interprocess.streams.vectorstream"></a><a class="link" href="streams.html#interprocess.streams.vectorstream" title="Formatting directly in your character vector: vectorstream">Formatting directly
  96       in your character vector: vectorstream</a>
  97 </h3></div></div></div>
  98 <p>
  99         The <span class="bold"><strong>vectorstream</strong></span> class family (<span class="bold"><strong>basic_vectorbuf</strong></span>, <span class="bold"><strong>basic_ivectorstream</strong></span>
 100         ,<span class="bold"><strong>basic_ovectorstream</strong></span> and <span class="bold"><strong>basic_vectorstream</strong></span>)
 101         is an efficient way to obtain formatted reading/writing directly in a character
 102         vector. This way, if a shared-memory vector is used, data is extracted/written
 103         from/to the shared-memory vector, without additional copy/allocation. We
 104         can see the declaration of basic_vectorstream here:
 105       </p>
 106 <pre class="programlisting"><span class="comment">//!A basic_iostream class that holds a character vector specified by CharVector</span>
 107 <span class="comment">//!template parameter as its formatting buffer. The vector must have</span>
 108 <span class="comment">//!contiguous storage, like std::vector, boost::interprocess::vector or</span>
 109 <span class="comment">//!boost::interprocess::basic_string</span>
 110 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharVector</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CharTraits</span> <span class="special">=</span>
 111          <span class="identifier">std</span><span class="special">::</span><span class="identifier">char_traits</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">CharVector</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;</span> <span class="special">&gt;</span>
 112 <span class="keyword">class</span> <span class="identifier">basic_vectorstream</span>
 113 <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_iostream</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">CharVector</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;</span>
 114
 115 <span class="special">{</span>
 116    <span class="keyword">public</span><span class="special">:</span>
 117    <span class="keyword">typedef</span> <span class="identifier">CharVector</span>                                                   <span class="identifier">vector_type</span><span class="special">;</span>
 118    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span>
 119       <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">CharVector</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">char_type</span>          <span class="identifier">char_type</span><span class="special">;</span>
 120    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span><span class="special">&lt;</span><span class="identifier">char_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">int_type</span>     <span class="identifier">int_type</span><span class="special">;</span>
 121    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span><span class="special">&lt;</span><span class="identifier">char_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">pos_type</span>     <span class="identifier">pos_type</span><span class="special">;</span>
 122    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span><span class="special">&lt;</span><span class="identifier">char_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">off_type</span>     <span class="identifier">off_type</span><span class="special">;</span>
 123    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span><span class="special">&lt;</span><span class="identifier">char_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">traits_type</span>  <span class="identifier">traits_type</span><span class="special">;</span>
 124
 125    <span class="comment">//!Constructor. Throws if vector_type default constructor throws.</span>
 126    <span class="identifier">basic_vectorstream</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">openmode</span> <span class="identifier">mode</span>
 127                      <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">in</span> <span class="special">|</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">out</span><span class="special">);</span>
 128
 129    <span class="comment">//!Constructor. Throws if vector_type(const Parameter &amp;param) throws.</span>
 130    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Parameter</span><span class="special">&gt;</span>
 131    <span class="identifier">basic_vectorstream</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Parameter</span> <span class="special">&amp;</span><span class="identifier">param</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">openmode</span> <span class="identifier">mode</span>
 132                      <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">in</span> <span class="special">|</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">out</span><span class="special">);</span>
 133
 134    <span class="special">~</span><span class="identifier">basic_vectorstream</span><span class="special">(){}</span>
 135
 136    <span class="comment">//!Returns the address of the stored stream buffer.</span>
 137    <span class="identifier">basic_vectorbuf</span><span class="special">&lt;</span><span class="identifier">CharVector</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;*</span> <span class="identifier">rdbuf</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 138
 139    <span class="comment">//!Swaps the underlying vector with the passed vector.</span>
 140    <span class="comment">//!This function resets the position in the stream.</span>
 141    <span class="comment">//!Does not throw.</span>
 142    <span class="keyword">void</span> <span class="identifier">swap_vector</span><span class="special">(</span><span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">vect</span><span class="special">);</span>
 143
 144    <span class="comment">//!Returns a const reference to the internal vector.</span>
 145    <span class="comment">//!Does not throw.</span>
 146    <span class="keyword">const</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">vector</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 147
 148    <span class="comment">//!Preallocates memory from the internal vector.</span>
 149    <span class="comment">//!Resets the stream to the first position.</span>
 150    <span class="comment">//!Throws if the internals vector's memory allocation throws.</span>
 151    <span class="keyword">void</span> <span class="identifier">reserve</span><span class="special">(</span><span class="keyword">typename</span> <span class="identifier">vector_type</span><span class="special">::</span><span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">);</span>
 152 <span class="special">};</span>
 153 </pre>
 154 <p>
 155         The vector type is templatized, so that we can use any type of vector: <span class="bold"><strong>std::vector</strong></span>, <code class="computeroutput">boost::interprocess::vector</code>...
 156         But the storage must be <span class="bold"><strong>contiguous</strong></span>, we can't
 157         use a deque. We can even use <span class="bold"><strong>boost::interprocess::basic_string</strong></span>,
 158         since it has a vector interface and it has contiguous storage. <span class="bold"><strong>We can't use std::string</strong></span>, because although some std::string
 159         implementation are vector-based, others can have optimizations and reference-counted
 160         implementations.
 161       </p>
 162 <p>
 163         The user can obtain a const reference to the internal vector using <code class="computeroutput"><span class="identifier">vector_type</span> <span class="identifier">vector</span><span class="special">()</span> <span class="keyword">const</span></code> function
 164         and he also can swap the internal vector with an external one calling <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">swap_vector</span><span class="special">(</span><span class="identifier">vector_type</span>
 165         <span class="special">&amp;</span><span class="identifier">vect</span><span class="special">)</span></code>. The swap function resets the stream position.
 166         This functions allow efficient methods to obtain the formatted data avoiding
 167         all allocations and data copies.
 168       </p>
 169 <p>
 170         Let's see an example to see how to use vectorstream:
 171       </p>
 172 <p>
 173 </p>
 174 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">interprocess</span><span class="special">/</span><span class="identifier">containers</span><span class="special">/</span><span class="identifier">vector</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 175 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">interprocess</span><span class="special">/</span><span class="identifier">containers</span><span class="special">/</span><span class="identifier">string</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 176 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">interprocess</span><span class="special">/</span><span class="identifier">allocators</span><span class="special">/</span><span class="identifier">allocator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 177 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">interprocess</span><span class="special">/</span><span class="identifier">managed_shared_memory</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 178 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">interprocess</span><span class="special">/</span><span class="identifier">streams</span><span class="special">/</span><span class="identifier">vectorstream</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 179 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>
 180
 181 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">interprocess</span><span class="special">;</span>
 182
 183 <span class="keyword">typedef</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">managed_shared_memory</span><span class="special">::</span><span class="identifier">segment_manager</span><span class="special">&gt;</span>
 184    <span class="identifier">IntAllocator</span><span class="special">;</span>
 185 <span class="keyword">typedef</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">managed_shared_memory</span><span class="special">::</span><span class="identifier">segment_manager</span><span class="special">&gt;</span>
 186    <span class="identifier">CharAllocator</span><span class="special">;</span>
 187 <span class="keyword">typedef</span> <span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">IntAllocator</span><span class="special">&gt;</span>   <span class="identifier">MyVector</span><span class="special">;</span>
 188 <span class="keyword">typedef</span> <span class="identifier">basic_string</span>
 189    <span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">char_traits</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;,</span> <span class="identifier">CharAllocator</span><span class="special">&gt;</span>   <span class="identifier">MyString</span><span class="special">;</span>
 190 <span class="keyword">typedef</span> <span class="identifier">basic_vectorstream</span><span class="special">&lt;</span><span class="identifier">MyString</span><span class="special">&gt;</span>               <span class="identifier">MyVectorStream</span><span class="special">;</span>
 191
 192 <span class="keyword">int</span> <span class="identifier">main</span> <span class="special">()</span>
 193 <span class="special">{</span>
 194    <span class="comment">//Remove shared memory on construction and destruction</span>
 195    <span class="keyword">struct</span> <span class="identifier">shm_remove</span>
 196    <span class="special">{</span>
 197       <span class="identifier">shm_remove</span><span class="special">()</span> <span class="special">{</span> <span class="identifier">shared_memory_object</span><span class="special">::</span><span class="identifier">remove</span><span class="special">(</span><span class="string">"MySharedMemory"</span><span class="special">);</span> <span class="special">}</span>
 198       <span class="special">~</span><span class="identifier">shm_remove</span><span class="special">(){</span> <span class="identifier">shared_memory_object</span><span class="special">::</span><span class="identifier">remove</span><span class="special">(</span><span class="string">"MySharedMemory"</span><span class="special">);</span> <span class="special">}</span>
 199    <span class="special">}</span> <span class="identifier">remover</span><span class="special">;</span>
 200
 201    <span class="identifier">managed_shared_memory</span> <span class="identifier">segment</span><span class="special">(</span>
 202       <span class="identifier">create_only</span><span class="special">,</span>
 203       <span class="string">"MySharedMemory"</span><span class="special">,</span> <span class="comment">//segment name</span>
 204       <span class="number">65536</span><span class="special">);</span>           <span class="comment">//segment size in bytes</span>
 205
 206    <span class="comment">//Construct shared memory vector</span>
 207    <span class="identifier">MyVector</span> <span class="special">*</span><span class="identifier">myvector</span> <span class="special">=</span>
 208       <span class="identifier">segment</span><span class="special">.</span><span class="identifier">construct</span><span class="special">&lt;</span><span class="identifier">MyVector</span><span class="special">&gt;(</span><span class="string">"MyVector"</span><span class="special">)</span>
 209       <span class="special">(</span><span class="identifier">IntAllocator</span><span class="special">(</span><span class="identifier">segment</span><span class="special">.</span><span class="identifier">get_segment_manager</span><span class="special">()));</span>
 210
 211    <span class="comment">//Fill vector</span>
 212    <span class="identifier">myvector</span><span class="special">-&gt;</span><span class="identifier">reserve</span><span class="special">(</span><span class="number">100</span><span class="special">);</span>
 213    <span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">100</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">){</span>
 214       <span class="identifier">myvector</span><span class="special">-&gt;</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">i</span><span class="special">);</span>
 215    <span class="special">}</span>
 216
 217    <span class="comment">//Create the vectorstream. To create the internal shared memory</span>
 218    <span class="comment">//basic_string we need to pass the shared memory allocator as</span>
 219    <span class="comment">//a constructor argument</span>
 220    <span class="identifier">MyVectorStream</span> <span class="identifier">myvectorstream</span><span class="special">(</span><span class="identifier">CharAllocator</span><span class="special">(</span><span class="identifier">segment</span><span class="special">.</span><span class="identifier">get_segment_manager</span><span class="special">()));</span>
 221
 222    <span class="comment">//Reserve the internal string</span>
 223    <span class="identifier">myvectorstream</span><span class="special">.</span><span class="identifier">reserve</span><span class="special">(</span><span class="number">100</span><span class="special">*</span><span class="number">5</span><span class="special">);</span>
 224
 225    <span class="comment">//Write all vector elements as text in the internal string</span>
 226    <span class="comment">//Data will be directly written in shared memory, because</span>
 227    <span class="comment">//internal string's allocator is a shared memory allocator</span>
 228    <span class="keyword">for</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">max</span> <span class="special">=</span> <span class="identifier">myvector</span><span class="special">-&gt;</span><span class="identifier">size</span><span class="special">();</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">max</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">){</span>
 229       <span class="identifier">myvectorstream</span> <span class="special">&lt;&lt;</span> <span class="special">(*</span><span class="identifier">myvector</span><span class="special">)[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 230    <span class="special">}</span>
 231
 232    <span class="comment">//Auxiliary vector to compare original data</span>
 233    <span class="identifier">MyVector</span> <span class="special">*</span><span class="identifier">myvector2</span> <span class="special">=</span>
 234       <span class="identifier">segment</span><span class="special">.</span><span class="identifier">construct</span><span class="special">&lt;</span><span class="identifier">MyVector</span><span class="special">&gt;(</span><span class="string">"MyVector2"</span><span class="special">)</span>
 235       <span class="special">(</span><span class="identifier">IntAllocator</span><span class="special">(</span><span class="identifier">segment</span><span class="special">.</span><span class="identifier">get_segment_manager</span><span class="special">()));</span>
 236
 237    <span class="comment">//Avoid reallocations</span>
 238    <span class="identifier">myvector2</span><span class="special">-&gt;</span><span class="identifier">reserve</span><span class="special">(</span><span class="number">100</span><span class="special">);</span>
 239
 240    <span class="comment">//Extract all values from the internal</span>
 241    <span class="comment">//string directly to a shared memory vector.</span>
 242    <span class="identifier">std</span><span class="special">::</span><span class="identifier">istream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">it</span><span class="special">(</span><span class="identifier">myvectorstream</span><span class="special">),</span> <span class="identifier">itend</span><span class="special">;</span>
 243    <span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">it</span><span class="special">,</span> <span class="identifier">itend</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">back_inserter</span><span class="special">(*</span><span class="identifier">myvector2</span><span class="special">));</span>
 244
 245    <span class="comment">//Compare vectors</span>
 246    <span class="identifier">assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal</span><span class="special">(</span><span class="identifier">myvector</span><span class="special">-&gt;</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">myvector</span><span class="special">-&gt;</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">myvector2</span><span class="special">-&gt;</span><span class="identifier">begin</span><span class="special">()));</span>
 247
 248    <span class="comment">//Create a copy of the internal string</span>
 249    <span class="identifier">MyString</span> <span class="identifier">stringcopy</span> <span class="special">(</span><span class="identifier">myvectorstream</span><span class="special">.</span><span class="identifier">vector</span><span class="special">());</span>
 250
 251    <span class="comment">//Now we create a new empty shared memory string...</span>
 252    <span class="identifier">MyString</span> <span class="special">*</span><span class="identifier">mystring</span> <span class="special">=</span>
 253       <span class="identifier">segment</span><span class="special">.</span><span class="identifier">construct</span><span class="special">&lt;</span><span class="identifier">MyString</span><span class="special">&gt;(</span><span class="string">"MyString"</span><span class="special">)</span>
 254       <span class="special">(</span><span class="identifier">CharAllocator</span><span class="special">(</span><span class="identifier">segment</span><span class="special">.</span><span class="identifier">get_segment_manager</span><span class="special">()));</span>
 255
 256    <span class="comment">//...and we swap vectorstream's internal string</span>
 257    <span class="comment">//with the new one: after this statement mystring</span>
 258    <span class="comment">//will be the owner of the formatted data.</span>
 259    <span class="comment">//No reallocations, no data copies</span>
 260    <span class="identifier">myvectorstream</span><span class="special">.</span><span class="identifier">swap_vector</span><span class="special">(*</span><span class="identifier">mystring</span><span class="special">);</span>
 261
 262    <span class="comment">//Let's compare both strings</span>
 263    <span class="identifier">assert</span><span class="special">(</span><span class="identifier">stringcopy</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">mystring</span><span class="special">);</span>
 264
 265    <span class="comment">//Done, destroy and delete vectors and string from the segment</span>
 266    <span class="identifier">segment</span><span class="special">.</span><span class="identifier">destroy_ptr</span><span class="special">(</span><span class="identifier">myvector2</span><span class="special">);</span>
 267    <span class="identifier">segment</span><span class="special">.</span><span class="identifier">destroy_ptr</span><span class="special">(</span><span class="identifier">myvector</span><span class="special">);</span>
 268    <span class="identifier">segment</span><span class="special">.</span><span class="identifier">destroy_ptr</span><span class="special">(</span><span class="identifier">mystring</span><span class="special">);</span>
 269    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 270 <span class="special">}</span>
 271 </pre>
 272 <p>
 273       </p>
 274 </div>
 275 <div class="section">
 276 <div class="titlepage"><div><div><h3 class="title">
 277 <a name="interprocess.streams.bufferstream"></a><a class="link" href="streams.html#interprocess.streams.bufferstream" title="Formatting directly in your character buffer: bufferstream">Formatting directly
 278       in your character buffer: bufferstream</a>
 279 </h3></div></div></div>
 280 <p>
 281         As seen, vectorstream offers an easy and secure way for efficient iostream
 282         formatting, but many times, we have to read or write formatted data from/to
 283         a fixed size character buffer (a static buffer, a c-string, or any other).
 284         Because of the overhead of stringstream, many developers (specially in embedded
 285         systems) choose sprintf family. The <span class="bold"><strong>bufferstream</strong></span>
 286         classes offer iostream interface with direct formatting in a fixed size memory
 287         buffer with protection against buffer overflows. This is the interface:
 288       </p>
 289 <pre class="programlisting"><span class="comment">//!A basic_iostream class that uses a fixed size character buffer</span>
 290 <span class="comment">//!as its formatting buffer.</span>
 291 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CharTraits</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">char_traits</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">&gt;</span> <span class="special">&gt;</span>
 292 <span class="keyword">class</span> <span class="identifier">basic_bufferstream</span>
 293    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_iostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;</span>
 294
 295 <span class="special">{</span>
 296    <span class="keyword">public</span><span class="special">:</span>                         <span class="comment">// Typedefs</span>
 297    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span>
 298       <span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">char_type</span>          <span class="identifier">char_type</span><span class="special">;</span>
 299    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span><span class="special">&lt;</span><span class="identifier">char_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">int_type</span>     <span class="identifier">int_type</span><span class="special">;</span>
 300    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span><span class="special">&lt;</span><span class="identifier">char_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">pos_type</span>     <span class="identifier">pos_type</span><span class="special">;</span>
 301    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span><span class="special">&lt;</span><span class="identifier">char_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">off_type</span>     <span class="identifier">off_type</span><span class="special">;</span>
 302    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_ios</span><span class="special">&lt;</span><span class="identifier">char_type</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;::</span><span class="identifier">traits_type</span>  <span class="identifier">traits_type</span><span class="special">;</span>
 303
 304    <span class="comment">//!Constructor. Does not throw.</span>
 305    <span class="identifier">basic_bufferstream</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">openmode</span> <span class="identifier">mode</span>
 306                      <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">in</span> <span class="special">|</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">out</span><span class="special">);</span>
 307
 308    <span class="comment">//!Constructor. Assigns formatting buffer. Does not throw.</span>
 309    <span class="identifier">basic_bufferstream</span><span class="special">(</span><span class="identifier">CharT</span> <span class="special">*</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">length</span><span class="special">,</span>
 310                      <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">openmode</span> <span class="identifier">mode</span>
 311                         <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">in</span> <span class="special">|</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">out</span><span class="special">);</span>
 312
 313    <span class="comment">//!Returns the address of the stored stream buffer.</span>
 314    <span class="identifier">basic_bufferbuf</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">CharTraits</span><span class="special">&gt;*</span> <span class="identifier">rdbuf</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 315
 316    <span class="comment">//!Returns the pointer and size of the internal buffer.</span>
 317    <span class="comment">//!Does not throw.</span>
 318    <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">CharT</span> <span class="special">*,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">&gt;</span> <span class="identifier">buffer</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 319
 320    <span class="comment">//!Sets the underlying buffer to a new value. Resets</span>
 321    <span class="comment">//!stream position. Does not throw.</span>
 322    <span class="keyword">void</span> <span class="identifier">buffer</span><span class="special">(</span><span class="identifier">CharT</span> <span class="special">*</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">length</span><span class="special">);</span>
 323 <span class="special">};</span>
 324
 325 <span class="comment">//Some typedefs to simplify usage</span>
 326 <span class="keyword">typedef</span> <span class="identifier">basic_bufferstream</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span>     <span class="identifier">bufferstream</span><span class="special">;</span>
 327 <span class="keyword">typedef</span> <span class="identifier">basic_bufferstream</span><span class="special">&lt;</span><span class="keyword">wchar_t</span><span class="special">&gt;</span>  <span class="identifier">wbufferstream</span><span class="special">;</span>
 328 <span class="comment">// ...</span>
 329 </pre>
 330 <p>
 331         While reading from a fixed size buffer, <span class="bold"><strong>bufferstream</strong></span>
 332         activates endbit flag if we try to read an address beyond the end of the
 333         buffer. While writing to a fixed size buffer, <span class="bold"><strong>bufferstream</strong></span>
 334         will active the badbit flag if a buffer overflow is going to happen and disallows
 335         writing. This way, the fixed size buffer formatting through <span class="bold"><strong>bufferstream</strong></span>
 336         is secure and efficient, and offers a good alternative to sprintf/sscanf
 337         functions. Let's see an example:
 338       </p>
 339 <p>
 340 </p>
 341 <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">interprocess</span><span class="special">/</span><span class="identifier">managed_shared_memory</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 342 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">interprocess</span><span class="special">/</span><span class="identifier">streams</span><span class="special">/</span><span class="identifier">bufferstream</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 343 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
 344 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>
 345 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cstddef</span><span class="special">&gt;</span>
 346
 347 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">interprocess</span><span class="special">;</span>
 348
 349 <span class="keyword">int</span> <span class="identifier">main</span> <span class="special">()</span>
 350 <span class="special">{</span>
 351    <span class="comment">//Remove shared memory on construction and destruction</span>
 352    <span class="keyword">struct</span> <span class="identifier">shm_remove</span>
 353    <span class="special">{</span>
 354       <span class="identifier">shm_remove</span><span class="special">()</span> <span class="special">{</span> <span class="identifier">shared_memory_object</span><span class="special">::</span><span class="identifier">remove</span><span class="special">(</span><span class="string">"MySharedMemory"</span><span class="special">);</span> <span class="special">}</span>
 355       <span class="special">~</span><span class="identifier">shm_remove</span><span class="special">(){</span> <span class="identifier">shared_memory_object</span><span class="special">::</span><span class="identifier">remove</span><span class="special">(</span><span class="string">"MySharedMemory"</span><span class="special">);</span> <span class="special">}</span>
 356    <span class="special">}</span> <span class="identifier">remover</span><span class="special">;</span>
 357
 358    <span class="comment">//Create shared memory</span>
 359    <span class="identifier">managed_shared_memory</span> <span class="identifier">segment</span><span class="special">(</span><span class="identifier">create_only</span><span class="special">,</span>
 360                                  <span class="string">"MySharedMemory"</span><span class="special">,</span>  <span class="comment">//segment name</span>
 361                                  <span class="number">65536</span><span class="special">);</span>
 362
 363    <span class="comment">//Fill data</span>
 364    <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">data</span><span class="special">;</span>
 365    <span class="identifier">data</span><span class="special">.</span><span class="identifier">reserve</span><span class="special">(</span><span class="number">100</span><span class="special">);</span>
 366    <span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">100</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">){</span>
 367       <span class="identifier">data</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">i</span><span class="special">);</span>
 368    <span class="special">}</span>
 369    <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">BufferSize</span> <span class="special">=</span> <span class="number">100</span><span class="special">*</span><span class="number">5</span><span class="special">;</span>
 370
 371    <span class="comment">//Allocate a buffer in shared memory to write data</span>
 372    <span class="keyword">char</span> <span class="special">*</span><span class="identifier">my_cstring</span> <span class="special">=</span>
 373       <span class="identifier">segment</span><span class="special">.</span><span class="identifier">construct</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;(</span><span class="string">"MyCString"</span><span class="special">)[</span><span class="identifier">BufferSize</span><span class="special">](</span><span class="number">0</span><span class="special">);</span>
 374    <span class="identifier">bufferstream</span> <span class="identifier">mybufstream</span><span class="special">(</span><span class="identifier">my_cstring</span><span class="special">,</span> <span class="identifier">BufferSize</span><span class="special">);</span>
 375
 376    <span class="comment">//Now write data to the buffer</span>
 377    <span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">100</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">){</span>
 378       <span class="identifier">mybufstream</span> <span class="special">&lt;&lt;</span> <span class="identifier">data</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 379    <span class="special">}</span>
 380
 381    <span class="comment">//Check there was no overflow attempt</span>
 382    <span class="identifier">assert</span><span class="special">(</span><span class="identifier">mybufstream</span><span class="special">.</span><span class="identifier">good</span><span class="special">());</span>
 383
 384    <span class="comment">//Extract all values from the shared memory string</span>
 385    <span class="comment">//directly to a vector.</span>
 386    <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">data2</span><span class="special">;</span>
 387    <span class="identifier">std</span><span class="special">::</span><span class="identifier">istream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">it</span><span class="special">(</span><span class="identifier">mybufstream</span><span class="special">),</span> <span class="identifier">itend</span><span class="special">;</span>
 388    <span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">it</span><span class="special">,</span> <span class="identifier">itend</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">back_inserter</span><span class="special">(</span><span class="identifier">data2</span><span class="special">));</span>
 389
 390    <span class="comment">//This extraction should have ended will fail error since</span>
 391    <span class="comment">//the numbers formatted in the buffer end before the end</span>
 392    <span class="comment">//of the buffer. (Otherwise it would trigger eofbit)</span>
 393    <span class="identifier">assert</span><span class="special">(</span><span class="identifier">mybufstream</span><span class="special">.</span><span class="identifier">fail</span><span class="special">());</span>
 394
 395    <span class="comment">//Compare data</span>
 396    <span class="identifier">assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal</span><span class="special">(</span><span class="identifier">data</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">data</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">data2</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()));</span>
 397
 398    <span class="comment">//Clear errors and rewind</span>
 399    <span class="identifier">mybufstream</span><span class="special">.</span><span class="identifier">clear</span><span class="special">();</span>
 400    <span class="identifier">mybufstream</span><span class="special">.</span><span class="identifier">seekp</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios</span><span class="special">::</span><span class="identifier">beg</span><span class="special">);</span>
 401
 402    <span class="comment">//Now write again the data trying to do a buffer overflow</span>
 403    <span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">m</span> <span class="special">=</span> <span class="identifier">data</span><span class="special">.</span><span class="identifier">size</span><span class="special">()*</span><span class="number">5</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">m</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">){</span>
 404       <span class="identifier">mybufstream</span> <span class="special">&lt;&lt;</span> <span class="identifier">data</span><span class="special">[</span><span class="identifier">i</span><span class="special">%</span><span class="number">5</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 405    <span class="special">}</span>
 406
 407    <span class="comment">//Now make sure badbit is active</span>
 408    <span class="comment">//which means overflow attempt.</span>
 409    <span class="identifier">assert</span><span class="special">(!</span><span class="identifier">mybufstream</span><span class="special">.</span><span class="identifier">good</span><span class="special">());</span>
 410    <span class="identifier">assert</span><span class="special">(</span><span class="identifier">mybufstream</span><span class="special">.</span><span class="identifier">bad</span><span class="special">());</span>
 411    <span class="identifier">segment</span><span class="special">.</span><span class="identifier">destroy_ptr</span><span class="special">(</span><span class="identifier">my_cstring</span><span class="special">);</span>
 412    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 413 <span class="special">}</span>
 414 </pre>
 415 <p>
 416       </p>
 417 <p>
 418         As seen, <span class="bold"><strong>bufferstream</strong></span> offers an efficient
 419         way to format data without any allocation and extra copies. This is very
 420         helpful in embedded systems, or formatting inside time-critical loops, where
 421         stringstream extra copies would be too expensive. Unlike sprintf/sscanf,
 422         it has protection against buffer overflows. As we know, according to the
 423         <span class="bold"><strong>Technical Report on C++ Performance</strong></span>, it's
 424         possible to design efficient iostreams for embedded platforms, so this bufferstream
 425         class comes handy to format data to stack, static or shared memory buffers.
 426       </p>
 427 </div>
 428 </div>
 429 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 430 <td align="left"></td>
 431 <td align="right"><div class="copyright-footer">Copyright &#169; 2005-2012 Ion Gaztanaga<p>
 432         Distributed under the Boost Software License, Version 1.0. (See accompanying
 433         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
 434       </p>
 435 </div></td>
 436 </tr></table>
 437 <hr>
 438 <div class="spirit-nav">
 439 <a accesskey="p" href="memory_algorithms.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../interprocess.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="interprocess_smart_ptr.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
 440 </div>
 441 </body>
 442 </html>