devn00b
/
EQ2EMu


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254
							<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Testing for equality and inequality</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_generic.html" title="Generic macros for working with data types">
<link rel="prev" href="vmd_convert_sequence.html" title="Getting the type of data">
<link rel="next" href="../vmd_modifiers.html" title="Macros with modifiers">
</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_convert_sequence.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../vmd_generic.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_modifiers.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_generic.vmd_assert"></a><a class="link" href="vmd_assert.html" title="Testing for equality and inequality">Testing for
      equality and inequality</a>
</h3></div></div></div>
<p>
        VMD allows the programmer to test generically for the equality or inequality
        of any value which VMD can parse. This includes emptiness, identifiers, numbers,
        types, arrays, lists, seqs, tuples, and multi-element sequences.
      </p>
<p>
        The macro to test for equality is called BOOST_VMD_EQUAL and it has two required
        parameters which are the two values against which to test. The values can
        be any VMD data type.
      </p>
<p>
        For the composite data types of array, list, seq, and tuple, or any of those
        types in a multi-element sequence, the elements of those types must also
        be a data type which VMD can parse. BOOST_VMD_EQUAL recursively parses the
        elements in a composite data type for equality, up to a level of 16 inner
        types, to test that one composite type equals another composite type. The
        requirement, that composite elements must also be a data type which VMD can
        parse, is different from most other macros in the VMD library, where only
        the top-level composite type need be parsed enough to determine the type
        of the data. If BOOST_VMD_EQUAL encounters a data type which it cannot parse
        the result will be UB.
      </p>
<p>
        VMD identifiers used in equality testing must be registered and pre-detected.
        All numbers and v-types are already registered/pre-detected for equality
        testing so it is only user-defined identifiers which must be registered and
        pre-detected. If an identifier has not been both registered and predetected
        it will never be equal to the same identifier value, so it will always fail
        equality testing, although it will not give a preprocessing error doing so.
      </p>
<p>
        The BOOST_VMD_EQUAL macro returns 1 if both parameters are equal and 0 if
        the parameters are not equal.
      </p>
<p>
        Conversely to test for inequality, of the same values as are required in
        testing for equality, the VMD library has the macro BOOST_VMD_NOT_EQUAL.
        This macro is simply a complement of the BOOST_VMD_EQUAL macro. If BOOST_VMD_EQUAL
        returns 1 then BOOST_VMD_NOT_EQUAL returns 0 and if BOOST_VMD_EQUAL returns
        0 then BOOST_VMD_NOT_EQUAL returns 1.
      </p>
