ceph/src/boost/libs/phoenix/doc/html/phoenix/modules/operator.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Operator</title>
   5 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
   7 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Phoenix 3.2.0">
   8 <link rel="up" href="../modules.html" title="Modules">
   9 <link rel="prev" href="function/adapting_functions.html" title="Adapting Functions">
  10 <link rel="next" href="statement.html" title="Statement">
  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="function/adapting_functions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../modules.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="statement.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h3 class="title">
  27 <a name="phoenix.modules.operator"></a><a class="link" href="operator.html" title="Operator">Operator</a>
  28 </h3></div></div></div>
  29 <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">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
  30 </pre>
  31 <p>
  32         This facility provides a mechanism for lazily evaluating operators. Syntactically,
  33         a lazy operator looks and feels like an ordinary C/C++ infix, prefix or postfix
  34         operator. The operator application looks the same. However, unlike ordinary
  35         operators, the actual operator execution is deferred. Samples:
  36       </p>
  37 <pre class="programlisting"><span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span>
  38 <span class="number">1</span> <span class="special">+</span> <span class="identifier">arg1</span> <span class="special">*</span> <span class="identifier">arg2</span>
  39 <span class="number">1</span> <span class="special">/</span> <span class="special">-</span><span class="identifier">arg1</span>
  40 <span class="identifier">arg1</span> <span class="special">&lt;</span> <span class="number">150</span>
  41 </pre>
  42 <p>
  43         We have seen the lazy operators in action (see <a class="link" href="../starter_kit/lazy_operators.html" title="Lazy Operators">Quick
  44         Start - Lazy Operators</a>). Let's go back and examine them a little bit
  45         further:
  46       </p>
  47 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">find_if</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">arg1</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">1</span><span class="special">)</span>
  48 </pre>
  49 <p>
  50         Through operator overloading, the expression <code class="computeroutput"><span class="identifier">arg1</span>
  51         <span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">1</span></code> actually
  52         generates an actor. This actor object is passed on to STL's <code class="computeroutput"><span class="identifier">find_if</span></code> function. From the viewpoint of
  53         STL, the expression is simply a function object expecting a single argument
  54         of the containers value_type. For each element in <code class="computeroutput"><span class="identifier">c</span></code>,
  55         the element is passed on as an argument <code class="computeroutput"><span class="identifier">arg1</span></code>
  56         to the actor (function object). The actor checks if this is an odd value
  57         based on the expression <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span>
  58         <span class="number">1</span></code> where arg1 is replaced by the container's
  59         element.
  60       </p>
  61 <p>
  62         Like lazy functions (see <a class="link" href="function.html" title="Function">Function</a>),
  63         lazy operators are not immediately executed when invoked. Instead, an actor
  64         (see <a class="link" href="../actor.html" title="Actor">Actor</a>) object is created and returned
  65         to the caller. Example:
  66       </p>
  67 <pre class="programlisting"><span class="special">(</span><span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">arg3</span>
  68 </pre>
  69 <p>
  70         does nothing more than return an actor. A second function call will evaluate
  71         the actual operators. Example:
  72       </p>
  73 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="special">((</span><span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">arg3</span><span class="special">)(</span><span class="number">4</span><span class="special">,</span> <span class="number">5</span><span class="special">,</span> <span class="number">6</span><span class="special">);</span>
  74 </pre>
  75 <p>
  76         will print out "54".
  77       </p>
  78 <p>
  79         Operator expressions are lazily evaluated following four simple rules:
  80       </p>
  81 <div class="orderedlist"><ol class="orderedlist" type="1">
  82 <li class="listitem">
  83             A binary operator, except <code class="computeroutput"><span class="special">-&gt;*</span></code>
  84             will be lazily evaluated when <span class="emphasis"><em>at least</em></span> one of its
  85             operands is an actor object (see <a class="link" href="../actor.html" title="Actor">Actor</a>).
  86           </li>
  87 <li class="listitem">
  88             Unary operators are lazily evaluated if their argument is an actor object.
  89           </li>
  90 <li class="listitem">
  91             Operator <code class="computeroutput"><span class="special">-&gt;*</span></code> is lazily
  92             evaluated if the left hand argument is an actor object.
  93           </li>
  94 <li class="listitem">
  95             The result of a lazy operator is an actor object that can in turn allow
  96             the applications of rules 1, 2 and 3.
  97           </li>
  98 </ol></div>
  99 <p>
 100         For example, to check the following expression is lazily evaluated:
 101       </p>
 102 <pre class="programlisting"><span class="special">-(</span><span class="identifier">arg1</span> <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="number">6</span><span class="special">)</span>
 103 </pre>
 104 <div class="orderedlist"><ol class="orderedlist" type="1">
 105 <li class="listitem">
 106             Following rule 1, <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">+</span> <span class="number">3</span></code> is
 107             lazily evaluated since <code class="computeroutput"><span class="identifier">arg1</span></code>
 108             is an actor (see <a class="link" href="core/arguments.html" title="Arguments">Arguments</a>).
 109           </li>
 110 <li class="listitem">
 111             The result of this <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">+</span> <span class="number">3</span></code> expression
 112             is an actor object, following rule 4.
 113           </li>
 114 <li class="listitem">
 115             Continuing, <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">+</span>
 116             <span class="number">3</span> <span class="special">+</span> <span class="number">6</span></code> is again lazily evaluated. Rule 2.
 117           </li>
 118 <li class="listitem">
 119             By rule 4 again, the result of <code class="computeroutput"><span class="identifier">arg1</span>
 120             <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="number">6</span></code> is
 121             an actor object.
 122           </li>
 123 <li class="listitem">
 124             As <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">+</span>
 125             <span class="number">3</span> <span class="special">+</span> <span class="number">6</span></code> is an actor, <code class="computeroutput"><span class="special">-(</span><span class="identifier">arg1</span> <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="number">6</span><span class="special">)</span></code> is lazily evaluated. Rule 2.
 126           </li>
 127 </ol></div>
 128 <p>
 129         Lazy-operator application is highly contagious. In most cases, a single
 130         <code class="computeroutput"><span class="identifier">argN</span></code> actor infects all its
 131         immediate neighbors within a group (first level or parenthesized expression).
 132       </p>
 133 <p>
 134         Note that at least one operand of any operator must be a valid actor for
 135         lazy evaluation to take effect. To force lazy evaluation of an ordinary expression,
 136         we can use <code class="computeroutput"><span class="identifier">ref</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>, <code class="computeroutput"><span class="identifier">val</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code> or <code class="computeroutput"><span class="identifier">cref</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
 137         to transform an operand into a valid actor object (see <a class="link" href="core.html" title="Core">Core</a>).
 138         For example:
 139       </p>
 140 <pre class="programlisting"><span class="number">1</span> <span class="special">&lt;&lt;</span> <span class="number">3</span><span class="special">;</span>      <span class="comment">// Immediately evaluated</span>
 141 <span class="identifier">val</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="number">3</span><span class="special">;</span> <span class="comment">// Lazily evaluated</span>
 142 </pre>
 143 <h5>
 144 <a name="phoenix.modules.operator.h0"></a>
 145         <span><a name="phoenix.modules.operator.supported_operators"></a></span><a class="link" href="operator.html#phoenix.modules.operator.supported_operators">Supported
 146         operators</a>
 147       </h5>
 148 <h5>
 149 <a name="phoenix.modules.operator.h1"></a>
 150         <span><a name="phoenix.modules.operator.unary_operators"></a></span><a class="link" href="operator.html#phoenix.modules.operator.unary_operators">Unary
 151         operators</a>
 152       </h5>
 153 <pre class="programlisting"><span class="identifier">prefix</span><span class="special">:</span>   <span class="special">~,</span> <span class="special">!,</span> <span class="special">-,</span> <span class="special">+,</span> <span class="special">++,</span> <span class="special">--,</span> <span class="special">&amp;</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">),</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">dereference</span><span class="special">)</span>
 154 <span class="identifier">postfix</span><span class="special">:</span>  <span class="special">++,</span> <span class="special">--</span>
 155 </pre>
 156 <h5>
 157 <a name="phoenix.modules.operator.h2"></a>
 158         <span><a name="phoenix.modules.operator.binary_operators"></a></span><a class="link" href="operator.html#phoenix.modules.operator.binary_operators">Binary
 159         operators</a>
 160       </h5>
 161 <pre class="programlisting"><span class="special">=,</span> <span class="special">[],</span> <span class="special">+=,</span> <span class="special">-=,</span> <span class="special">*=,</span> <span class="special">/=,</span> <span class="special">%=,</span> <span class="special">&amp;=,</span> <span class="special">|=,</span> <span class="special">^=,</span> <span class="special">&lt;&lt;=,</span> <span class="special">&gt;&gt;=</span>
 162 <span class="special">+,</span> <span class="special">-,</span> <span class="special">*,</span> <span class="special">/,</span> <span class="special">%,</span> <span class="special">&amp;,</span> <span class="special">|,</span> <span class="special">^,</span> <span class="special">&lt;&lt;,</span> <span class="special">&gt;&gt;</span>
 163 <span class="special">==,</span> <span class="special">!=,</span> <span class="special">&lt;,</span> <span class="special">&gt;,</span> <span class="special">&lt;=,</span> <span class="special">&gt;=</span>
 164 <span class="special">&amp;&amp;,</span> <span class="special">||,</span> <span class="special">-&gt;*</span>
 165 </pre>
 166 <h5>
 167 <a name="phoenix.modules.operator.h3"></a>
 168         <span><a name="phoenix.modules.operator.ternary_operator"></a></span><a class="link" href="operator.html#phoenix.modules.operator.ternary_operator">Ternary
 169         operator</a>
 170       </h5>
 171 <pre class="programlisting"><span class="identifier">if_else</span><span class="special">(</span><span class="identifier">c</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">)</span>
 172 </pre>
 173 <p>
 174         The ternary operator deserves special mention. Since C++ does not allow us
 175         to overload the conditional expression: <code class="computeroutput"><span class="identifier">c</span>
 176         <span class="special">?</span> <span class="identifier">a</span> <span class="special">:</span> <span class="identifier">b</span></code>, the
 177         if_else pseudo function is provided for this purpose. The behavior is identical,
 178         albeit in a lazy manner.
 179       </p>
 180 <h5>
 181 <a name="phoenix.modules.operator.h4"></a>
 182         <span><a name="phoenix.modules.operator.member_pointer_operator"></a></span><a class="link" href="operator.html#phoenix.modules.operator.member_pointer_operator">Member
 183         pointer operator</a>
 184       </h5>
 185 <pre class="programlisting"><span class="identifier">a</span><span class="special">-&gt;*</span><span class="identifier">member_object_pointer</span>
 186 <span class="identifier">a</span><span class="special">-&gt;*</span><span class="identifier">member_function_pointer</span>
 187 </pre>
 188 <p>
 189         The left hand side of the member pointer operator must be an actor returning
 190         a pointer type. The right hand side of the member pointer operator may be
 191         either a pointer to member object or pointer to member function.
 192       </p>
 193 <p>
 194         If the right hand side is a member object pointer, the result is an actor
 195         which, when evaluated, returns a reference to that member. For example:
 196       </p>
 197 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span>
 198 <span class="special">{</span>
 199     <span class="keyword">int</span> <span class="identifier">member</span><span class="special">;</span>
 200 <span class="special">};</span>
 201
 202 <span class="identifier">A</span><span class="special">*</span> <span class="identifier">a</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">A</span><span class="special">;</span>
 203 <span class="special">...</span>
 204
 205 <span class="special">(</span><span class="identifier">arg1</span><span class="special">-&gt;*&amp;</span><span class="identifier">A</span><span class="special">::</span><span class="identifier">member</span><span class="special">)(</span><span class="identifier">a</span><span class="special">);</span> <span class="comment">// returns member a-&gt;member</span>
 206 </pre>
 207 <p>
 208         If the right hand side is a member function pointer, the result is an actor
 209         which, when invoked, calls the specified member function. For example:
 210       </p>
 211 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span>
 212 <span class="special">{</span>
 213     <span class="keyword">int</span> <span class="identifier">func</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
 214 <span class="special">};</span>
 215
 216 <span class="identifier">A</span><span class="special">*</span> <span class="identifier">a</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">A</span><span class="special">;</span>
 217 <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
 218
 219 <span class="special">(</span><span class="identifier">arg1</span><span class="special">-&gt;*&amp;</span><span class="identifier">A</span><span class="special">::</span><span class="identifier">func</span><span class="special">)(</span><span class="identifier">arg2</span><span class="special">)(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">i</span><span class="special">);</span> <span class="comment">// returns a-&gt;func(i)</span>
 220 </pre>
 221 <h5>
 222 <a name="phoenix.modules.operator.h5"></a>
 223         <span><a name="phoenix.modules.operator.include_files"></a></span><a class="link" href="operator.html#phoenix.modules.operator.include_files">Include
 224         Files</a>
 225       </h5>
 226 <div class="informaltable"><table class="table">
 227 <colgroup>
 228 <col>
 229 <col>
 230 </colgroup>
 231 <thead><tr>
 232 <th>
 233                 <p>
 234                   Operators
 235                 </p>
 236               </th>
 237 <th>
 238                 <p>
 239                   File
 240                 </p>
 241               </th>
 242 </tr></thead>
 243 <tbody>
 244 <tr>
 245 <td>
 246                 <p>
 247                   <code class="computeroutput"><span class="special">-</span></code>, <code class="computeroutput"><span class="special">+</span></code>,
 248                   <code class="computeroutput"><span class="special">++</span></code>, <code class="computeroutput"><span class="special">--</span></code>, <code class="computeroutput"><span class="special">+=</span></code>,
 249                   <code class="computeroutput"><span class="special">-=</span></code>, <code class="computeroutput"><span class="special">*=</span></code>, <code class="computeroutput"><span class="special">/=</span></code>,
 250                   <code class="computeroutput"><span class="special">%=</span></code>, <code class="computeroutput"><span class="special">*</span></code>, <code class="computeroutput"><span class="special">/</span></code>,
 251                   <code class="computeroutput"><span class="special">%</span></code>
 252                 </p>
 253               </td>
 254 <td>
 255                 <p>
 256                   <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">arithmetic</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 257                 </p>
 258               </td>
 259 </tr>
 260 <tr>
 261 <td>
 262                 <p>
 263                   <code class="computeroutput"><span class="special">&amp;=</span></code>, <code class="computeroutput"><span class="special">|=</span></code>, <code class="computeroutput"><span class="special">^=</span></code>,
 264                   <code class="computeroutput"><span class="special">&lt;&lt;=</span></code>, <code class="computeroutput"><span class="special">&gt;&gt;=</span></code>, <code class="computeroutput"><span class="special">&amp;</span></code>,
 265                   <code class="computeroutput"><span class="special">|</span></code>, <code class="computeroutput"><span class="special">^</span></code>,
 266                   <code class="computeroutput"><span class="special">&lt;&lt;</span></code>, <code class="computeroutput"><span class="special">&gt;&gt;</span></code>
 267                 </p>
 268               </td>
 269 <td>
 270                 <p>
 271                   <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">bitwise</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 272                 </p>
 273               </td>
 274 </tr>
 275 <tr>
 276 <td>
 277                 <p>
 278                   <code class="computeroutput"><span class="special">==</span></code>, <code class="computeroutput"><span class="special">!=</span></code>, <code class="computeroutput"><span class="special">&lt;</span></code>,
 279                   <code class="computeroutput"><span class="special">&lt;=</span></code>, <code class="computeroutput"><span class="special">&gt;</span></code>, <code class="computeroutput"><span class="special">&gt;=</span></code>
 280                 </p>
 281               </td>
 282 <td>
 283                 <p>
 284                   <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">comparison</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 285                 </p>
 286               </td>
 287 </tr>
 288 <tr>
 289 <td>
 290                 <p>
 291                   <code class="computeroutput"><span class="special">&lt;&lt;</span></code>, <code class="computeroutput"><span class="special">&gt;&gt;</span></code>
 292                 </p>
 293               </td>
 294 <td>
 295                 <p>
 296                   <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 297                 </p>
 298               </td>
 299 </tr>
 300 <tr>
 301 <td>
 302                 <p>
 303                   <code class="computeroutput"><span class="special">!</span></code>, &amp;&amp;, <code class="computeroutput"><span class="special">||</span></code>
 304                 </p>
 305               </td>
 306 <td>
 307                 <p>
 308                   <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">logical</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 309                 </p>
 310               </td>
 311 </tr>
 312 <tr>
 313 <td>
 314                 <p>
 315                   <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span></code>,
 316                   <code class="computeroutput"><span class="special">*</span><span class="identifier">p</span></code>,
 317                   <code class="computeroutput"><span class="special">=</span></code>, <code class="computeroutput"><span class="special">[]</span></code>
 318                 </p>
 319               </td>
 320 <td>
 321                 <p>
 322                   <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 323                 </p>
 324               </td>
 325 </tr>
 326 <tr>
 327 <td>
 328                 <p>
 329                   <code class="computeroutput"><span class="identifier">if_else</span><span class="special">(</span><span class="identifier">c</span><span class="special">,</span>
 330                   <span class="identifier">a</span><span class="special">,</span>
 331                   <span class="identifier">b</span><span class="special">)</span></code>
 332                 </p>
 333               </td>
 334 <td>
 335                 <p>
 336                   <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">if_else</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 337                 </p>
 338               </td>
 339 </tr>
 340 <tr>
 341 <td>
 342                 <p>
 343                   <code class="computeroutput"><span class="special">-&gt;*</span></code>
 344                 </p>
 345               </td>
 346 <td>
 347                 <p>
 348                   <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 349                 </p>
 350               </td>
 351 </tr>
 352 </tbody>
 353 </table></div>
 354 </div>
 355 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 356 <td align="left"></td>
 357 <td align="right"><div class="copyright-footer">Copyright &#169; 2002-2005, 2010, 2014, 2015 Joel de Guzman, Dan Marsden, Thomas
 358       Heller, John Fletcher<p>
 359         Distributed under the Boost Software License, Version 1.0. (See accompanying
 360         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>)
 361       </p>
 362 </div></td>
 363 </tr></table>
 364 <hr>
 365 <div class="spirit-nav">
 366 <a accesskey="p" href="function/adapting_functions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../modules.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="statement.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 367 </div>
 368 </body>
 369 </html>