devn00b
/
EQ2EMu


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379
							<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>VMD and Boost PP 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&#160;1.&#160;The Variadic Macro Data Library 1.9">
<link rel="up" href="../vmd_specific.html" title="Specific macros for working with data types">
<link rel="prev" href="vmd_type.html" title="Types">
<link rel="next" href="vmd_identifying.html" title="Identifying data types">
</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_type.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../vmd_specific.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_identifying.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="variadic_macro_data.vmd_specific.vmd_pp_data_types"></a><a class="link" href="vmd_pp_data_types.html" title="VMD and Boost PP data types">VMD
      and Boost PP data types</a>
</h3></div></div></div>
<p>
        VMD is able to determine whether or not preprocessing input is a given Boost
        PP data type. The VMD macros to do this are:
      </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            BOOST_VMD_IS_ARRAY for an array
          </li>
<li class="listitem">
            BOOST_VMD_IS_LIST for a list
          </li>
<li class="listitem">
            BOOST_VMD_IS_SEQ for a seq
          </li>
<li class="listitem">
            BOOST_VMD_IS_TUPLE for a tuple
          </li>
</ul></div>
<p>
        Each of these macros take a single parameter as input and return 1 if the
        parameter is the appropriate data type and 0 if it is not.
      </p>
<h5>
<a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.h0"></a>
        <span class="phrase"><a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.syntax_anomalies"></a></span><a class="link" href="vmd_pp_data_types.html#variadic_macro_data.vmd_specific.vmd_pp_data_types.syntax_anomalies">Syntax
        anomalies</a>
      </h5>
<p>
        Both an array and a non-empty list are also a tuple. So if one has:
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">ANARRAY</span> <span class="special">(</span><span class="number">3</span><span class="special">,(</span><span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">))</span>
<span class="preprocessor">#define</span> <span class="identifier">ALIST</span> <span class="special">(</span><span class="identifier">a</span><span class="special">,(</span><span class="identifier">b</span><span class="special">,(</span><span class="identifier">c</span><span class="special">,</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)))</span>
<span class="preprocessor">#define</span> <span class="identifier">ATUPLE</span> <span class="special">(</span><span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">ASEQ</span> <span class="special">(</span><span class="identifier">a</span><span class="special">)(</span><span class="identifier">b</span><span class="special">)(</span><span class="identifier">c</span><span class="special">)</span>
</pre>
<p>
        then
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">BOOST_VMD_IS_TUPLE</span><span class="special">(</span><span class="identifier">ANARRAY</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_TUPLE</span><span class="special">(</span><span class="identifier">ALIST</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_TUPLE</span><span class="special">(</span><span class="identifier">ATUPLE</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_TUPLE</span><span class="special">(</span><span class="identifier">ASEQ</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">0</span>
</pre>
<p>
        A list whose first element is the number 2 and whose second element is not
        the end-of-list marker BOOST_PP_NIL is also an array. So if one has:
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">ALIST</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_PP_NIL</span><span class="special">))</span>
<span class="preprocessor">#define</span> <span class="identifier">ALIST2</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="identifier">BOOST_PP_NIL</span><span class="special">)))</span>
<span class="preprocessor">#define</span> <span class="identifier">ALIST3</span> <span class="special">(</span><span class="number">2</span><span class="special">,</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)</span>

<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">BOOST_VMD_IS_LIST</span><span class="special">(</span><span class="identifier">ALIST</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_LIST</span><span class="special">(</span><span class="identifier">ALIST2</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_LIST</span><span class="special">(</span><span class="identifier">ALIST3</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_ARRAY</span><span class="special">(</span><span class="identifier">ALIST</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_ARRAY</span><span class="special">(</span><span class="identifier">ALIST2</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_ARRAY</span><span class="special">(</span><span class="identifier">ALIST3</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">0</span>
</pre>
<p>
        A single element tuple is also a one element seq. So if one has:
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">ASE_TUPLE</span> <span class="special">(</span><span class="identifier">a</span><span class="special">)</span>
</pre>
<p>
        then
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_seq</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">BOOST_VMD_IS_TUPLE</span><span class="special">(</span><span class="identifier">ASE_TUPLE</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
<span class="identifier">BOOST_VMD_IS_SEQ</span><span class="special">(</span><span class="identifier">ASE_TUPLE</span><span class="special">)</span> <span class="identifier">returns</span> <span class="number">1</span>
</pre>
<h5>
<a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.h1"></a>
        <span class="phrase"><a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.problem_when_testing_an_array"></a></span><a class="link" href="vmd_pp_data_types.html#variadic_macro_data.vmd_specific.vmd_pp_data_types.problem_when_testing_an_array">Problem
        when testing an array</a>
      </h5>