<p>
        The BOOST_VMD_EQUAL and BOOST_VMD_NOT_EQUAL macros are called "equality
        macros".
      </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">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">BOOST_VMD_REGISTER_AN_ID1</span> <span class="special">(</span><span class="identifier">AN_ID1</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">BOOST_VMD_REGISTER_AN_ID2</span> <span class="special">(</span><span class="identifier">AN_ID2</span><span class="special">)</span>

<span class="preprocessor">#define</span> <span class="identifier">BOOST_VMD_DETECT_AN_ID1_AN_ID1</span>
<span class="preprocessor">#define</span> <span class="identifier">BOOST_VMD_DETECT_AN_ID2_AN_ID2</span>

<span class="preprocessor">#define</span> <span class="identifier">AN_IDENTIFIER1</span> <span class="identifier">AN_ID1</span>
<span class="preprocessor">#define</span> <span class="identifier">AN_IDENTIFIER2</span> <span class="identifier">AN_ID2</span>
<span class="preprocessor">#define</span> <span class="identifier">AN_IDENTIFIER3</span> <span class="identifier">AN_ID1</span> <span class="comment">// same as AN_IDENTIFIER1 = AN_ID1</span>

<span class="preprocessor">#define</span> <span class="identifier">A_NUMBER1</span> <span class="number">33</span>
<span class="preprocessor">#define</span> <span class="identifier">A_NUMBER2</span> <span class="number">145</span>
<span class="preprocessor">#define</span> <span class="identifier">A_NUMBER3</span> <span class="number">33</span> <span class="comment">// same as A_NUMBER1 = 33</span>

<span class="preprocessor">#define</span> <span class="identifier">A_TUPLE1</span> <span class="special">(</span><span class="identifier">AN_IDENTIFIER1</span><span class="special">,</span><span class="identifier">A_NUMBER1</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">A_TUPLE2</span> <span class="special">(</span><span class="identifier">AN_IDENTIFIER1</span><span class="special">,</span><span class="identifier">A_NUMBER2</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">A_TUPLE3</span> <span class="special">(</span><span class="identifier">AN_IDENTIFIER3</span><span class="special">,</span><span class="identifier">A_NUMBER3</span><span class="special">)</span> <span class="comment">// same as A_TUPLE1 = (AN_ID1,33)</span>

<span class="preprocessor">#define</span> <span class="identifier">A_SEQ1</span> <span class="special">(</span><span class="identifier">A_NUMBER1</span><span class="special">)(</span><span class="identifier">A_TUPLE1</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">A_SEQ2</span> <span class="special">(</span><span class="identifier">A_NUMBER2</span><span class="special">)(</span><span class="identifier">A_TUPLE2</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">A_SEQ3</span> <span class="special">(</span><span class="identifier">A_NUMBER3</span><span class="special">)(</span><span class="identifier">A_TUPLE3</span><span class="special">)</span> <span class="comment">// same as A_SEQ1 = (33)((AN_ID1,33))</span>

<span class="identifier">BOOST_VMD_EQUAL</span><span class="special">(</span><span class="identifier">AN_IDENTIFIER1</span><span class="special">,</span><span class="identifier">AN_IDENTIFIER2</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_EQUAL</span><span class="special">(</span><span class="identifier">AN_IDENTIFIER1</span><span class="special">,</span><span class="identifier">AN_IDENTIFIER3</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_EQUAL</span><span class="special">(</span><span class="identifier">A_NUMBER1</span><span class="special">,</span><span class="identifier">A_NUMBER2</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_EQUAL</span><span class="special">(</span><span class="identifier">A_NUMBER1</span><span class="special">,</span><span class="identifier">A_NUMBER3</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_EQUAL</span><span class="special">(</span><span class="identifier">A_TUPLE1</span><span class="special">,</span><span class="identifier">A_TUPLE2</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_EQUAL</span><span class="special">(</span><span class="identifier">A_TUPLE1</span><span class="special">,</span><span class="identifier">A_TUPLE3</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_EQUAL</span><span class="special">(</span><span class="identifier">A_SEQ1</span><span class="special">,</span><span class="identifier">A_SEQ2</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_EQUAL</span><span class="special">(</span><span class="identifier">A_SEQ1</span><span class="special">,</span><span class="identifier">A_SEQ3</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
</pre>
<p>
        When BOOST_VMD_EQUAL tests for equality it always parses data for their most
        specific types. The reason for this is that a valid tuple, which is also
        an invalid list or array, can never be compared completely because all elements
        of that tuple are not data types which VMD can parse. Therefore VMD always
        tests equality based on the most specific type for any value being tested,
        which speeds up testing for the more specific tuple data types such as lists
        and arrays.
      </p>
<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">TUPLE_IS_ARRAY1</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">TUPLE_IS_ARRAY2</span> <span class="special">(</span><span class="number">2</span><span class="special">,(</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">))</span>
<span class="preprocessor">#define</span> <span class="identifier">TUPLE_IS_ARRAY3</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">TUPLE_IS_LIST1</span> <span class="special">(</span><span class="number">55</span><span class="special">,</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">TUPLE_IS_LIST2</span> <span class="special">(</span><span class="number">135</span><span class="special">,</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">TUPLE_IS_LIST3</span> <span class="special">(</span><span class="number">55</span><span class="special">,</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)</span>

<span class="preprocessor">#define</span> <span class="identifier">TUPLE_IS_LIST_OR_ARRAY1</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">TUPLE_IS_LIST_OR_ARRAY2</span> <span class="special">(</span><span class="number">2</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">TUPLE_IS_LIST_OR_ARRAY3</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">TUPLE_BUT_INVALID_ARRAY1</span> <span class="special">(&amp;</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">TUPLE_BUT_INVALID_ARRAY2</span> <span class="special">(&amp;</span><span class="number">2</span><span class="special">,(</span><span class="number">4</span><span class="special">,</span><span class="number">4</span><span class="special">))</span>
<span class="preprocessor">#define</span> <span class="identifier">TUPLE_BUT_INVALID_ARRAY3</span> <span class="special">(&amp;</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">TUPLE_BUT_INVALID_LIST1</span> <span class="special">(</span><span class="number">55</span><span class="special">,^</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">TUPLE_BUT_INVALID_LIST2</span> <span class="special">(</span><span class="number">135</span><span class="special">,^</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">TUPLE_BUT_INVALID_LIST3</span> <span class="special">(</span><span class="number">55</span><span class="special">,^</span><span class="identifier">BOOST_PP_NIL</span><span class="special">)</span>
</pre>
<p>
        All of the constructs above are valid tuples.
      </p>
<p>
        The first three are valid arrays, so they will be parsed and compared as
        arrays, so that they can be used as in:
      </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">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">BOOST_VMD_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_IS_ARRAY1</span><span class="special">,</span><span class="identifier">TUPLE_IS_ARRAY2</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_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_IS_ARRAY1</span><span class="special">,</span><span class="identifier">TUPLE_IS_ARRAY3</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
</pre>
<p>
        The next three are valid lists, so they will be parsed and compared as lists,
        so that they can be used as in:
      </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">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">BOOST_VMD_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_IS_LIST1</span><span class="special">,</span><span class="identifier">TUPLE_IS_LIST2</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_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_IS_LIST1</span><span class="special">,</span><span class="identifier">TUPLE_IS_LIST3</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
</pre>
<p>
        The next three are valid lists or arrays but will be parsed as lists because
        lists are more specific than arrays. They can be used as in:
      </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">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">BOOST_VMD_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_IS_LIST_OR_ARRAY1</span><span class="special">,</span><span class="identifier">TUPLE_IS_LIST_OR_ARRAY2</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_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_IS_LIST_OR_ARRAY1</span><span class="special">,</span><span class="identifier">TUPLE_IS_LIST_OR_ARRAY3</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">1</span>
</pre>
<p>
        The next three are valid tuples but invalid arrays. The BOOST_VMD_EQUAL macro
        attempts to parse them as the most specific type they can be, which is an
        array. But the attempt to parse them as arrays will lead to UB because the
        number which signifies the size of the array is invalid as a number. Now
        let us suppose we should parse them as the less specific type of a tuple
        instead of as an array. This will still give UB if we will attempt to compare
        the first tuple element against a corresponding first tuple element of another
        tuple, and when we do will again encounter UB because it is not a data type
        VMD can parse.
      </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">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">BOOST_VMD_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_BUT_INVALID_ARRAY1</span><span class="special">,</span><span class="identifier">TUPLE_BUT_INVALID_ARRAY1</span><span class="special">)</span> <span class="identifier">will</span> <span class="identifier">generate</span> <span class="identifier">UB</span>
<span class="identifier">BOOST_VMD_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_BUT_INVALID_ARRAY1</span><span class="special">,</span><span class="identifier">TUPLE_BUT_INVALID_ARRAY1</span><span class="special">)</span> <span class="identifier">will</span> <span class="identifier">generate</span> <span class="identifier">UB</span>
</pre>
<p>
        The next three are valid tuples but invalid lists. The BOOST_VMD_EQUAL macro
        attempts to parse them as the most specific type they can be, which is a
        list. But the attempt to parse them as lists will lead to UB because the
        identifier which signifies the end-of-list is invalid as an identifier. Now
        let us suppose we should parse them as the less specific type of a tuple
        instead of as a list. This will still give UB if we will attempt to compare
        the second tuple element against a corresponding second tuple element of
        another tuple, and when we do will again encounter UB because it is not a
        data type VMD can parse.
      </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">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="identifier">BOOST_VMD_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_BUT_INVALID_LIST1</span><span class="special">,</span><span class="identifier">TUPLE_BUT_INVALID_LIST2</span><span class="special">)</span> <span class="identifier">will</span> <span class="identifier">generate</span> <span class="identifier">UB</span>
<span class="identifier">BOOST_VMD_EQUAL</span><span class="special">(</span><span class="identifier">TUPLE_BUT_INVALID_LIST1</span><span class="special">,</span><span class="identifier">TUPLE_BUT_INVALID_LIST3</span><span class="special">)</span> <span class="identifier">will</span> <span class="identifier">generate</span> <span class="identifier">UB</span>
</pre>
<p>
        It is possible that a composite data type which has an element which VMD
        cannot parse will not give UB when compared for equality, but rather just
        the test for equality will fail. This can occur if the algorithm which tests
        for equality tests false before parsing of the particular element. Such a
        situation might be:
      </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">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="preprocessor">#define</span> <span class="identifier">A_TUPLE1</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="string">"astring"</span><span class="special">)</span>
<span class="preprocessor">#define</span> <span class="identifier">A_TUPLE2</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_VMD_EQUAL</span><span class="special">(</span><span class="identifier">A_TUPLE1</span><span class="special">,</span><span class="identifier">A_TUPLE2</span><span class="special">)</span> <span class="identifier">will</span> <span class="keyword">return</span> <span class="number">0</span> <span class="identifier">rather</span> <span class="identifier">than</span> <span class="identifier">generate</span> <span class="identifier">UB</span>
</pre>
<p>
        The reason the above correctly returns 0, rather than generate UB when VMD
        attempts to parse '"astring"', which is not a data type VMD can
        parse, is because the algorithm for testing equality tests whether or not
        the tuples have the same number of elements before it tests for the equality
        of each element. This is just one example where testing for equality may
        fail before UB is generated when BOOST_VMD_EQUAL attempts to parse a data
        type which it cannot handle. Nevertheless the general rule should still be
        considered that for BOOST_VMD_EQUAL/BOOT_VMD_NOT_EQUAL all data types, even
        an element of a composite data type, must be a VMD data type if the macro
        is to work properly, else UB could occur.
      </p>
<h5>
<a name="variadic_macro_data.vmd_generic.vmd_assert.h0"></a>
        <span class="phrase"><a name="variadic_macro_data.vmd_generic.vmd_assert.usage"></a></span><a class="link" href="vmd_assert.html#variadic_macro_data.vmd_generic.vmd_assert.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 the individual header files:
      </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">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="keyword">for</span> <span class="identifier">the</span> <span class="identifier">BOOST_VMD_EQUAL</span> <span class="identifier">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">not_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="keyword">for</span> <span class="identifier">the</span> <span class="identifier">BOOST_VMD_NOT_EQUAL</span> <span class="identifier">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_convert_sequence.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../vmd_generic.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_modifiers.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>