123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510 |
- <html>
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
- <title>Generic macros for working with data types</title>
- <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
- <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
- <link rel="home" href="../index.html" title="Chapter 1. The Variadic Macro Data Library 1.9">
- <link rel="up" href="../index.html" title="Chapter 1. The Variadic Macro Data Library 1.9">
- <link rel="prev" href="vmd_specific/vmd_identifying.html" title="Identifying data types">
- <link rel="next" href="vmd_generic/vmd_convert_sequence.html" title="Getting the type of data">
- </head>
- <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
- <table cellpadding="2" width="100%"><tr>
- <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
- <td align="center"><a href="../../../../../index.html">Home</a></td>
- <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
- <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
- <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
- <td align="center"><a href="../../../../../more/index.htm">More</a></td>
- </tr></table>
- <hr>
- <div class="spirit-nav">
- <a accesskey="p" href="vmd_specific/vmd_identifying.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="vmd_generic/vmd_convert_sequence.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
- </div>
- <div class="section">
- <div class="titlepage"><div><div><h2 class="title" style="clear: both">
- <a name="variadic_macro_data.vmd_generic"></a><a class="link" href="vmd_generic.html" title="Generic macros for working with data types">Generic macros for working
- with data types</a>
- </h2></div></div></div>
- <div class="toc"><dl class="toc">
- <dt><span class="section"><a href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence">Parsing
- sequences</a></span></dt>
- <dd><dl>
- <dt><span class="section"><a href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_convert">Converting
- sequences</a></span></dt>
- <dt><span class="section"><a href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_access">Accessing
- a sequence element</a></span></dt>
- </dl></dd>
- <dt><span class="section"><a href="vmd_generic/vmd_convert_sequence.html">Getting
- the type of data</a></span></dt>
- <dt><span class="section"><a href="vmd_generic/vmd_assert.html">Testing for
- equality and inequality</a></span></dt>
- </dl></div>
- <p>
- Besides the specific macros for working with data types VMD has a number of
- generic macros for parsing sequences.
- </p>
- <div class="section">
- <div class="titlepage"><div><div><h3 class="title">
- <a name="variadic_macro_data.vmd_generic.vmd_sequence"></a><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence" title="Parsing sequences">Parsing
- sequences</a>
- </h3></div></div></div>
- <div class="toc"><dl class="toc">
- <dt><span class="section"><a href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_convert">Converting
- sequences</a></span></dt>
- <dt><span class="section"><a href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_access">Accessing
- a sequence element</a></span></dt>
- </dl></div>
- <p>
- In the normal use of Boost PP data is passed as arguments to a macro in discrete
- units so that each parameter expects a single data type. A typical macro
- might be:
- </p>
- <pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">AMACRO</span><span class="special">(</span><span class="identifier">anumber</span><span class="special">,</span><span class="identifier">atuple</span><span class="special">,</span><span class="identifier">anidentifier</span><span class="special">)</span> <span class="identifier">someoutput</span>
- </pre>
- <p>
- where the 'atuple', having the form of ( data1, data2, data3 ), itself may
- contain different data types of elements.
- </p>
- <p>
- This is the standard macro design and internally it is the easiest way to
- pass macro data back and forth. The Boost PP library has a rich set of functionality
- to deal with all of its high-level data types, and variadic data, with its
- own simpler functionality, also offers another alternative to representing
- data.
- </p>
- <p>
- Occasionally designers of macros, especially for the use of others programmers
- within a particular library, have expressed the need for a macro parameter
- to allow a more C/C++ like syntax where a single parameter might mimic a
- C++ function-call or a C-like type modification syntax, or some other more
- complicated construct. Something along the lines of:
- </p>
- <pre class="programlisting"><span class="identifier">areturn</span> <span class="identifier">afunction</span> <span class="special">(</span> <span class="identifier">aparameter1</span><span class="special">,</span> <span class="identifier">aparameter2</span><span class="special">,</span> <span class="identifier">aparameter3</span> <span class="special">)</span>
- </pre>
- <p>
- or
- </p>
- <pre class="programlisting"><span class="special">(</span> <span class="identifier">type</span> <span class="special">)</span> <span class="identifier">data</span>
- </pre>
- <p>
- etc. etc.
- </p>
- <p>
- In other words, from a syntactical level when designing possible macro input,
- is it possible to design parameter data to look more like C/C++ when macros
- are used in a library and still do a certain amount of preprocessor metaprogramming
- with such mixed token input ?
- </p>
- <p>
- VMD has functionality which allows more than one type of preprocessing token,
- excluding an 'empty' token which always refers to some entire input, to be
- part of a single parameter of input data. These preprocessing tokens as a
- single parameter are syntactically a consecutive series of data. The single
- limitation of this consecutive series of data is that each top-level part
- of the data of this series is of some VMD data type. What this means is that
- if some input consists of a series of data types it is possible to extract
- the data for each data type in that series.
- </p>
- <p>
- In practicality what this means is that, given the examples just above, if
- 'areturn', 'afunction', and 'data' are identifiers it would be possible to
- parse either of the two inputs above so that one could identify the different
- data types involved and do preprocessor metaprogramming based on those results.
- </p>
- <h5>
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.h0"></a>
- <span class="phrase"><a name="variadic_macro_data.vmd_generic.vmd_sequence.sequence_definition"></a></span><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.sequence_definition">Sequence
- definition</a>
- </h5>
- <p>
- I will be calling such input data, which consists of all top-level data types
- in a series, by the term of a 'sequence'. Each separate data type in the
- sequence is called an 'element'. In this definition of a 'sequence' we can
- have 0 or more elements, so that a sequence is a general name for any VMD
- input. A sequence is therefore any input VMD can parse, whether it is emptiness,
- a single element, or more than one element in a series. Therefore when we
- speak of VMD macros parsing input data we are really speaking of VMD macros
- parsing a sequence. A sequence can therefore also be part of a Boost PP composite
- data type, or variadic data, and VMD can still parse such an embedded sequence
- if asked to do so.
- </p>
- <h5>
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.h1"></a>
- <span class="phrase"><a name="variadic_macro_data.vmd_generic.vmd_sequence.sequence_parsing"></a></span><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.sequence_parsing">Sequence
- parsing</a>
- </h5>
- <p>
- Parsing a sequence means that VMD can step through each element of a sequence
- sequentially, determine the type and data of each element, then move on to
- the next element. Parsing is sequential and can only be done in a forward
- direction, but it can be done any number of times. In C++ iterator terms
- parsing of a sequence is a forward iterator.
- </p>
- <p>
- Working with a sequence is equivalent to using VMD macros 'generically'.
- </p>
- <p>
- Before I give an explanation of how to use a sequence using VMD generic functionality
- I would like to make two points:
- </p>
- <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
- <li class="listitem">
- The possibility of working with a sequence which contains more than one
- data type can be easily abused. In general keeping things simple is usually
- better than making things overly complicated when it comes to the syntactical
- side of things in a computer language. A macro parameter syntactical
- possibility has to be understandable to be used.
- </li>
- <li class="listitem">
- Using VMD to parse the individual data types of a sequence takes more
- preprocessing time than functionality offered with Boost PP data types,
- because it is based on forward access through each top-level type of
- the sequence.
- </li>
- </ul></div>
- <p>
- The one constraint in a sequence is that the top-level must consist of VMD
- data types, in other words preprocessor tokens which VMD understands. By
- top-level it is meant that a Boost PP composite data may have elements which
- VMD cannot parse but as long as the input consists of the composite data
- types and not the inner unparsable elements, VMD can parse the input. Therefore
- if preprocessor data is one of the examples above, you will be successful
- in using VMD. However if your preprocessor data takes the form of:
- </p>
- <pre class="programlisting"><span class="special">&</span><span class="identifier">name</span> <span class="identifier">identifier</span> <span class="special">(</span> <span class="identifier">param</span> <span class="special">)</span>
- </pre>
- <p>
- or
- </p>
- <pre class="programlisting"><span class="identifier">identifier</span> <span class="string">"string literal"</span>
- </pre>
- <p>
- or
- </p>
- <pre class="programlisting"><span class="identifier">identifier</span> <span class="special">+</span> <span class="identifier">number</span>
- </pre>
- <p>
- or
- </p>
- <pre class="programlisting"><span class="identifier">identifier</span> <span class="special">+=</span> <span class="number">4.3</span>
- </pre>
- <p>
- etc. etc.
- </p>
- <p>
- you will not be able to parse the data using VMD since '&', "string
- literal", '+', '+=', and "4.3" are preprocessor tokens which
- are not VMD top-level data types and therefore VMD cannot handle them at
- the parsing level. You can still of course pass such data as preprocessing
- input to macros but you cannot use VMD to recognize the parts of such data.
- </p>
- <p>
- This is similar to the fact that VMD cannot tell you what type preprocessor
- data is as a whole, using any of the VMD identifying macros already discussed,
- if the type is not one that VMD can handle.
- </p>
- <p>
- On the other hand you can still use VMD to parse such tokens in the input
- if you use Boost PP data types as top-level data types to do so. Such as:
- </p>
- <pre class="programlisting"><span class="special">(</span> <span class="special">&</span><span class="identifier">name</span> <span class="special">)</span> <span class="identifier">identifier</span> <span class="special">(</span> <span class="identifier">param</span> <span class="special">)</span>
- </pre>
- <p>
- or
- </p>
- <pre class="programlisting"><span class="identifier">identifier</span> <span class="special">(</span> <span class="string">"string literal"</span> <span class="special">)</span>
- </pre>
- <p>
- or
- </p>
- <pre class="programlisting"><span class="identifier">identifier</span> <span class="special">(</span> <span class="special">+</span> <span class="special">)</span> <span class="identifier">number</span>
- </pre>
- <p>
- or
- </p>
- <pre class="programlisting"><span class="identifier">identifier</span> <span class="special">(</span> <span class="special">+=</span> <span class="special">)</span> <span class="number">4</span> <span class="special">(</span> <span class="special">.</span> <span class="special">)</span> <span class="number">3</span>
- </pre>
- <p>
- The succeeding topics explain the VMD functionality for parsing a sequence
- for each individual VMD data type in that sequence.
- </p>
- <h5>
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.h2"></a>
- <span class="phrase"><a name="variadic_macro_data.vmd_generic.vmd_sequence.sequence_types"></a></span><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.sequence_types">Sequence
- types</a>
- </h5>
- <p>
- A VMD sequence can be seen as one of either three general types:
- </p>
- <div class="orderedlist"><ol class="orderedlist" type="1">
- <li class="listitem">
- An empty sequence
- </li>
- <li class="listitem">
- A single element sequence
- </li>
- <li class="listitem">
- A multi-element sequence
- </li>
- </ol></div>
- <p>
- An empty sequence is merely input that is empty, what VMD calls "emptiness".
- Use the previously explained BOOST_VMD_IS_EMPTY macro to test for an empty
- sequence.
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_empty</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="preprocessor">#define</span> <span class="identifier">AN_EMPTY_SEQUENCE</span>
- <span class="identifier">BOOST_VMD_IS_EMPTY</span><span class="special">(</span><span class="identifier">AN_EMPTY_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
- </pre>
- <p>
- The type of an empty sequence is BOOST_VMD_TYPE_EMPTY.
- </p>
- <p>
- A single element sequence is a single VMD data type. This is what we have
- been previously discussing as data which VMD can parse in this documentation
- with our identifying macros. You can use the BOOST_VMD_IS_UNARY macro to
- test for a single element sequence.
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_unary</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="preprocessor">#define</span> <span class="identifier">A_SINGLE_ELEMENT_SEQUENCE</span> <span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">)</span>
- <span class="identifier">BOOST_VMD_IS_UNARY</span><span class="special">(</span><span class="identifier">A_SINGLE_ELEMENT_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
- </pre>
- <p>
- The type of a single element sequence is the type of the individual data
- type. In our example above the type of A_SINGLE_ELEMENT_SEQUENCE is BOOST_VMD_TYPE_TUPLE.
- </p>
- <p>
- A multi-element sequence consists of more than one data type. This is the
- "new" type which VMD can parse. You can use the BOOST_VMD_IS_MULTI
- macro to test for a multi-element sequence.
- </p>
- <pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">A_MULTI_ELEMENT_SEQUENCE</span> <span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">)</span> <span class="special">(</span><span class="number">1</span><span class="special">)(</span><span class="number">2</span><span class="special">)</span> <span class="number">45</span>
- </pre>
- <p>
- The A_MULTI_ELEMENT_SEQUENCE consists of a tuple followed by a seq followed
- by a number.
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_multi</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="identifier">BOOST_VMD_IS_MULTI</span><span class="special">(</span><span class="identifier">A_MULTI_ELEMENT_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
- </pre>
- <p>
- The type of a multi-element sequence is always BOOST_VMD_TYPE_SEQUENCE.
- </p>
- <p>
- The type of a sequence can be obtained generically with the BOOST_VMD_GET_TYPE
- macro. We will be explaining this further in the documentation.
- </p>
- <h5>
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.h3"></a>
- <span class="phrase"><a name="variadic_macro_data.vmd_generic.vmd_sequence.sequence_size"></a></span><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.sequence_size">Sequence
- size</a>
- </h5>
- <p>
- The size of any sequence can be accessed using the BOOST_VMD_SIZE macro.
- For an empty sequence the size is always 0. For a single element sequence
- the size is always 1. For a multi-element sequence the size is the number
- of individual top-level data types in the sequence.
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">size</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="identifier">BOOST_VMD_SIZE</span><span class="special">(</span><span class="identifier">AN_EMPTY_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">0</span>
- <span class="identifier">BOOST_VMD_SIZE</span><span class="special">(</span><span class="identifier">A_SINGLE_ELEMENT_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
- <span class="identifier">BOOST_VMD_SIZE</span><span class="special">(</span><span class="identifier">A_MULTI_ELEMENT_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">3</span>
- </pre>
- <h5>
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.h4"></a>
- <span class="phrase"><a name="variadic_macro_data.vmd_generic.vmd_sequence.using_vmd_to_parse_sequence_inpu"></a></span><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.using_vmd_to_parse_sequence_inpu">Using
- VMD to parse sequence input</a>
- </h5>
- <p>
- For a VMD sequence essentially two ways of parsing into individual data types
- are offered by the VMD library:
- </p>
- <div class="orderedlist"><ol class="orderedlist" type="1">
- <li class="listitem">
- The sequence can be converted to any of the Boost PP data types, or to
- variadic data, where each individual data type in the sequence becomes
- a separate element of the particular composite data type chosen. The
- conversion to a particular Boost PP data type or variadic data is slow,
- because it is based on forward access through each top-level type of
- the sequence, but afterwards accessing any individual element is as fast
- as accessing any element in the Boost PP data type or among variadic
- data.
- </li>
- <li class="listitem">
- The sequence can be accessed directly through its individual elements.
- This is slower than accessing an element of a Boost PP data type or variadic
- data but offers conceptual access to the original sequence as a series
- of elements.
- </li>
- </ol></div>
- <p>
- These two techniques will be discussed in succeeding topics.
- </p>
- <div class="section">
- <div class="titlepage"><div><div><h4 class="title">
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_convert"></a><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_convert" title="Converting sequences">Converting
- sequences</a>
- </h4></div></div></div>
- <p>
- The easiest way to work with a sequence is to convert it to a Boost PP
- data type. Likewise you can also convert a sequence to variadic data even
- though the Boost PP data types have much greater functionality than variadic
- data in Boost PP.
- </p>
- <p>
- To convert a sequence to a Boost PP data type or variadic data the macros
- to be used are:
- </p>
- <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
- <li class="listitem">
- BOOST_VMD_TO_ARRAY(sequence) to convert the sequence to an array
- </li>
- <li class="listitem">
- BOOST_VMD_TO_LIST(sequence) to convert the sequence to a list
- </li>
- <li class="listitem">
- BOOST_VMD_TO_SEQ(sequence) to convert the sequence to a seq
- </li>
- <li class="listitem">
- BOOST_VMD_TO_TUPLE(sequence) to convert the sequence to a tuple
- </li>
- <li class="listitem">
- BOOST_VMD_ENUM(sequence) to convert the sequence to variadic data
- </li>
- </ul></div>
- <p>
- After the conversion the elements of a sequence become the elements of
- the corresponding composite data type.
- </p>
- <p>
- Once the elements of the sequence have been converted to the elements of
- the composite data type the full power of that composite data type can
- be used to process each element. Furthermore the programmer can use VMD
- to discover the type of an individual element for further processing.
- </p>
- <p>
- For single element sequences the result is always a single element composite
- data type. For multi-element sequences the result is always a composite
- data type of more than one element.
- </p>
- <p>
- For a sequence that is empty the result is emptiness when converting to
- a seq, tuple, or variadic data; the result is an empty array or list when
- converting to each of those composite data types respectively.
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="keyword">enum</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">to_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">to_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">to_seq</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">to_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="preprocessor">#define</span> <span class="identifier">BOOST_VMD_REGISTER_ANID</span> <span class="special">(</span><span class="identifier">ANID</span><span class="special">)</span>
- <span class="preprocessor">#define</span> <span class="identifier">SEQUENCE_EMPTY</span>
- <span class="preprocessor">#define</span> <span class="identifier">SEQUENCE_SINGLE</span> <span class="number">35</span>
- <span class="preprocessor">#define</span> <span class="identifier">SEQUENCE_SINGLE_2</span> <span class="identifier">ANID</span>
- <span class="preprocessor">#define</span> <span class="identifier">SEQUENCE_MULTI</span> <span class="special">(</span><span class="number">0</span><span class="special">,</span><span class="number">1</span><span class="special">)</span> <span class="special">(</span><span class="number">2</span><span class="special">)(</span><span class="number">3</span><span class="special">)(</span><span class="number">4</span><span class="special">)</span>
- <span class="preprocessor">#define</span> <span class="identifier">SEQUENCE_MULTI_2</span> <span class="identifier">BOOST_VMD_TYPE_SEQ</span> <span class="special">(</span><span class="number">2</span><span class="special">,(</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">))</span>
- <span class="identifier">BOOST_VMD_TO_ARRAY</span><span class="special">(</span><span class="identifier">SEQUENCE_EMPTY</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">an</span> <span class="identifier">empty</span> <span class="identifier">array</span> <span class="char">'(0,())'</span>
- <span class="identifier">BOOST_VMD_TO_LIST</span><span class="special">(</span><span class="identifier">SEQUENCE_SINGLE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">a</span> <span class="identifier">one</span><span class="special">-</span><span class="identifier">element</span> <span class="identifier">list</span> <span class="char">'(35,BOOST_PP_NIL)'</span>
- <span class="identifier">BOOST_VMD_TO_SEQ</span><span class="special">(</span><span class="identifier">SEQUENCE_SINGLE_2</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">a</span> <span class="identifier">one</span><span class="special">-</span><span class="identifier">element</span> <span class="identifier">seq</span> <span class="char">'(ANID)'</span>
- <span class="identifier">BOOST_VMD_TO_TUPLE</span><span class="special">(</span><span class="identifier">SEQUENCE_MULTI</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">a</span> <span class="identifier">multi</span><span class="special">-</span><span class="identifier">element</span> <span class="identifier">tuple</span> <span class="char">'((0,1),(2)(3)(4))'</span>
- <span class="identifier">BOOST_VMD_ENUM</span><span class="special">(</span><span class="identifier">SEQUENCE_MULTI_2</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">multi</span><span class="special">-</span><span class="identifier">element</span> <span class="identifier">variadic</span> <span class="identifier">data</span> <span class="char">'BOOST_VMD_TYPE_SEQ,(2,(5,6))'</span>
- </pre>
- <h6>
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_convert.h0"></a>
- <span class="phrase"><a name="variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_convert.usage"></a></span><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_convert.usage">Usage</a>
- </h6>
- <p>
- You can use the general header file:
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- </pre>
- <p>
- or you can use individual header files for each of these macros. The individual
- header files are:
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">to_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> <span class="comment">// for the BOOST_VMD_TO_ARRAY macro</span>
- <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">to_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> <span class="comment">// for the BOOST_VMD_TO_LIST macro</span>
- <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">to_seq</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> <span class="comment">// for the BOOST_VMD_TO_SEQ macro</span>
- <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">to_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> <span class="comment">// for the BOOST_VMD_TO_TUPLE macro.</span>
- <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="keyword">enum</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> <span class="comment">// for the BOOST_VMD_ENUM macro.</span>
- </pre>
- </div>
- <div class="section">
- <div class="titlepage"><div><div><h4 class="title">
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_access"></a><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_access" title="Accessing a sequence element">Accessing
- a sequence element</a>
- </h4></div></div></div>
- <p>
- It is possible to access an individual element of a sequence. The macro
- to do this is called BOOST_VMD_ELEM. The macro takes two required parameters.
- The required parameters are the element number to access and the sequence,
- in that order. The element number is a 0-based number and its maximum value
- should be one less than the size of the sequence.
- </p>
- <p>
- The BOOST_VMD_ELEM macro returns the actual sequence element. If the first
- required parameter is greater or equal to the size of the sequence the
- macro returns emptiness. Because of this using BOOST_VMD_ELEM on an empty
- sequence, whose size is 0, always returns emptiness.
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">elem</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- <span class="preprocessor">#define</span> <span class="identifier">BOOST_VMD_REGISTER_ANAME</span> <span class="special">(</span><span class="identifier">ANAME</span><span class="special">)</span>
- <span class="preprocessor">#define</span> <span class="identifier">A_SEQUENCE</span> <span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">)</span> <span class="number">46</span> <span class="special">(</span><span class="identifier">list_data1</span><span class="special">,(</span><span class="identifier">list_data2</span><span class="special">,</span><span class="identifier">BOOST_PP_NIL</span><span class="special">))</span> <span class="identifier">BOOST_VMD_TYPE_SEQ</span> <span class="identifier">ANAME</span>
- <span class="preprocessor">#define</span> <span class="identifier">AN_EMPTY_SEQUENCE</span>
- <span class="identifier">BOOST_VMD_ELEM</span><span class="special">(</span><span class="number">0</span><span class="special">,</span><span class="identifier">A_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">)</span>
- <span class="identifier">BOOST_VMD_ELEM</span><span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="identifier">A_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">46</span>
- <span class="identifier">BOOST_VMD_ELEM</span><span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="identifier">A_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="special">(</span><span class="identifier">list_data1</span><span class="special">,(</span><span class="identifier">list_data2</span><span class="special">,</span><span class="identifier">BOOST_PP_NIL</span><span class="special">))</span>
- <span class="identifier">BOOST_VMD_ELEM</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="identifier">A_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">BOOST_VMD_TYPE_SEQ</span>
- <span class="identifier">BOOST_VMD_ELEM</span><span class="special">(</span><span class="number">4</span><span class="special">,</span><span class="identifier">A_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">ANAME</span>
- <span class="identifier">BOOST_VMD_ELEM</span><span class="special">(</span><span class="number">5</span><span class="special">,</span><span class="identifier">A_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">emptiness</span>
- <span class="identifier">BOOST_VMD_ELEM</span><span class="special">(</span><span class="number">0</span><span class="special">,</span><span class="identifier">AN_EMPTY_SEQUENCE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="identifier">emptiness</span>
- </pre>
- <p>
- Accessing an element of a sequence directly is slower than accessing an
- element of a Boost PP data type or even variadic data, since each access
- has to directly cycle through each element of the sequence to get to the
- one being accessed. The process of sequentially parsing each element again
- each time is slower than accessing a Boost PP data type element.
- </p>
- <h6>
- <a name="variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_access.h0"></a>
- <span class="phrase"><a name="variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_access.usage"></a></span><a class="link" href="vmd_generic.html#variadic_macro_data.vmd_generic.vmd_sequence.vmd_sequence_access.usage">Usage</a>
- </h6>
- <p>
- You can use the general header file:
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- </pre>
- <p>
- or you can use the individual header file:
- </p>
- <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">elem</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
- </pre>
- </div>
- </div>
- </div>
- <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
- <td align="left"></td>
- <td align="right"><div class="copyright-footer">Copyright © 2010-2017 Tropic Software
- East Inc</div></td>
- </tr></table>
- <hr>
- <div class="spirit-nav">
- <a accesskey="p" href="vmd_specific/vmd_identifying.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="vmd_generic/vmd_convert_sequence.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
- </div>
- </body>
- </html>
|