<p>
        The form of an array is a two element tuple, where the first element is a
        number and the second element is a tuple. The number specifies the size of
        the tuple. Since when using variadic macros it is never necessary to specify
        the size of a tuple, an array is largely obsolete. However VMD still supports
        it.
      </p>
<p>
        The problem when testing for an array is that if the first element does not
        obey the constraint on testing for a number, you will get UB.
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">A_TUPLE</span> <span class="special">(&amp;</span><span class="identifier">anything</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_ARRAY</span><span class="special">(</span><span class="identifier">A_TUPLE</span><span class="special">)</span> <span class="identifier">will</span> <span class="identifier">give</span> <span class="identifier">UB</span> <span class="identifier">due</span> <span class="identifier">to</span> <span class="identifier">the</span> <span class="identifier">constraint</span>
<span class="identifier">BOOST_VMD_IS_TUPLE</span><span class="special">(</span><span class="identifier">A_TUPLE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
</pre>
<p>
        When VMD attempts to parse for an array, as it does when the BOOST_VMD_IS_ARRAY
        is used, if first looks to see if the syntax represents a tuple with two
        elements. Next it looks to see if the second element itself is a tuple. Finally
        if it is satisfied that the previous checks are valid it tests whether the
        first element is a number or not. It is in this final test, that the first
        element is a valid number, where the UB could occur as explained in the topic
        'Numbers'.
      </p>
<h5>
<a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.h2"></a>
        <span class="phrase"><a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.problem_when_testing_a_list"></a></span><a class="link" href="vmd_pp_data_types.html#variadic_macro_data.vmd_specific.vmd_pp_data_types.problem_when_testing_a_list">Problem
        when testing a list</a>
      </h5>
<p>
        The form of a non-empty list is a two element tuple, where the first element
        is the head of the list and can be anything and the second element is itself
        a list or the end-of-list identifier BOOST_PP_NIL.
      </p>
<p>
        The problem when testing for a list is that if the second element does not
        obey the constraint on testing for an identifier, since BOOST_PP_NIL is an
        identifier and is tested as such, you will get UB.
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">A_TUPLE</span> <span class="special">(</span><span class="identifier">element</span><span class="special">,&amp;</span><span class="identifier">anything</span><span class="special">)</span>

<span class="identifier">BOOST_VMD_IS_LIST</span><span class="special">(</span><span class="identifier">A_TUPLE</span><span class="special">)</span> <span class="identifier">will</span> <span class="identifier">give</span> <span class="identifier">UB</span> <span class="identifier">due</span> <span class="identifier">to</span> <span class="identifier">the</span> <span class="identifier">constraint</span>
<span class="identifier">BOOST_VMD_IS_TUPLE</span><span class="special">(</span><span class="identifier">A_TUPLE</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
</pre>
<p>
        The form of an empty list is the identifier BOOST_PP_NIL. Therefore:
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_identifier</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">A_BAD_EMPTY_LIST</span> <span class="special">&amp;</span><span class="identifier">BOOST_PP_NIL</span>

<span class="identifier">BOOST_VMD_IS_LIST</span><span class="special">(</span><span class="identifier">A_BAD_EMPTY_LIST</span><span class="special">)</span> <span class="identifier">will</span> <span class="identifier">give</span> <span class="identifier">UB</span> <span class="identifier">due</span> <span class="identifier">to</span> <span class="identifier">the</span> <span class="identifier">constraint</span>
<span class="identifier">BOOST_VMD_IS_IDENTIFIER</span><span class="special">(</span><span class="identifier">A_BAD_EMPTY_LIST</span><span class="special">)</span> <span class="identifier">will</span> <span class="identifier">give</span> <span class="identifier">UB</span> <span class="identifier">due</span> <span class="identifier">to</span> <span class="identifier">the</span> <span class="identifier">constraint</span>
</pre>
<p>
        When VMD attempts to parse for a list, as it does when the BOOST_VMD_IS_LIST
        is used, if first looks to see if the syntax represents a tuple with two
        elements. If it is not a tuple with two elements it will check for the end-of-list.
        If it is a tuple with two elements it looks to see if the second element
        is a list. In both these paths it must always eventually check for the end-of-list
        notation BOOST_PP_NIL, which is an identifier in VMD. It is in this final
        test, that the end-of-list notation exists as a VMD identifier, where the
        UB could occur as explained in the topic 'Identifiers'.
      </p>
<h5>
<a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.h3"></a>
        <span class="phrase"><a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.distinguishing_a_seq_and_a_tuple"></a></span><a class="link" href="vmd_pp_data_types.html#variadic_macro_data.vmd_specific.vmd_pp_data_types.distinguishing_a_seq_and_a_tuple">Distinguishing
        a seq and a tuple</a>
      </h5>
<p>
        As has previously been mentioned a single element tuple is also a one element
        seq.
      </p>
<p>
        However, as will be discussed later in the documentation, when VMD has to
        determine the type of such data, it always returns it as a tuple ( BOOST_VMD_TYPE_TUPLE
        ).
      </p>
<p>
        If our data consists of more than one consecutive tuple of a single element
        the data is a seq:
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_seq</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">ST_DATA</span> <span class="special">(</span><span class="identifier">somedata</span><span class="special">)(</span><span class="identifier">some_other_data</span><span class="special">)</span>

<span class="identifier">BOOST_VMD_IS_SEQ</span><span class="special">(</span><span class="identifier">ST_DATA</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_IS_TUPLE</span><span class="special">(</span><span class="identifier">ST_DATA</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">0</span>
</pre>
<p>
        However if the data consists of a mixture we need to distinguish how VMD
        parses the data. The rule is that VMD always parses a single element tuple
        as a tuple unless it is followed by one or more single element tuples, in
        which case it is a seq.
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">ST_DATA</span> <span class="special">(</span><span class="identifier">somedata</span><span class="special">)(</span><span class="identifier">element1</span><span class="special">,</span><span class="identifier">element2</span><span class="special">)</span>
</pre>
<p>
        VMD parses the above data as 2 consecutive tuples. The first tuple is the
        single element tuple '(somedata)' and the second tuple is the multi element
        tuple '(element1,element2)'.
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">ST_DATA</span> <span class="special">(</span><span class="identifier">element1</span><span class="special">,</span><span class="identifier">element2</span><span class="special">)(</span><span class="identifier">somedata</span><span class="special">)</span>
</pre>
<p>
        VMD parses the above data as 2 consecutive tuples. The first tuple is the
        multi element tuple '(element1,element2)' and the second tuple is the single
        element tuple '(somedata)'.
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">ST_DATA</span> <span class="special">(</span><span class="identifier">somedata</span><span class="special">)(</span><span class="identifier">some_other_data</span><span class="special">)(</span><span class="identifier">element1</span><span class="special">,</span><span class="identifier">element2</span><span class="special">)</span>
</pre>
<p>
        VMD parses the above data as a seq followed by a tuple. The seq is '(somedata)(some_other_data)'
        and the tuple is '(element1,element2)'.
      </p>
<h5>
<a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.h4"></a>
        <span class="phrase"><a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.empty_boost_pp_data_types"></a></span><a class="link" href="vmd_pp_data_types.html#variadic_macro_data.vmd_specific.vmd_pp_data_types.empty_boost_pp_data_types">Empty
        Boost PP data types</a>
      </h5>
<p>
        An array and a list can be empty.
      </p>
<p>
        An empty array has the form '(0,())', and is a perfectly valid array.
      </p>
<p>
        You can test for an empty array using the macro BOOST_VMD_IS_EMPTY_ARRAY.
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_empty_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">AN_ARRAY</span> <span class="special">(</span><span class="number">1</span><span class="special">,(</span><span class="number">1</span><span class="special">))</span>
<span class="preprocessor">#define</span> <span class="identifier">AN_EMPTY_ARRAY</span> <span class="special">(</span><span class="number">0</span><span class="special">,())</span>

<span class="identifier">BOOST_VMD_IS_ARRAY</span><span class="special">(</span><span class="identifier">AN_ARRAY</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_IS_ARRAY</span><span class="special">(</span><span class="identifier">AN_EMPTY_ARRAY</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_IS_EMPTY_ARRAY</span><span class="special">(</span><span class="identifier">AN_EMPTY_ARRAY</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_IS_EMPTY_ARRAY</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_IS_EMPTY_ARRAY</span><span class="special">(</span><span class="identifier">AN_ARRAY</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">0</span>
</pre>
<p>
        An empty list has the form 'BOOST_PP_NIL', and is a perfectly valid list.
      </p>
<p>
        You can test for an empty list using the macro BOOST_VMD_IS_EMPTY_LIST.
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_empty_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">A_LIST</span> <span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">AN_EMPTY_LIST</span> <span class="identifier">BOOST_PP_NIL</span>

<span class="identifier">BOOST_VMD_IS_LIST</span><span class="special">(</span><span class="identifier">A_LIST</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_IS_LIST</span><span class="special">(</span><span class="identifier">AN_EMPTY_LIST</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_IS_EMPTY_LIST</span><span class="special">(</span><span class="identifier">AN_EMPTY_LIST</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_IS_EMPTY_LIST</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_IS_EMPTY_LIST</span><span class="special">(</span><span class="identifier">A_LIST</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">0</span>
</pre>
<p>
        Neither seqs or tuples can be empty when using Boost PP. Because of this
        if you convert from an empty array or list to a seq or tuple using Boost
        PP macros to do so you will get undefined behavior.
      </p>
<p>
        The syntax '()', which is called an empty parenthesis, is neither a zero-element
        seq or a tuple consisting of no elements. Rather it is either a one-element
        seq whose content is emptiness or a single-element tuple whose content is
        emptiness.
      </p>
<p>
        VMD supports the syntax of an empty parenthesis. You can test for it using
        the macro BOOST_VMD_IS_PARENS_EMPTY.
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">is_parens_empty</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_seq</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">EMPTY_PARENS</span> <span class="special">()</span>
<span class="preprocessor">#define</span> <span class="identifier">TUPLE</span> <span class="special">(</span><span class="number">0</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">SEQ</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="identifier">BOOST_VMD_IS_TUPLE</span><span class="special">(</span><span class="identifier">EMPTY_PARENS</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_IS_SEQ</span><span class="special">(</span><span class="identifier">EMPTY_PARENS</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_IS_PARENS_EMPTY</span><span class="special">(</span><span class="identifier">EMPTY_PARENS</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_IS_PARENS_EMPTY</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_IS_PARENS_EMPTY</span><span class="special">(</span><span class="identifier">TUPLE</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_IS_PARENS_EMPTY</span><span class="special">(</span><span class="identifier">SEQ</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">0</span>
</pre>
<p>
        The VC++8 compiler ( Visual Studio 2005 ), which is the oldest VC++ version
        which VMD supports, has trouble working with the empty parenthesis syntax.
        Therefore if you have to use VC++8 avoid its use, otherwise you should be
        fine using it if you desire.
      </p>
<h5>
<a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.h5"></a>
        <span class="phrase"><a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.using_a_tuple_instead_of_an_arra"></a></span><a class="link" href="vmd_pp_data_types.html#variadic_macro_data.vmd_specific.vmd_pp_data_types.using_a_tuple_instead_of_an_arra">Using
        a tuple instead of an array</a>
      </h5>
<p>
        When using variadic macros, the fact that an array can be empty is its only
        advantage over a tuple. Otherwise using a tuple is always easier since the
        syntax is simpler; you never have to notate the tuple's size.
      </p>
<p>
        Since VMD fully supports passing and returning emptiness you could use a
        tuple instead of an array in all situations and simply pass or return emptiness
        to represent an "empty" tuple, and as an equivalent to an empty
        array.
      </p>
<p>
        This notion of using emptiness to represent an "empty" tuple can
        also be extended to using emptiness to represent an "empty" seq.
        However functionality in Boost PP will not recognize emptiness as an empty
        tuple or seq, nor can you work with emptiness to represent an empty tuple
        or empty seq using the Boost PP functionality for a tuple or a seq. For a
        solution to using emptiness to represent an "empty" tuple or an
        "empty" seq VMD has functionality which will be explained when
        we look at our last area of functionality in VMD, useful variadic macros
        not in Boost PP.
      </p>
<h5>
<a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.h6"></a>
        <span class="phrase"><a name="variadic_macro_data.vmd_specific.vmd_pp_data_types.usage"></a></span><a class="link" href="vmd_pp_data_types.html#variadic_macro_data.vmd_specific.vmd_pp_data_types.usage">Usage</a>
      </h5>
<p>
        You can use the general header file:
      </p>
<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">vmd</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</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">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">//  for the BOOST_VMD_IS_ARRAY macro</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">//  for the BOOST_VMD_IS_LIST macro</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_seq</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">//  for the BOOST_VMD_IS_SEQ macro</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_tuple</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// for the BOOST_VMD_IS_TUPLE macro.</span>

<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_empty_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// for the BOOST_VMD_IS_EMPTY_ARRAY macro.</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_empty_list</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// for the BOOST_VMD_IS_EMPTY_LIST macro.</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">vmd</span><span class="special">/</span><span class="identifier">is_parens_empty</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// for the BOOST_VMD_IS_PARENS_EMPTY macro.</span>
</pre>
</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 &#169; 2010-2017 Tropic Software
      East Inc</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="vmd_type.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../vmd_specific.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_identifying.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>