← Back to branch summary

~ubuntu-branches/debian/sid/boost1.49/sid

« back to all changes in this revision

Viewing changes to libs/proto/doc/reference/debug.xml

  • Committer: Package Import Robot
  • Author(s): Steve M. Robbins
  • Date: 2012-02-26 00:31:44 UTC
  • Revision ID: package-import@ubuntu.com-20120226003144-eaytp12cbf6ubpms
Tags: upstream-1.49.0
ImportĀ upstreamĀ versionĀ 1.49.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/proto/doc/reference/debug.xml
 
1
ļ»æ<?xml version="1.0" encoding="utf-8"?>
 
2
<!--
 
3
  Copyright 2012 Eric Niebler
 
4
 
 
5
  Distributed under the Boost
 
6
  Software License, Version 1.0. (See accompanying
 
7
  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
8
  -->
 
9
<header name="boost/proto/debug.hpp">
 
10
  <para>Utilities for debugging Proto expression trees </para>
 
11
  <namespace name="boost">
 
12
    <namespace name="proto">
 
13
      <namespace name="functional">
 
14
 
 
15
        <!-- proto::functional::display_expr -->
 
16
        <struct name="display_expr">
 
17
          <purpose>Pretty-print a Proto expression tree. </purpose>
 
18
          <description>
 
19
            <para>
 
20
              A <conceptname>PolymorphicFunctionObject</conceptname> which accepts a Proto expression tree and pretty-prints it to an <computeroutput>ostream</computeroutput> for debugging purposes.
 
21
            </para>
 
22
          </description>
 
23
 
 
24
          <typedef name="result_type">
 
25
            <type>void</type>
 
26
          </typedef>
 
27
 
 
28
          <method-group name="public member functions">
 
29
            <method name="operator()" cv="const">
 
30
              <type>void</type>
 
31
              <template>
 
32
                <template-type-parameter name="Expr"/>
 
33
              </template>
 
34
              <parameter name="expr">
 
35
                <paramtype>Expr const &amp;</paramtype>
 
36
              </parameter>
 
37
            </method>
 
38
          </method-group>
 
39
 
 
40
          <constructor>
 
41
            <parameter name="sout"><paramtype>std::ostream &amp;</paramtype><default>std::cout</default>
 
42
              <description>
 
43
                <para>
 
44
                  The <computeroutput>ostream</computeroutput> to which the expression tree will be written.
 
45
                </para>
 
46
              </description>
 
47
            </parameter>
 
48
            <parameter name="depth">
 
49
              <paramtype>int</paramtype>
 
50
              <default>0</default>
 
51
              <description>
 
52
                <para>
 
53
                  The starting indentation depth for this node. Children nodes will be displayed at a starting depth of <computeroutput>depth+4</computeroutput>.
 
54
                </para>
 
55
              </description>
 
56
            </parameter>
 
57
          </constructor>
 
58
        </struct>
 
59
 
 
60
      </namespace>
 
61
 
 
62
      <!-- proto::display_expr -->
 
63
      <overloaded-function name="display_expr">
 
64
 
 
65
        <signature>
 
66
          <type>void</type>
 
67
          <template>
 
68
            <template-type-parameter name="Expr"/>
 
69
          </template>
 
70
          <parameter name="expr">
 
71
            <paramtype>Expr const &amp;</paramtype>
 
72
            <description>
 
73
              <para>The Proto expression tree to pretty-print </para>
 
74
            </description>
 
75
          </parameter>
 
76
          <parameter name="sout">
 
77
            <paramtype>std::ostream &amp;</paramtype>
 
78
            <description>
 
79
              <para>
 
80
                The <computeroutput>ostream</computeroutput> to which the output should be written. If not specified, defaults to <computeroutput>std::cout</computeroutput>.
 
81
              </para>
 
82
            </description>
 
83
          </parameter>
 
84
        </signature>
 
85
 
 
86
        <signature>
 
87
          <type>void</type>
 
88
          <template>
 
89
            <template-type-parameter name="Expr"/>
 
90
          </template>
 
91
          <parameter name="expr">
 
92
            <paramtype>Expr const &amp;</paramtype>
 
93
          </parameter>
 
94
        </signature>
 
95
        <purpose>Pretty-print a Proto expression tree. </purpose>
 
96
        <notes>
 
97
          <para>
 
98
            Equivalent to <computeroutput><classname alt="boost::proto::functional::display_expr">proto::functional::display_expr</classname>(0, sout)(expr)</computeroutput>.
 
99
          </para>
 
100
        </notes>
 
101
      </overloaded-function>
 
102
 
 
103
      <!-- proto::assert_matches -->
 
104
      <function name="assert_matches">
 
105
        <type>void</type>
 
106
        <template>
 
107
          <template-type-parameter name="Grammar"/>
 
108
          <template-type-parameter name="Expr"/>
 
109
        </template>
 
110
        <parameter name="expr">
 
111
          <paramtype>Expr const &amp;</paramtype>
 
112
          <purpose>
 
113
            The Proto expression to check againts <code>Grammar</code>.
 
114
          </purpose>
 
115
        </parameter>
 
116
        <purpose>
 
117
          Assert at compile time that a particular expression
 
118
          matches the specified grammar.
 
119
        </purpose>
 
120
        <notes>
 
121
          <para>
 
122
            Equivalent to <code>BOOST_MPL_ASSERT((<classname alt="proto::matches">proto::matches</classname>&lt;Expr, Grammar&gt;))</code>.
 
123
          </para>
 
124
        </notes>
 
125
        <description>
 
126
          <para>
 
127
            Use <code>proto::assert_matches()</code> to assert at compile-time that
 
128
            an expression matches a grammar. 
 
129
          </para>
 
130
          <para>
 
131
            <emphasis role="bold">Example:</emphasis><programlisting>typedef proto::plus&lt; proto::terminal&lt; int &gt;, proto::terminal&lt; int &gt; &gt; PlusInts;
 
132
 
 
133
proto::assert_matches&lt;PlusInts&gt;( <functionname>proto::lit</functionname>(1) + 42 );</programlisting>
 
134
          </para>
 
135
          <para>
 
136
            See also:
 
137
            <itemizedlist>
 
138
              <listitem>
 
139
                <code><functionname>proto::assert_matches_not</functionname>()</code>
 
140
              </listitem>
 
141
              <listitem>
 
142
                <code><macroname>BOOST_PROTO_ASSERT_MATCHES</macroname>()</code>
 
143
              </listitem>
 
144
              <listitem>
 
145
                <code><macroname>BOOST_PROTO_ASSERT_MATCHES_NOT</macroname>()</code>
 
146
              </listitem>
 
147
            </itemizedlist>
 
148
          </para>
 
149
        </description>
 
150
      </function>
 
151
 
 
152
      <!-- proto::assert_matches_not -->
 
153
      <function name="assert_matches_not">
 
154
        <type>void</type>
 
155
        <template>
 
156
          <template-type-parameter name="Grammar"/>
 
157
          <template-type-parameter name="Expr"/>
 
158
        </template>
 
159
        <parameter name="expr">
 
160
          <paramtype>Expr const &amp;</paramtype>
 
161
          <purpose>
 
162
            The Proto expression to check againts <code>Grammar</code>.
 
163
          </purpose>
 
164
        </parameter>
 
165
        <purpose>
 
166
          Assert at compile time that a particular expression
 
167
          does not match the specified grammar.
 
168
        </purpose>
 
169
        <notes>
 
170
          <para>
 
171
            Equivalent to <code>BOOST_MPL_ASSERT_NOT((<classname alt="proto::matches">proto::matches</classname>&lt;Expr, Grammar&gt;))</code>.
 
172
          </para>
 
173
        </notes>
 
174
        <description>
 
175
          <para>
 
176
            Use <code>proto::assert_matches_not()</code> to assert at compile-time that
 
177
            an expression does not match a grammar. 
 
178
          </para>
 
179
          <para>
 
180
            <emphasis role="bold">Example:</emphasis><programlisting>typedef proto::plus&lt; proto::terminal&lt; int &gt;, proto::terminal&lt; int &gt; &gt; PlusInts;
 
181
 
 
182
proto::assert_matches_not&lt;PlusInts&gt;( <functionname>proto::lit</functionname>("a string") + 42 );</programlisting>
 
183
          </para>
 
184
          <para>
 
185
            See also:
 
186
            <itemizedlist>
 
187
              <listitem>
 
188
                <code><functionname>proto::assert_matches</functionname>()</code>
 
189
              </listitem>
 
190
              <listitem>
 
191
                <code><macroname>BOOST_PROTO_ASSERT_MATCHES</macroname>()</code>
 
192
              </listitem>
 
193
              <listitem>
 
194
                <code><macroname>BOOST_PROTO_ASSERT_MATCHES_NOT</macroname>()</code>
 
195
              </listitem>
 
196
            </itemizedlist>
 
197
          </para>
 
198
        </description>
 
199
      </function>
 
200
    </namespace>
 
201
  </namespace>
 
202
 
 
203
  <macro name="BOOST_PROTO_ASSERT_MATCHES" kind="functionlike">
 
204
    <macro-parameter name="expr"/>
 
205
    <macro-parameter name="Grammar"/>
 
206
    <purpose>
 
207
      Assert at compile time that a particular expression
 
208
      matches the specified grammar.
 
209
    </purpose>
 
210
    <notes>
 
211
      <para>
 
212
        Equivalent to <code><functionname alt="boost::proto::assert_matches">proto::assert_matches</functionname>&lt;Grammar&gt;(expr)</code>.
 
213
      </para>
 
214
    </notes>
 
215
    <description>
 
216
      <para>
 
217
        Use <code>BOOST_PROTO_ASSERT_MATCHES()</code> to assert at compile-time that
 
218
        an expression matches a grammar.
 
219
      </para>
 
220
      <para>
 
221
        <emphasis role="bold">Example:</emphasis><programlisting>typedef <classname alt="boost::proto::plus">proto::plus</classname>&lt; <classname alt="boost::proto::terminal">proto::terminal</classname>&lt; int &gt;, <classname alt="boost::proto::terminal">proto::terminal</classname>&lt; int &gt; &gt; PlusInts;
 
222
 
 
223
BOOST_PROTO_ASSERT_MATCHES( <functionname alt="boost::proto::lit">proto::lit</functionname>(1) + 42, PlusInts );</programlisting>
 
224
      </para>
 
225
      <para>
 
226
        See also:
 
227
        <itemizedlist>
 
228
          <listitem>
 
229
            <code><functionname alt="boost::proto::assert_matches">proto::assert_matches</functionname>()</code>
 
230
          </listitem>
 
231
          <listitem>
 
232
            <code><functionname alt="boost::proto::assert_matches_not">proto::assert_matches_not</functionname>()</code>
 
233
          </listitem>
 
234
          <listitem>
 
235
            <code><macroname>BOOST_PROTO_ASSERT_MATCHES_NOT</macroname>()</code>
 
236
          </listitem>
 
237
        </itemizedlist>
 
238
      </para>
 
239
    </description>
 
240
  </macro>
 
241
 
 
242
  <macro name="BOOST_PROTO_ASSERT_MATCHES_NOT" kind="functionlike">
 
243
    <macro-parameter name="expr"/>
 
244
    <macro-parameter name="Grammar"/>
 
245
    <purpose>
 
246
      Assert at compile time that a particular expression
 
247
      does not match the specified grammar.
 
248
    </purpose>
 
249
    <notes>
 
250
      <para>
 
251
        Equivalent to <code><functionname alt="boost::proto::assert_matches_not">proto::assert_matches_not</functionname>&lt;Grammar&gt;(expr)</code>.
 
252
      </para>
 
253
    </notes>
 
254
    <description>
 
255
      <para>
 
256
        Use <code>BOOST_PROTO_ASSERT_MATCHES_NOT()</code> to assert at compile-time that
 
257
        an expression does not match a grammar. 
 
258
      </para>
 
259
      <para>
 
260
        <emphasis role="bold">Example:</emphasis><programlisting>typedef <classname alt="boost::proto::plus">proto::plus</classname>&lt; <classname alt="boost::proto::terminal">proto::terminal</classname>&lt; int &gt;, <classname alt="boost::proto::terminal">proto::terminal</classname>&lt; int &gt; &gt; PlusInts;
 
261
 
 
262
BOOST_PROTO_ASSERT_MATCHES_NOT( <functionname alt="boost::proto::lit">proto::lit</functionname>("a string") + 42, PlusInts );</programlisting>
 
263
      </para>
 
264
      <para>
 
265
        See also:
 
266
        <itemizedlist>
 
267
          <listitem>
 
268
            <code><functionname alt="boost::proto::assert_matches">proto::assert_matches</functionname>()</code>
 
269
          </listitem>
 
270
          <listitem>
 
271
            <code><functionname alt="boost::proto::assert_matches_not">proto::assert_matches_not</functionname>()</code>
 
272
          </listitem>
 
273
          <listitem>
 
274
            <code><macroname>BOOST_PROTO_ASSERT_MATCHES</macroname>()</code>
 
275
          </listitem>
 
276
        </itemizedlist>
 
277
      </para>
 
278
    </description>
 
279
  </macro>
 
280
</header>