1<?xml version="1.0" standalone="yes"?> 2<library-reference id="variadic_macro_data_reference"><title>Variadic Macro Data Reference</title><header name="boost/vmd/array/to_seq.hpp"> 3<macro name="BOOST_VMD_ARRAY_TO_SEQ" kind="functionlike"><macro-parameter name="array"/><purpose>converts an array to a seq. </purpose><description><para>array = array to be converted.</para><para>If the array is an array of 0 elements it is converted to an empty seq. Otherwise the array is converted to a seq with the same number of elements as the array. </para></description></macro> 4</header> 5<header name="boost/vmd/list/to_seq.hpp"> 6<macro name="BOOST_VMD_LIST_TO_SEQ" kind="functionlike"><macro-parameter name="list"/><purpose>converts a list to a seq. </purpose><description><para>list = list to be converted.</para><para>If the list is an empty list (BOOST_PP_NIL) it is converted to an empty seq. Otherwise the list is converted to a seq with the same number of elements as the list. </para></description></macro> 7</header> 8<header name="boost/vmd/to_seq.hpp"> 9<macro name="BOOST_VMD_TO_SEQ" kind="functionlike"><macro-parameter name="..."/><purpose>Converts a sequence to a Boost PP seq whose elements are the elements of the sequence. </purpose><description><para>... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = A Boost PP seq. If the sequence is empty the return is emptiness since an empty seq does not exist. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as the seq element. Otherwise just the data is returned as the seq element, which is the default. </para></description></macro> 10<macro name="BOOST_VMD_TO_SEQ_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="..."/><purpose>Converts a sequence to a Boost PP seq whose elements are the elements of the sequence. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 11 ... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = A Boost PP seq. If the sequence is empty the return is emptiness since an empty seq does not exist. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as the seq element. Otherwise just the data is returned as the seq element, which is the default. </para></description></macro> 12</header> 13<header name="boost/vmd/tuple/to_seq.hpp"> 14<macro name="BOOST_VMD_TUPLE_TO_SEQ" kind="functionlike"><macro-parameter name="tuple"/><purpose>converts a tuple to a seq. </purpose><description><para>tuple = tuple to be converted.</para><para>If the tuple is an empty tuple it is converted to an empty seq. Otherwise the tuple is converted to a seq with the same number of elements as the tuple. </para></description></macro> 15</header> 16<header name="boost/vmd/array/to_tuple.hpp"> 17<macro name="BOOST_VMD_ARRAY_TO_TUPLE" kind="functionlike"><macro-parameter name="array"/><purpose>converts an array to a tuple. </purpose><description><para>array = array to be converted.</para><para>If the array is an array of 0 elements it is converted to an empty tuple. Otherwise the array is converted to a tuple with the same number of elements as the array. </para></description></macro> 18</header> 19<header name="boost/vmd/list/to_tuple.hpp"> 20<macro name="BOOST_VMD_LIST_TO_TUPLE" kind="functionlike"><macro-parameter name="list"/><purpose>converts a list to a tuple. </purpose><description><para>list = list to be converted.</para><para>If the list is an empty list (BOOST_PP_NIL) it is converted to an empty tuple. Otherwise the list is converted to a tuple with the same number of elements as the list. </para></description></macro> 21</header> 22<header name="boost/vmd/seq/to_tuple.hpp"> 23<macro name="BOOST_VMD_SEQ_TO_TUPLE" kind="functionlike"><macro-parameter name="seq"/><purpose>converts a seq to a tuple. </purpose><description><para>seq = seq to be converted.</para><para>If the seq is an empty seq it is converted to an empty tuple. Otherwise the seq is converted to a tuple with the same number of elements as the seq. </para></description></macro> 24</header> 25<header name="boost/vmd/to_tuple.hpp"> 26<macro name="BOOST_VMD_TO_TUPLE" kind="functionlike"><macro-parameter name="..."/><purpose>Converts a sequence to a Boost PP tuple whose elements are the elements of the sequence. </purpose><description><para>... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = A Boost PP tuple. If the sequence is empty the return is emptiness since an empty tuple does not exist. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as the tuple element. Otherwise just the data is returned as the tuple element, which is the default. </para></description></macro> 27<macro name="BOOST_VMD_TO_TUPLE_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="..."/><purpose>Converts a sequence to a Boost PP tuple whose elements are the elements of the sequence. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 28 ... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = A Boost PP tuple. If the sequence is empty the return is emptiness since an empty tuple does not exist. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as the tuple element. Otherwise just the data is returned as the tuple element, which is the default. </para></description></macro> 29</header> 30<header name="boost/vmd/assert.hpp"> 31<macro name="BOOST_VMD_ASSERT" kind="functionlike"><macro-parameter name="..."/><purpose>Conditionally causes an error to be generated. </purpose><description><para>... = variadic parameters, maximum of 2 will be considered. Any variadic parameters beyond the maximum of 2 are just ignored.</para><para>The first variadic parameter is:</para><para>cond = A condition that determines whether an assertion occurs. Valid values range from 0 to BOOST_PP_LIMIT_MAG.</para><para>The second variadic parameter (optional) is:</para><para>errstr = An error string for generating a compiler error when using the VC++ compiler. The VC++ compiler is incapable of producing a preprocessor error so when the 'cond' is 0, a compiler error is generated by outputting C++ code in the form of:</para><para><programlisting language="c++">typedef char errstr[-1]; 32</programlisting></para><para>The errstr defaults to BOOST_VMD_ASSERT_ERROR if not supplied. It is only relevant for VC++.</para><para>returns = If cond expands to 0, this macro causes an error. Otherwise, it expands to nothing. For all compilers other than Visual C++ the error is a preprocessing error. For Visual C++ the error is caused by output invalid C++: this error could be masked if the invalid output is ignored by a macro which invokes this macro. </para></description></macro> 33</header> 34<header name="boost/vmd/assert_is_array.hpp"> 35<macro name="BOOST_VMD_ASSERT_IS_ARRAY" kind="functionlike"><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a Boost PP array. </purpose><description><para>The macro checks that the sequence is a Boost PP array. If it is not a Boost PP array, it forces a compiler error.</para><para>The macro normally checks for a Boost PP array only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>sequence = a possible Boost PP array.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 36 37 If the sequence is a Boost PP array, nothing is 38 output. 39 40 For VC++, because there is no sure way of forcing 41 a compiler error from within a macro without producing 42 output, if the sequence is not a Boost PP array the 43 macro forces a compiler error by outputting invalid C++. 44 45 For all other compilers a compiler error is forced 46 without producing output if the sequence is not a 47 Boost PP array. 48</programlisting> </para></description></macro> 49<macro name="BOOST_VMD_ASSERT_IS_ARRAY_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a Boost PP array. Re-entrant version. </purpose><description><para>The macro checks that the sequence is a Boost PP array. If it is not a Boost PP array, it forces a compiler error.</para><para>The macro normally checks for a Boost PP array only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 50 sequence = a possible Boost PP sequence.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 51 52 If the sequence is a Boost PP array, nothing is 53 output. 54 55 For VC++, because there is no sure way of forcing 56 a compiler error from within a macro without producing 57 output, if the sequence is not a Boost PP array the 58 macro forces a compiler error by outputting invalid C++. 59 60 For all other compilers a compiler error is forced 61 without producing output if the sequence is not a 62 Boost PP array. 63</programlisting> </para></description></macro> 64</header> 65<header name="boost/vmd/assert_is_empty.hpp"> 66<macro name="BOOST_VMD_ASSERT_IS_EMPTY" kind="functionlike"><macro-parameter name="..."/><purpose>Asserts that the input is empty. </purpose><description><para>The macro checks to see if the input is empty or not. If it is not empty, it forces a compiler error.</para><para>The macro is a variadic macro taking any input. For the VC++8 compiler (VS2005) the macro takes a single parameter of input to check and not variadic data.</para><para>The macro normally checks for emptiness only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>.... = variadic input, for VC++8 this must be a single parameter.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 67 68 If the input is empty, nothing is output. 69 70 For VC++, because there is no sure way of forcing 71 a compiler error from within a macro without producing 72 output, if the input is not empty the 73 macro forces a compiler error by outputting invalid C++. 74 75 For all other compilers a compiler error is forced 76 without producing output if the input is not empty. 77</programlisting></para><para>It is recommended to append BOOST_PP_EMPTY() to whatever input is being tested in order to avoid possible warning messages from some compilers about no parameters being passed to the macro when the input is truly empty. </para></description></macro> 78</header> 79<header name="boost/vmd/assert_is_identifier.hpp"> 80<macro name="BOOST_VMD_ASSERT_IS_IDENTIFIER" kind="functionlike"><macro-parameter name="..."/><purpose>Asserts that the sequence is an identifier. </purpose><description><para>The macro checks that the sequence is an identifier. If it is not an identifier, it forces a compiler error.</para><para>The macro normally checks for an identifier only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>... = variadic parameters</para><para>The variadic parameters are:</para><para>sequence = A sequence to test as an identifier. <sbr/> 81 ids (optional) = The data may take one of two forms: it is either one or more single identifiers or a single Boost PP tuple of identifiers.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 82 83 If the sequence is an identifier, nothing is 84 output. If optional ids are specified, for the 85 sequence to be an identifier it must be an 86 identifier that matches one of the optional 87 ids. 88 89 For VC++, because there is no sure way of forcing 90 a compiler error from within a macro without producing 91 output, if the sequence is not an identifier the 92 macro forces a compiler error by outputting invalid C++. 93 94 For all other compilers a compiler error is forced 95 without producing output if the sequence is not an 96 identifier. 97</programlisting></para><para>Identifiers are registered in VMD with:</para><para><programlisting language="c++">#define BOOST_VMD_REG_XXX (XXX) where XXX is a v-identifier. 98</programlisting></para><para>The identifier must be registered to be found.</para><para>Identifiers are pre-detected in VMD with:</para><para><programlisting language="c++">#define BOOST_VMD_DETECT_XXX_XXX where XXX is an identifier. 99</programlisting></para><para>If you specify optional ids and have not specified the detection of an optional id, that id will never match an identifier. </para></description></macro> 100<macro name="BOOST_VMD_ASSERT_IS_IDENTIFIER_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="..."/><purpose>Asserts that the sequence is an identifier. Re-entrant version. </purpose><description><para>The macro checks that the sequence is an identifier. If it is not an identifier, it forces a compiler error.</para><para>The macro normally checks for an identifier only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 101 ... = variadic parameters</para><para>The variadic parameters are:</para><para>sequence = A sequence to test as an identifier. <sbr/> 102 ids (optional) = The data may take one of two forms: it is either one or more single identifiers or a single Boost PP tuple of identifiers.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 103 104 If the sequence is an identifier, nothing is 105 output. If optional ids are specified, for the 106 sequence to be an identifier it must be an 107 identifier that matches one of the optional 108 ids. 109 110 For VC++, because there is no sure way of forcing 111 a compiler error from within a macro without producing 112 output, if the sequence is not an identifier the 113 macro forces a compiler error by outputting invalid C++. 114 115 For all other compilers a compiler error is forced 116 without producing output if the sequence is not an 117 identifier. 118</programlisting></para><para>Identifiers are registered in VMD with:</para><para><programlisting language="c++">#define BOOST_VMD_REG_XXX (XXX) where XXX is a v-identifier. 119</programlisting></para><para>The identifier must be registered to be found.</para><para>Identifiers are pre-detected in VMD with:</para><para><programlisting language="c++">#define BOOST_VMD_DETECT_XXX_XXX where XXX is an identifier. 120</programlisting></para><para>If you specify optional ids and have not specified the detection of an optional id, that id will never match an identifier. </para></description></macro> 121</header> 122<header name="boost/vmd/assert_is_list.hpp"> 123<macro name="BOOST_VMD_ASSERT_IS_LIST" kind="functionlike"><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a Boost PP list. </purpose><description><para>The macro checks that the sequence is a Boost PP list. If it is not a Boost PP list, it forces a compiler error.</para><para>The macro normally checks for a Boost PP list only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>sequence = a possible Boost PP list.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 124 125 If the sequence is a Boost PP list, nothing is 126 output. 127 128 For VC++, because there is no sure way of forcing 129 a compiler error from within a macro without producing 130 output, if the sequence is not a Boost PP list the 131 macro forces a compiler error by outputting invalid C++. 132 133 For all other compilers a compiler error is forced 134 without producing output if the parameter is not a 135 Boost PP list. 136</programlisting> </para></description></macro> 137<macro name="BOOST_VMD_ASSERT_IS_LIST_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a Boost PP list. Re-entrant version. </purpose><description><para>The macro checks that the sequence is a Boost PP list. If it is not a Boost PP list, it forces a compiler error.</para><para>The macro normally checks for a Boost PP list only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 138 sequence = a possible Boost PP list.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 139 140 If the sequence is a Boost PP list, nothing is 141 output. 142 143 For VC++, because there is no sure way of forcing 144 a compiler error from within a macro without producing 145 output, if the sequence is not a Boost PP list the 146 macro forces a compiler error by outputting invalid C++. 147 148 For all other compilers a compiler error is forced 149 without producing output if the parameter is not a 150 Boost PP list. 151</programlisting> </para></description></macro> 152</header> 153<header name="boost/vmd/assert_is_number.hpp"> 154<macro name="BOOST_VMD_ASSERT_IS_NUMBER" kind="functionlike"><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a number. </purpose><description><para>The macro checks that the parameter is a number. If it is not a number, it forces a compiler error.</para><para>The macro normally checks for a number only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>sequence = a possible number.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 155 156 If the sequence is a number, nothing is 157 output. 158 159 For VC++, because there is no sure way of forcing 160 a compiler error from within a macro without producing 161 output, if the sequence is not a number the 162 macro forces a compiler error by outputting invalid C++. 163 164 For all other compilers a compiler error is forced 165 without producing output if the sequence is not a 166 number. 167</programlisting> </para></description></macro> 168</header> 169<header name="boost/vmd/assert_is_seq.hpp"> 170<macro name="BOOST_VMD_ASSERT_IS_SEQ" kind="functionlike"><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a Boost PP seq. </purpose><description><para>The macro checks that the sequence is a Boost PP seq. If it is not a Boost PP seq, it forces a compiler error.</para><para>The macro normally checks for a Boost PP seq only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>sequence = a possible Boost PP seq.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 171 172 If the sequence is a Boost PP seq, nothing is 173 output. 174 175 For VC++, because there is no sure way of forcing 176 a compiler error from within a macro without producing 177 output, if the sequence is not a Boost PP seq the 178 macro forces a compiler error by outputting invalid C++. 179 180 For all other compilers a compiler error is forced 181 without producing output if the sequence is not a 182 Boost PP seq. 183</programlisting> </para></description></macro> 184<macro name="BOOST_VMD_ASSERT_IS_SEQ_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a Boost PP seq. Re-entrant version. </purpose><description><para>The macro checks that the sequence is a Boost PP seq. If it is not a Boost PP seq, it forces a compiler error.</para><para>The macro normally checks for a Boost PP seq only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 185 sequence = a possible Boost PP seq.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 186 187 If the sequence is a Boost PP seq, nothing is 188 output. 189 190 For VC++, because there is no sure way of forcing 191 a compiler error from within a macro without producing 192 output, if the sequence is not a Boost PP seq the 193 macro forces a compiler error by outputting invalid C++. 194 195 For all other compilers a compiler error is forced 196 without producing output if the sequence is not a 197 Boost PP seq. 198</programlisting> </para></description></macro> 199</header> 200<header name="boost/vmd/assert_is_tuple.hpp"> 201<macro name="BOOST_VMD_ASSERT_IS_TUPLE" kind="functionlike"><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a Boost PP tuple. </purpose><description><para>The macro checks that the sequence is a Boost PP tuple. If it is not a Boost PP tuple, it forces a compiler error.</para><para>The macro normally checks for a Boost PP tuple only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>sequence = a possible Boost PP tuple.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 202 203 If the sequence is a Boost PP tuple, nothing is 204 output. 205 206 For VC++, because there is no sure way of forcing 207 a compiler error from within a macro without producing 208 output, if the sequence is not a Boost PP tuple the 209 macro forces a compiler error by outputting invalid C++. 210 211 For all other compilers a compiler error is forced 212 without producing output if the sequence is not a 213 Boost PP tuple. 214</programlisting> </para></description></macro> 215</header> 216<header name="boost/vmd/assert_is_type.hpp"> 217<macro name="BOOST_VMD_ASSERT_IS_TYPE" kind="functionlike"><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a VMD type. </purpose><description><para>The macro checks that the sequence is a VMD type. If it is not a VMD type, it forces a compiler error.</para><para>The macro normally checks for a VMD type only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>sequence = a possible VMD type.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 218 219 If the sequence is a VMD type, nothing is 220 output. 221 222 For VC++, because there is no sure way of forcing 223 a compiler error from within a macro without producing 224 output, if the sequence is not a VMD type the 225 macro forces a compiler error by outputting invalid C++. 226 227 For all other compilers a compiler error is forced 228 without producing output if the sequence is not a 229 VMD type. 230</programlisting> </para></description></macro> 231<macro name="BOOST_VMD_ASSERT_IS_TYPE_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Asserts that the sequence is a VMD type. Re-entrant version. </purpose><description><para>The macro checks that the sequence is a VMD type. If it is not a VMD type, it forces a compiler error.</para><para>The macro normally checks for a VMD type only in debug mode. However an end-user can force the macro to check or not check by defining the macro BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 232 sequence = a possible VMD type.</para><para><programlisting language="c++">returns = Normally the macro returns nothing. 233 234 If the sequence is a VMD type, nothing is 235 output. 236 237 For VC++, because there is no sure way of forcing 238 a compiler error from within a macro without producing 239 output, if the sequence is not a VMD type the 240 macro forces a compiler error by outputting invalid C++. 241 242 For all other compilers a compiler error is forced 243 without producing output if the sequence is not a 244 VMD type. 245</programlisting> </para></description></macro> 246</header> 247<header name="boost/vmd/elem.hpp"> 248<macro name="BOOST_VMD_ELEM" kind="functionlike"><macro-parameter name="elem"/><macro-parameter name="..."/><purpose>Accesses an element of a sequence. </purpose><description><para>elem = A sequence element number. From 0 to sequence size - 1. <sbr/> 249 ... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to access. Further variadic parameters are all optional.</para><para>With no further variadic parameters the macro returns the particular element in the sequence. If the element number is outside the bounds of the sequence macro access fails and the macro turns emptiness.</para><para>Optional parameters determine what it means that an element is successfully accessed as well as what data is returned by the macro.</para><para>Filters: specifying a VMD type tells the macro to return the element only if it is of the VMD type specified, else macro access fails. If more than one VMD type is specified as an optional parameter the last one specified is the filter.</para><para>Matching Identifiers: If the filter is specified as the identifier type, BOOST_VMD_TYPE_IDENTIFIER, optional parameters which are identifiers specify that the element accessed must match one of the identifiers else access fails. The identifiers may be specified multiple times as single optional parameters or once as a tuple of identifier parameters. If the identifiers are specified as single optional parameters they cannot be any of the specific BOOST_VMD_ optional parameters in order to be recognized as matching identifiers. Normally this should never be the case. The only situation where this could occur is if the VMD types, which are filters, are used as matching identifiers; in this case the matching identifiers need to be passed as a tuple of identifier parameters so they are not treated as filters.</para><para>Filters and matching identifiers change what it means that an element is successfully accessed. They do not change what data is returned by the macro. The remaining optional parameters do not change what it means that an element is successfully accessed but they do change what data is returned by the macro.</para><para><programlisting language="c++">Splitting: Splitting allows the macro to return the rest of the sequence 250 after the element accessed. 251 252 If BOOST_VMD_RETURN_AFTER is specified the return is a tuple 253 with the element accessed as the first tuple parameter and the rest of 254 the sequence as the second tuple parameter. If element access fails 255 both tuple parameters are empty. 256 257 If BOOST_VMD_RETURN_ONLY_AFTER 258 is specified the return is the rest of the sequence after the element accessed 259 found. If the element access fails the return is emptiness. 260 261 If BOOST_VMD_RETURN_NO_AFTER, the default, is specified no splitting 262 occurs. 263 264 If more than one of the splitting identifiers are specified 265 the last one specified determines the splitting. 266 267 Return Type: The element accessed can be changed to return both the type 268 of the element as well as the element data with optional return type 269 parameters. When a type is returned, the element accessed which is returned becomes a 270 two-element tuple where the type of the element accessed is the first tuple element and the element 271 data itself is the second tuple element. If the macro fails to access the 272 element the element access returned is emptiness and not a tuple. 273 274 If BOOST_VMD_RETURN_NO_TYPE, the default, is specified no type is returned 275 as part of the element accessed. 276 277 If BOOST_VMD_RETURN_TYPE is specified the specific type of the element 278 is returned in the tuple. 279 280 If BOOST_VMD_RETURN_TYPE_ARRAY is specified 281 an array type is returned if the element is an array, else a tuple 282 type is returned if the element is a tuple, else the actual type 283 is returned for non-tuple data. 284 285 If BOOST_VMD_RETURN_TYPE_LIST is specified 286 a list type is returned if the element is a list, else a tuple 287 type is returned if the element is a tuple, else the actual type 288 is returned for non-tuple data. 289 290 If BOOST_VMD_RETURN_TYPE_TUPLE is specified 291 a tuple type is returned for all tuple-like data, else the actual type 292 is returned for non-tuple data. 293 294 If more than one return type optional 295 parameter is specified the last one specified determines the return type. 296 297 If a filter is specified optional return type parameters are ignored and 298 the default BOOST_VMD_RETURN_NO_TYPE is in effect. 299 300 Index: If the filter is specified as the identifier type, BOOST_VMD_TYPE_IDENTIFIER, 301 and matching identifiers are specified, an index parameter specifies that the 302 numeric index, starting with 0, of the matching identifier found, be returned 303 as part of the result. 304 305 If BOOST_VMD_RETURN_INDEX is specified an index is returned 306 as part of the result. 307 308 If BOOST_VMD_RETURN_NO_INDEX, the default, is specified 309 no index is returned as part of the result. 310 311 If both are specified the last one specified determines the index parameter. 312 313 When an index is returned as part of the result, the result is a tuple where the 314 element accessed is the first tuple parameter and the index is the last tuple parameter. 315 If element access fails the index is empty. If there is no BOOST_VMD_TYPE_IDENTIFIER 316 filter or if there are no matching identifiers the BOOST_VMD_RETURN_INDEX is ignored 317 and no index is returned as part of the result. 318</programlisting></para><para>returns = With no optional parameters the element accessed is returned, or emptiness if element is outside the bounds of the sequence. Filters and matching identifiers can change the meaning of whether the element accessed is returned or failure occurs, but whenever failure occurs emptiness is returned as the element access part of that failure, else the element accessed is returned. Return type optional parameters, when filters are not used, return the element accessed as a two-element tuple where the first tuple element is the type and the second tuple element is the data; if the element is not accessed then emptiness is returned as the element access and not a tuple. Splitting with BOOST_VMD_RETURN_AFTER returns a tuple where the element accessed is the first tuple element and the rest of the sequence is the second tuple element. Splitting with BOOST_VMD_RETURN_ONLY_AFTER returns the rest of the sequence after the element accessed or emptiness if the element can not be accessed. Indexing returns the index as part of the output only if filtering with BOOST_VMD_TYPE_IDENTIFIER is specified and matching identifiers are specified. When the index is returned with BOOST_VMD_RETURN_AFTER it is the third element of the tuple returned, else it is the second element of a tuple where the element accessed is the first element of the tuple. </para></description></macro> 319<macro name="BOOST_VMD_ELEM_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="elem"/><macro-parameter name="..."/><purpose>Accesses an element of a sequence. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 320 elem = A sequence element number. From 0 to sequence size - 1. <sbr/> 321 ... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to access. Further variadic parameters are all optional.</para><para>With no further variadic parameters the macro returns the particular element in the sequence. If the element number is outside the bounds of the sequence macro access fails and the macro turns emptiness.</para><para>Optional parameters determine what it means that an element is successfully accessed as well as what data is returned by the macro.</para><para>Filters: specifying a VMD type tells the macro to return the element only if it is of the VMD type specified, else macro access fails. If more than one VMD type is specified as an optional parameter the last one specified is the filter.</para><para>Matching Identifiers: If the filter is specified as the identifier type, BOOST_VMD_TYPE_IDENTIFIER, optional parameters which are identifiers specify that the element accessed must match one of the identifiers else access fails. The identifiers may be specified multiple times as single optional parameters or once as a tuple of identifier parameters. If the identifiers are specified as single optional parameters they cannot be any of the specific BOOST_VMD_ optional parameters in order to be recognized as matching identifiers. Normally this should never be the case. The only situation where this could occur is if the VMD types, which are filters, are used as matching identifiers; in this case the matching identifiers need to be passed as a tuple of identifier parameters so they are not treated as filters.</para><para>Filters and matching identifiers change what it means that an element is successfully accessed. They do not change what data is returned by the macro. The remaining optional parameters do not change what it means that an element is successfully accessed but they do change what data is returned by the macro.</para><para><programlisting language="c++">Splitting: Splitting allows the macro to return the rest of the sequence 322 after the element accessed. 323 324 If BOOST_VMD_RETURN_AFTER is specified the return is a tuple 325 with the element accessed as the first tuple parameter and the rest of 326 the sequence as the second tuple parameter. If element access fails 327 both tuple parameters are empty. 328 329 If BOOST_VMD_RETURN_ONLY_AFTER 330 is specified the return is the rest of the sequence after the element accessed 331 found. If the element access fails the return is emptiness. 332 333 If BOOST_VMD_RETURN_NO_AFTER, the default, is specified no splitting 334 occurs. 335 336 If more than one of the splitting identifiers are specified 337 the last one specified determines the splitting. 338 339 Return Type: The element accessed can be changed to return both the type 340 of the element as well as the element data with optional return type 341 parameters. When a type is returned, the element accessed which is returned becomes a 342 two-element tuple where the type of the element accessed is the first tuple element and the element 343 data itself is the second tuple element. If the macro fails to access the 344 element the element access returned is emptiness and not a tuple. 345 346 If BOOST_VMD_RETURN_NO_TYPE, the default, is specified no type is returned 347 as part of the element accessed. 348 349 If BOOST_VMD_RETURN_TYPE is specified the specific type of the element 350 is returned in the tuple. 351 352 If BOOST_VMD_RETURN_TYPE_ARRAY is specified 353 an array type is returned if the element is an array, else a tuple 354 type is returned if the element is a tuple, else the actual type 355 is returned for non-tuple data. 356 357 If BOOST_VMD_RETURN_TYPE_LIST is specified 358 a list type is returned if the element is a list, else a tuple 359 type is returned if the element is a tuple, else the actual type 360 is returned for non-tuple data. 361 362 If BOOST_VMD_RETURN_TYPE_TUPLE is specified 363 a tuple type is returned for all tuple-like data, else the actual type 364 is returned for non-tuple data. If more than one return type optional 365 parameter is specified the last one specified determines the return type. 366 367 If a filter is specified optional return type parameters are ignored and 368 the default BOOST_VMD_RETURN_NO_TYPE is in effect. 369 370 Index: If the filter is specified as the identifier type, BOOST_VMD_TYPE_IDENTIFIER, 371 and matching identifiers are specified, an index parameter specifies that the 372 numeric index, starting with 0, of the matching identifier found, be returned 373 as part of the result. 374 375 If BOOST_VMD_RETURN_INDEX is specified an index is returned 376 as part of the result. 377 378 If BOOST_VMD_RETURN_NO_INDEX, the default, is specified 379 no index is returned as part of the result. 380 381 If both are specified the last one specified determines the index parameter. 382 383 When an index is returned as part of the result, the result is a tuple where the 384 element accessed is the first tuple parameter and the index is the last tuple parameter. 385 If element access fails the index is empty. If there is no BOOST_VMD_TYPE_IDENTIFIER 386 filter or if there are no matching identifiers the BOOST_VMD_RETURN_INDEX is ignored 387 and no index is returned as part of the result. 388</programlisting></para><para>returns = With no optional parameters the element accessed is returned, or emptiness if element is outside the bounds of the sequence. Filters and matching identifiers can change the meaning of whether the element accessed is returned or failure occurs, but whenever failure occurs emptiness is returned as the element access part of that failure, else the element accessed is returned. Return type optional parameters, when filters are not used, return the element accessed as a two-element tuple where the first tuple element is the type and the second tuple element is the data; if the element is not accessed then emptiness is returned as the element access and not a tuple. Splitting with BOOST_VMD_RETURN_AFTER returns a tuple where the element accessed is the first tuple element and the rest of the sequence is the second tuple element. Splitting with BOOST_VMD_RETURN_ONLY_AFTER returns the rest of the sequence after the element accessed or emptiness if the element can not be accessed. Indexing returns the index as part of the output only if filtering with BOOST_VMD_TYPE_IDENTIFIER is specified and matching identifiers are specified. When the index is returned with BOOST_VMD_RETURN_AFTER it is the third element of the tuple returned, else it is the second element of a tuple where the element accessed is the first element of the tuple. </para></description></macro> 389</header> 390<header name="boost/vmd/empty.hpp"> 391<macro name="BOOST_VMD_EMPTY" kind="functionlike"><macro-parameter name="..."/><purpose>Outputs emptiness. </purpose><description><para>... = any variadic parameters. The parameters are ignored.</para><para>This macro is used to output emptiness ( nothing ) no matter what is passed to it.</para><para>If you use this macro to return a result, as in 'result BOOST_VMD_EMPTY' subsequently invoked, you should surround the result with BOOST_VMD_IDENTITY_RESULT to smooth over a VC++ problem. </para></description></macro> 392</header> 393<header name="boost/vmd/enum.hpp"> 394<macro name="BOOST_VMD_ENUM" kind="functionlike"><macro-parameter name="..."/><purpose>Converts a sequence to comma-separated elements which are the elements of the sequence. </purpose><description><para>... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = Comma-separated data, otherwise known as variadic data. If the sequence is empty the variadic data is empty. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as part of the variadic data. Otherwise just the data of each element is returned, which is the default. </para></description></macro> 395<macro name="BOOST_VMD_ENUM_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="..."/><purpose>Converts a sequence to comma-separated elements which are the elements of the sequence. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 396 ... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = Comma-separated data, otherwise known as variadic data. If the sequence is empty the variadic data is empty. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as part of the variadic data. Otherwise just the data of each element is returned, which is the default. </para></description></macro> 397</header> 398<header name="boost/vmd/equal.hpp"> 399<macro name="BOOST_VMD_EQUAL" kind="functionlike"><macro-parameter name="sequence"/><macro-parameter name="..."/><purpose>Tests any two sequences for equality. </purpose><description><para>sequence = First sequence. <sbr/> 400 ... = variadic parameters, maximum of 2.</para><para>The first variadic parameter is required and is the second sequence to test. The optional second variadic parameter is a VMD type as a filter.</para><para>The macro tests any two sequences for equality. For sequences to be equal the VMD types of each sequence must be equal and the individual elements of the sequence must be equal. For Boost PP composite types the macro tests that the composite types have the same size and then tests that each element of the composite type is equal. This means that all elements of a composite type must be a VMD type in order to use this macro successfully.</para><para>The single optional parameter is a filter. The filter is a VMD type which specifies that both sequences to test must be of that VMD type, as well as being equal to each other, for the test to succeed.</para><para>returns = 1 upon success or 0 upon failure. Success means that both sequences are equal and, if the optional parameter is specified, that the sequences are of the optional VMD type. </para></description></macro> 401<macro name="BOOST_VMD_EQUAL_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><macro-parameter name="..."/><purpose>Tests any two sequences for equality. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 402 sequence = First sequence. <sbr/> 403 ... = variadic parameters, maximum of 2.</para><para>The first variadic parameter is required and is the second sequence to test. The optional second variadic parameter is a VMD type as a filter.</para><para>The macro tests any two sequences for equality. For sequences to be equal the VMD types of each sequence must be equal and the individual elements of the sequence must be equal. For Boost PP composite types the macro tests that the composite types have the same size and then tests that each element of the composite type is equal. This means that all elements of a composite type must be a VMD type in order to use this macro successfully.</para><para>The single optional parameter is a filter. The filter is a VMD type which specifies that both sequences to test must be of that VMD type, as well as being equal to each other, for the test to succeed.</para><para>returns = 1 upon success or 0 upon failure. Success means that both sequences are equal and, if the optional parameter is specified, that the sequences are of the optional VMD type. </para></description></macro> 404</header> 405<header name="boost/vmd/get_type.hpp"> 406<macro name="BOOST_VMD_GET_TYPE" kind="functionlike"><macro-parameter name="..."/><purpose>Returns the type of a sequence as a VMD type. </purpose><description><para>... = variadic parameters.</para><para>The first variadic parameter is required and is the sequence whose type we are getting.</para><para>The optional variadic parameters are return type parameters.</para><para>The macro returns the type of a sequence as a VMD type. The type of an empty sequence is always BOOST_VMD_TYPE_EMPTY and the type of a multi-element is always BOOST_VMD_TYPE_SEQUENCE. The type of a single-element sequence is the type of that single element.</para><para>The type returned can be modified by specifying an optional return type parameter.</para><para>If BOOST_VMD_RETURN_TYPE, the default, is specified the specific type of the element is returned.</para><para>If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data.</para><para>If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data.</para><para>If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data.</para><para>If BOOST_VMD_RETURN_NO_TYPE is specified it is ignored since the macro always returns the type of the sequence.</para><para>If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = the type of the sequence as a VMD type. </para></description></macro> 407<macro name="BOOST_VMD_GET_TYPE_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="..."/><purpose>Returns the type of a sequence as a VMD type. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 408 ... = variadic parameters.</para><para>The first variadic parameter is required and is the sequence whose type we are getting.</para><para>The optional variadic parameters are return type parameters.</para><para>The macro returns the type of a sequence as a VMD type. The type of an empty sequence is always BOOST_VMD_TYPE_EMPTY and the type of a multi-element is always BOOST_VMD_TYPE_SEQUENCE. The type of a single-element sequence is the type of that single element.</para><para>The type returned can be modified by specifying an optional return type parameter.</para><para>If BOOST_VMD_RETURN_TYPE, the default, is specified the specific type of the element is returned.</para><para>If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data.</para><para>If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data.</para><para>If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data.</para><para>If BOOST_VMD_RETURN_NO_TYPE is specified it is ignored since the macro always returns the type of the sequence.</para><para>If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = the type of the sequence as a VMD type. </para></description></macro> 409</header> 410<header name="boost/vmd/identity.hpp"> 411<macro name="BOOST_VMD_IDENTITY" kind="functionlike"><macro-parameter name="item"/><purpose>Macro which expands to its argument when invoked with any number of parameters. </purpose><description><para>item = any single argument</para><para>When BOOST_VMD_IDENTITY(item) is subsequently invoked with any number of parameters it expands to 'item'. Subsequently invoking the macro is done as 'BOOST_VMD_IDENTITY(item)(zero_or_more_arguments)'.</para><para>The macro is equivalent to the Boost PP macro BOOST_PP_IDENTITY(item) with the difference being that BOOST_PP_IDENTITY(item) is always invoked with no arguments, as in 'BOOST_VMD_IDENTITY(item)()' whereas BOOST_VMD_IDENTITY can be invoked with any number of arguments.</para><para>The macro is meant to be used in BOOST_PP_IF and BOOST_PP_IIF statements when only one of the clauses needs to be invoked with calling another macro and the other is meant to return an 'item'.</para><para>returns = the macro as 'BOOST_VMD_IDENTITY(item)', when invoked with any number of parameters as in '(zero_or_more_arguments)', returns 'item'. The macro itself returns 'item BOOST_VMD_EMPTY'. </para></description></macro> 412<macro name="BOOST_VMD_IDENTITY_RESULT" kind="functionlike"><macro-parameter name="result"/><purpose>Macro which wraps any result which can return its value using BOOST_VMD_IDENTITY or 'item BOOST_VMD_EMPTY'. </purpose><description><para>result = any single result returned when BOOST_VMD_IDENTITY is used or 'item BOOST_VMD_EMPTY'.</para><para>The reason for this macro is to smooth over a problem when using VC++ with BOOST_VMD_IDENTITY. If your BOOST_VMD_IDENTITY macro can be used where VC++ is the compiler then you need to surround your macro code which could return a result with this macro in order that VC++ handles BOOST_VMD_IDENTITY correctly.</para><para>If you are not using VC++ you do not have to use this macro, but doing so does no harm. </para></description></macro> 413</header> 414<header name="boost/vmd/is_array.hpp"> 415<macro name="BOOST_VMD_IS_ARRAY" kind="functionlike"><macro-parameter name="sequence"/><purpose>Determines if a sequence is a Boost PP array. </purpose><description><para>The macro checks that the sequence is a Boost PP array. It returns 1 if it is an array, else if returns 0.</para><para>sequence = a possible Boost PP array.</para><para>returns = 1 if it is an array, else returns 0.</para><para>The macro will generate a preprocessing error if the input is in the form of an array but its first tuple element, instead of being a number, is a preprocessor token which VMD cannot parse, as in the example '(&2,(0,1))' which is a valid tuple but an invalid array. </para></description></macro> 416<macro name="BOOST_VMD_IS_ARRAY_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Determines if a sequence is a Boost PP array. Re-entrant version. </purpose><description><para>The macro checks that the sequence is a Boost PP array. It returns 1 if it is an array, else if returns 0.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 417 sequence = a possible Boost PP array.</para><para>returns = 1 if it is an array, else returns 0.</para><para>The macro will generate a preprocessing error if the input is in the form of an array but its first tuple element, instead of being a number, is a preprocessor token which VMD cannot parse, as in the example '(&2,(0,1))' which is a valid tuple but an invalid array. </para></description></macro> 418</header> 419<header name="boost/vmd/is_empty.hpp"> 420<macro name="BOOST_VMD_IS_EMPTY" kind="functionlike"><macro-parameter name="..."/><purpose>Tests whether its input is empty or not. </purpose><description><para>The macro checks to see if the input is empty or not. It returns 1 if the input is empty, else returns 0.</para><para>The macro is a variadic macro taking any input. For the VC++8 compiler (VS2005) the macro takes a single parameter of input to check.</para><para>For all levels of C++ prior to C++20 the macro is not perfect, and can not be so. The problem area is if the input to be checked is a function-like macro name, in which case either a compiler error can result or a false result can occur.</para><para>For C++20, with its support for the new <emphasis role="bold">VA_OPT</emphasis> preprocessor construct, the macro will always work correctly no matter what the variadic input, and is therefore 100% reliable.</para><para>This macro is a replacement, using variadic macro support, for the undocumented macro BOOST_PP_IS_EMPTY in the Boost PP library. The code is taken from a posting by Paul Mensonides of a variadic version for BOOST_PP_IS_EMPTY, and changed in order to also support VC++. The code for the C++20 implementation of the macro, using the <emphasis role="bold">VA_OPT</emphasis> preprocessor construct, is the author's own and reuses code added to the Boost preprocessor library by this author.</para><para>... = variadic input, for VC++8 this must be a single parameter</para><para>returns = 1 if the input is empty, 0 if it is not</para><para>It is recommended to append BOOST_PP_EMPTY() to whatever input is being tested in order to avoid possible warning messages from some compilers about no parameters being passed to the macro when the input is truly empty. </para></description></macro> 421<macro name="BOOST_VMD_IS_EMPTY_NO_OPT" kind="functionlike"><macro-parameter name="..."/></macro> 422</header> 423<header name="boost/vmd/is_empty_array.hpp"> 424<macro name="BOOST_VMD_IS_EMPTY_ARRAY" kind="functionlike"><macro-parameter name="sequence"/><purpose>Tests whether a sequence is an empty Boost PP array. </purpose><description><para>An empty Boost PP array is a two element tuple where the first size element is 0 and the second element is a tuple with a single empty element, ie. '(0,())'.</para><para>sequence = a possible empty array</para><para>returns = 1 if the sequence is an empty Boost PP array, 0 if it is not.</para><para>The macro will generate a preprocessing error if the sequence is in the form of an array but its first tuple element, instead of being a number, is a preprocessor token which VMD cannot parse, as in the example '(&0,())' which is a valid tuple but an invalid array. </para></description></macro> 425<macro name="BOOST_VMD_IS_EMPTY_ARRAY_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Tests whether a sequence is an empty Boost PP array. Re-entrant version. </purpose><description><para>An empty Boost PP array is a two element tuple where the first size element is 0 and the second element is a tuple with a single empty element, ie. '(0,())'.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 426 sequence = a possible empty array</para><para>returns = 1 if the sequence is an empty Boost PP array, 0 if it is not.</para><para>The macro will generate a preprocessing error if the sequence is in the form of an array but its first tuple element, instead of being a number, is a preprocessor token which VMD cannot parse, as in the example '(&0,())' which is a valid tuple but an invalid array. </para></description></macro> 427</header> 428<header name="boost/vmd/is_empty_list.hpp"> 429<macro name="BOOST_VMD_IS_EMPTY_LIST" kind="functionlike"><macro-parameter name="sequence"/><purpose>Tests whether a sequence is an empty Boost PP list. </purpose><description><para>An empty Boost PP list consists of the single identifier 'BOOST_PP_NIL'. This identifier also serves as a list terminator for a non-empty list.</para><para>sequence = a preprocessor parameter</para><para>returns = 1 if the sequence is an empty Boost PP list, 0 if it is not.</para><para>The macro will generate a preprocessing error if the input as an empty list marker, instead of being an identifier, is a preprocessor token which VMD cannot parse, as in the example '&BOOST_PP_NIL'. </para></description></macro> 430<macro name="BOOST_VMD_IS_EMPTY_LIST_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Tests whether a sequence is an empty Boost PP list. Re-entrant version. </purpose><description><para>An empty Boost PP list consists of the single identifier 'BOOST_PP_NIL'. This identifier also serves as a list terminator for a non-empty list.</para><para>d = The next available BOOST_PP_WHILE iteration <sbr/> 431 sequence = a preprocessor parameter</para><para>returns = 1 if the sequence is an empty Boost PP list, 0 if it is not.</para><para>The macro will generate a preprocessing error if the input as an empty list marker, instead of being an identifier, is a preprocessor token which VMD cannot parse, as in the example '&BOOST_PP_NIL'. </para></description></macro> 432</header> 433<header name="boost/vmd/is_identifier.hpp"> 434<macro name="BOOST_VMD_IS_IDENTIFIER" kind="functionlike"><macro-parameter name="..."/><purpose>Tests whether a parameter is an identifier. </purpose><description><para>... = variadic parameters</para><para>The first variadic parameter is required and it is the input to test.</para><para>Further variadic parameters are optional and are identifiers to match. The data may take one of two forms; it is either one or more single identifiers or a single Boost PP tuple of identifiers.</para><para><programlisting language="c++">returns = 1 if the parameter is an identifier, otherwise 0. 435 436 If the parameter is not an identifier, 437 or if optional identifiers are specified and the identifier 438 does not match any of the optional identifiers, the macro returns 0. 439</programlisting></para><para>Identifiers are registered in VMD with:</para><para><programlisting language="c++">#define BOOST_VMD_REG_XXX (XXX) where XXX is a v-identifier. 440</programlisting></para><para>The identifier must be registered to be found.</para><para>Identifiers are pre-detected in VMD with:</para><para><programlisting language="c++">#define BOOST_VMD_DETECT_XXX_XXX where XXX is an identifier. 441</programlisting></para><para>If you specify optional identifiers and have not specified the detection of an optional identifier, that optional identifier will never match the input.</para><para>If the input is not a VMD data type this macro could lead to a preprocessor error. This is because the macro uses preprocessor concatenation to determine if the input is an identifier once it is determined that the input does not start with parenthesis. If the data being concatenated would lead to an invalid preprocessor token the compiler can issue a preprocessor error. </para></description></macro> 442<macro name="BOOST_VMD_IS_IDENTIFIER_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="..."/><purpose>Tests whether a parameter is an identifier. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 443 ... = variadic parameters</para><para>The first variadic parameter is required and it is the input to test.</para><para>Further variadic parameters are optional and are identifiers to match. The data may take one of two forms; it is either one or more single identifiers or a single Boost PP tuple of identifiers.</para><para><programlisting language="c++">returns = 1 if the parameter is an identifier, otherwise 0. 444 445 If the parameter is not an identifier, 446 or if optional identifiers are specified and the identifier 447 does not match any of the optional identifiers, the macro returns 0. 448</programlisting></para><para>Identifiers are registered in VMD with:</para><para><programlisting language="c++">#define BOOST_VMD_REG_XXX (XXX) where XXX is a v-identifier. 449</programlisting></para><para>The identifier must be registered to be found.</para><para>Identifiers are pre-detected in VMD with:</para><para><programlisting language="c++">#define BOOST_VMD_DETECT_XXX_XXX where XXX is an identifier. 450</programlisting></para><para>If you specify optional identifiers and have not specified the detection of an optional identifier, that optional identifier will never match the input.</para><para>If the input is not a VMD data type this macro could lead to a preprocessor error. This is because the macro uses preprocessor concatenation to determine if the input is an identifier once it is determined that the input does not start with parenthesis. If the data being concatenated would lead to an invalid preprocessor token the compiler can issue a preprocessor error. </para></description></macro> 451</header> 452<header name="boost/vmd/is_list.hpp"> 453<macro name="BOOST_VMD_IS_LIST" kind="functionlike"><macro-parameter name="sequence"/><purpose>Determines if a sequence is a Boost pplib list. </purpose><description><para>The macro checks that the sequence is a pplib list. It returns 1 if it is a list, else if returns 0.</para><para>sequence = input as a possible Boost PP list.</para><para>returns = 1 if it a list, else returns 0.</para><para>The macro will generate a preprocessing error if the input is in the form of a list but its end-of-list marker, instead of being an identifier, is a preprocessor token which VMD cannot parse, as in the example '(anything,&BOOST_PP_NIL)' which is a valid tuple but an invalid list. </para></description></macro> 454<macro name="BOOST_VMD_IS_LIST_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Determines if a sequence is a Boost pplib list. Re-entrant version. </purpose><description><para>The macro checks that the sequence is a pplib list. It returns 1 if it is a list, else if returns 0.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 455 sequence = input as a possible Boost PP list.</para><para>returns = 1 if it a list, else returns 0.</para><para>The macro will generate a preprocessing error if the input is in the form of a list but its end-of-list marker, instead of being an identifier, is a preprocessor token which VMD cannot parse, as in the example '(anything,&BOOST_PP_NIL)' which is a valid tuple but an invalid list. </para></description></macro> 456</header> 457<header name="boost/vmd/is_multi.hpp"> 458<macro name="BOOST_VMD_IS_MULTI" kind="functionlike"><macro-parameter name="sequence"/><purpose>Determines if the sequence has more than one element, referred to as a multi-element sequence. </purpose><description><para>sequence = a sequence</para><para>returns = 1 if the sequence is a multi-element sequence, else returns 0.</para><para>If the size of a sequence is known it is faster comparing that size to be greater than one to find out if the sequence is multi-element. But if the size of the sequence is not known it is faster calling this macro than getting the size and doing the previously mentioned comparison in order to determine if the sequence is multi-element or not. </para></description></macro> 459<macro name="BOOST_VMD_IS_MULTI_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Determines if the sequence has more than one element, referred to as a multi-element sequence. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 460 sequence = a sequence</para><para>returns = 1 if the sequence is a multi-element sequence, else returns 0.</para><para>If the size of a sequence is known it is faster comparing that size to be greater than one to find out if the sequence is multi-element. But if the size of the sequence is not known it is faster calling this macro than getting the size and doing the previously mentioned comparison in order to determine if the sequence is multi-element or not. </para></description></macro> 461</header> 462<header name="boost/vmd/is_number.hpp"> 463<macro name="BOOST_VMD_IS_NUMBER" kind="functionlike"><macro-parameter name="sequence"/><purpose>Tests whether a sequence is a Boost PP number. </purpose><description><para>The macro checks to see if a sequence is a Boost PP number. A Boost PP number is a value from 0 to 256.</para><para>sequence = a possible number</para><para>returns = 1 if the sequence is a Boost PP number, 0 if it is not.</para><para>If the input is not a VMD data type this macro could lead to a preprocessor error. This is because the macro uses preprocessor concatenation to determine if the input is a number once it is determined that the input does not start with parenthesis. If the data being concatenated would lead to an invalid preprocessor token the compiler can issue a preprocessor error. </para></description></macro> 464</header> 465<header name="boost/vmd/is_parens_empty.hpp"> 466<macro name="BOOST_VMD_IS_PARENS_EMPTY" kind="functionlike"><macro-parameter name="sequence"/><purpose>Determines if the sequence is a set of parens with no data. </purpose><description><para>sequence = a VMD sequence</para><para>returns = 1 if the sequence is a set of parens with no data, else returns 0.</para><para><programlisting language="c++">A set of parens with no data may be: 467 4681) a tuple whose size is a single element which is empty 469 470 or 471 4722) a single element seq whose data is empty 473</programlisting> </para></description></macro> 474<macro name="BOOST_VMD_IS_PARENS_EMPTY_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Determines if the sequence is a set of parens with no data. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 475 sequence = a VMD sequence</para><para>returns = 1 if the sequence is a set of parens with no data, else returns 0.</para><para><programlisting language="c++">A set of parens with no data may be: 476 4771) a tuple whose size is a single element which is empty 478 479 or 480 4812) a single element seq whose data is empty 482</programlisting> </para></description></macro> 483</header> 484<header name="boost/vmd/is_seq.hpp"> 485<macro name="BOOST_VMD_IS_SEQ" kind="functionlike"><macro-parameter name="sequence"/><purpose>Determines if a sequence is a Boost PP seq. </purpose><description><para>The macro checks that the sequence is a Boost PP seq. It returns 1 if it is a seq, else if returns 0.</para><para>sequence = a possible Boost PP seq</para><para>returns = 1 if it a seq, else returns 0.</para><para>A single set of parentheses, with a single element, is parsed as a tuple and not a seq. To be parsed as a seq the input needs to be more than one consecutive sets of parentheses, each with a single element of data. </para></description></macro> 486<macro name="BOOST_VMD_IS_SEQ_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Determines if a sequence is a Boost PP seq. Re-entrant version. </purpose><description><para>The macro checks that the sequence is a Boost PP seq. It returns 1 if it is a seq, else if returns 0.</para><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 487 sequence = a possible Boost PP seq</para><para>returns = 1 if it a seq, else returns 0.</para><para>A single set of parentheses, with a single element, is parsed as a tuple and not a seq. To be parsed as a seq the input needs to be more than one consecutive sets of parentheses, each with a single element of data. </para></description></macro> 488</header> 489<header name="boost/vmd/is_tuple.hpp"> 490<macro name="BOOST_VMD_IS_TUPLE" kind="functionlike"><macro-parameter name="sequence"/><purpose>Tests whether a sequence is a Boost PP tuple. </purpose><description><para>The macro checks to see if a sequence is a Boost PP tuple. A Boost PP tuple is preprocessor tokens enclosed by a set of parentheses with no preprocessing tokens before or after the parentheses.</para><para>sequence = a possible tuple</para><para>returns = 1 if the sequence is a Boost PP tuple, 0 if it is not. </para></description></macro> 491</header> 492<header name="boost/vmd/is_type.hpp"> 493<macro name="BOOST_VMD_IS_TYPE" kind="functionlike"><macro-parameter name="sequence"/><purpose>Tests whether a sequence is a VMD type. </purpose><description><para>sequence = a possible VMD type</para><para>returns = 1 if the sequence is a VMD type, 0 if it is not.</para><para>If the sequence is not a VMD data type this macro could lead to a preprocessor error. This is because the macro uses preprocessor concatenation to determine if the sequence is an identifier once it is determined that the sequence does not start with parentheses. If the data being concatenated would lead to an invalid preprocessor token the compiler can issue a preprocessor error. </para></description></macro> 494<macro name="BOOST_VMD_IS_TYPE_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Tests whether a sequence is a VMD type. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 495 sequence = a possible VMD type</para><para>returns = 1 if the sequence is a VMD type, 0 if it is not.</para><para>If the sequence is not a VMD data type this macro could lead to a preprocessor error. This is because the macro uses preprocessor concatenation to determine if the sequence is an identifier once it is determined that the sequence does not start with parentheses. If the data being concatenated would lead to an invalid preprocessor token the compiler can issue a preprocessor error. </para></description></macro> 496</header> 497<header name="boost/vmd/is_unary.hpp"> 498<macro name="BOOST_VMD_IS_UNARY" kind="functionlike"><macro-parameter name="sequence"/><purpose>Determines if the sequence has only a single element, referred to as a single-element sequence. </purpose><description><para>sequence = a VMD sequence</para><para>returns = 1 if the sequence is a single-element sequence, else returns 0.</para><para>If the size of a sequence is known it is faster comparing that size to be equal to one to find out if the sequence is single-element. But if the size of the sequence is not known it is faster calling this macro than getting the size and doing the previously mentioned comparison in order to determine if the sequence is single-element or not. </para></description></macro> 499<macro name="BOOST_VMD_IS_UNARY_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Determines if the sequence has only a single element, referred to as a single-element sequence. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 500 sequence = a sequence</para><para>returns = 1 if the sequence is a single-element sequence, else returns 0.</para><para>If the size of a sequence is known it is faster comparing that size to be equal to one to find out if the sequence is single-element. But if the size of the sequence is not known it is faster calling this macro than getting the size and doing the previously mentioned comparison in order to determine if the sequence is single-element or not. </para></description></macro> 501</header> 502<header name="boost/vmd/not_equal.hpp"> 503<macro name="BOOST_VMD_NOT_EQUAL" kind="functionlike"><macro-parameter name="sequence"/><macro-parameter name="..."/><purpose>Tests any two sequences for inequality. </purpose><description><para>sequence = First sequence. <sbr/> 504 ... = variadic parameters, maximum of 2.</para><para>The first variadic parameter is required and is the second sequence to test. The optional second variadic parameter is a VMD type as a filter.</para><para>The macro tests any two sequences for inequality. For sequences to be unequal either the VMD types of each sequence must be unequal or the individual elements of the sequence must be unequal.</para><para>The single optional parameter is a filter. The filter is a VMD type which specifies that both sequences to test must be of that VMD type, as well as being equal to each other, for the test to fail, else it succeeds.</para><para>returns = 1 upon success or 0 upon failure. Success means that the sequences are unequal or, if the optional parameter is specified, that the sequences are not of the optional VMD type; otherwise 0 is returned if the sequences are equal.</para><para>The macro is implemented as the complement of BOOST_VMD_EQUAL, so that whenever BOOST_VMD_EQUAL would return 1 the macro returns 0 and whenever BOOST_VMD_EQUAL would return 0 the macro would return 1. </para></description></macro> 505<macro name="BOOST_VMD_NOT_EQUAL_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><macro-parameter name="..."/><purpose>Tests any two sequences for inequality. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 506 sequence = First sequence. <sbr/> 507 ... = variadic parameters, maximum of 2.</para><para>The first variadic parameter is required and is the second sequence to test. The optional second variadic parameter is a VMD type as a filter.</para><para>The macro tests any two sequences for inequality. For sequences to be unequal either the VMD types of each sequence must be unequal or the individual elements of the sequence must be unequal.</para><para>The single optional parameter is a filter. The filter is a VMD type which specifies that both sequences to test must be of that VMD type, as well as being equal to each other, for the test to fail, else it succeeds.</para><para>returns = 1 upon success or 0 upon failure. Success means that the sequences are unequal or, if the optional parameter is specified, that the sequences are not of the optional VMD type; otherwise 0 is returned if the sequences are equal.</para><para>The macro is implemented as the complement of BOOST_VMD_EQUAL, so that whenever BOOST_VMD_EQUAL would return 1 the macro returns 0 and whenever BOOST_VMD_EQUAL would return 0 the macro would return 1. </para></description></macro> 508</header> 509<header name="boost/vmd/seq/is_vmd_seq.hpp"> 510<macro name="BOOST_VMD_IS_VMD_SEQ" kind="functionlike"><macro-parameter name="sequence"/><purpose>Determines if a sequence is a VMD seq. </purpose><description><para>The macro checks that the sequence is a VMD seq. A VMD seq, which may be a Boost PP seq or emptiness, is a superset of a Boost PP seq. It returns 1 if it is a VMD seq, else if returns 0.</para><para>sequence = a possible Boost PP seq</para><para>returns = 1 if it a VMD seq, else returns 0. </para></description></macro> 511</header> 512<header name="boost/vmd/seq/pop_back.hpp"> 513<macro name="BOOST_VMD_SEQ_POP_BACK" kind="functionlike"><macro-parameter name="seq"/><purpose>pops an element from the end of a seq. </purpose><description><para>seq = seq to pop an element from.</para><para>If the seq is an empty seq the result is undefined. If the seq is a single element the result is an empty seq. Otherwise the result is a seq after removing the last element. </para></description></macro> 514</header> 515<header name="boost/vmd/tuple/pop_back.hpp"> 516<macro name="BOOST_VMD_TUPLE_POP_BACK" kind="functionlike"><macro-parameter name="tuple"/><purpose>pops an element from the end of a tuple. </purpose><description><para>tuple = tuple to pop an element from.</para><para>If the tuple is an empty tuple the result is undefined. If the tuple is a single element the result is an empty tuple. Otherwise the result is a tuple after removing the last element. </para></description></macro> 517<macro name="BOOST_VMD_TUPLE_POP_BACK_Z" kind="functionlike"><macro-parameter name="z"/><macro-parameter name="tuple"/><purpose>pops an element from the end of a tuple. It reenters BOOST_PP_REPEAT with maximum efficiency. </purpose><description><para>z = the next available BOOST_PP_REPEAT dimension. <sbr/> 518 tuple = tuple to pop an element from.</para><para>If the tuple is an empty tuple the result is undefined. If the tuple is a single element the result is an empty tuple. Otherwise the result is a tuple after removing the last element. </para></description></macro> 519</header> 520<header name="boost/vmd/seq/pop_front.hpp"> 521<macro name="BOOST_VMD_SEQ_POP_FRONT" kind="functionlike"><macro-parameter name="seq"/><purpose>pops an element from the front of a seq. </purpose><description><para>seq = seq to pop an element from.</para><para>If the seq is an empty seq the result is undefined. If the seq is a single element the result is an empty seq. Otherwise the result is a seq after removing the first element. </para></description></macro> 522</header> 523<header name="boost/vmd/tuple/pop_front.hpp"> 524<macro name="BOOST_VMD_TUPLE_POP_FRONT" kind="functionlike"><macro-parameter name="tuple"/><purpose>pops an element from the front of a tuple. </purpose><description><para>tuple = tuple to pop an element from.</para><para>If the tuple is an empty tuple the result is undefined. If the tuple is a single element the result is an empty tuple. Otherwise the result is a tuple after removing the first element. </para></description></macro> 525<macro name="BOOST_VMD_TUPLE_POP_FRONT_Z" kind="functionlike"><macro-parameter name="z"/><macro-parameter name="tuple"/><purpose>pops an element from the front of a tuple. It reenters BOOST_PP_REPEAT with maximum efficiency. </purpose><description><para>z = the next available BOOST_PP_REPEAT dimension. <sbr/> 526 tuple = tuple to pop an element from.</para><para>If the tuple is an empty tuple the result is undefined. If the tuple is a single element the result is an empty tuple. Otherwise the result is a tuple after removing the first element. </para></description></macro> 527</header> 528<header name="boost/vmd/seq/push_back.hpp"> 529<macro name="BOOST_VMD_SEQ_PUSH_BACK" kind="functionlike"><macro-parameter name="seq"/><macro-parameter name="elem"/><purpose>appends an element to the end of a seq. </purpose><description><para>seq = seq to to append an element to. <sbr/> 530 elem = element to append.</para><para>If the seq is an empty seq the result is a seq with the single element. Otherwise the result is a seq after adding the element to the end. </para></description></macro> 531</header> 532<header name="boost/vmd/tuple/push_back.hpp"> 533<macro name="BOOST_VMD_TUPLE_PUSH_BACK" kind="functionlike"><macro-parameter name="tuple"/><macro-parameter name="elem"/><purpose>appends an element to the end of a tuple. </purpose><description><para>tuple = tuple to to append an element to. <sbr/> 534 elem = element to append.</para><para>If the tuple is an empty tuple the result is a tuple with the single element. Otherwise the result is a tuple after adding the element to the end. </para></description></macro> 535</header> 536<header name="boost/vmd/seq/push_front.hpp"> 537<macro name="BOOST_VMD_SEQ_PUSH_FRONT" kind="functionlike"><macro-parameter name="seq"/><macro-parameter name="elem"/><purpose>inserts an element at the beginning of a seq. </purpose><description><para>seq = seq to insert an element at. <sbr/> 538 elem = element to insert.</para><para>If the seq is an empty seq the result is a seq with the single element. Otherwise the result is a seq after inserting the element at the beginning. </para></description></macro> 539</header> 540<header name="boost/vmd/tuple/push_front.hpp"> 541<macro name="BOOST_VMD_TUPLE_PUSH_FRONT" kind="functionlike"><macro-parameter name="tuple"/><macro-parameter name="elem"/><purpose>inserts an element at the beginning of a tuple. </purpose><description><para>tuple = tuple to insert an element at. <sbr/> 542 elem = element to insert.</para><para>If the tuple is an empty tuple the result is a tuple with the single element. Otherwise the result is a tuple after inserting the element at the beginning. </para></description></macro> 543</header> 544<header name="boost/vmd/seq/remove.hpp"> 545<macro name="BOOST_VMD_SEQ_REMOVE" kind="functionlike"><macro-parameter name="seq"/><macro-parameter name="index"/><purpose>removes an element from a seq. </purpose><description><para>seq = seq from which an element is to be removed. <sbr/> 546 index = The zero-based position in seq of the element to be removed.</para><para>If index is greater or equal to the seq size the result is undefined. If the seq is a single element and the index is 0 the result is an empty seq. Otherwise the result is a seq after removing the index element. </para></description></macro> 547</header> 548<header name="boost/vmd/tuple/remove.hpp"> 549<macro name="BOOST_VMD_TUPLE_REMOVE" kind="functionlike"><macro-parameter name="tuple"/><macro-parameter name="index"/><purpose>removes an element from a tuple. </purpose><description><para>tuple = tuple from which an element is to be removed. <sbr/> 550 index = The zero-based position in tuple of the element to be removed.</para><para>If index is greater or equal to the tuple size the result is undefined. If the tuple is a single element and the index is 0 the result is an empty tuple. Otherwise the result is a tuple after removing the index element. </para></description></macro> 551<macro name="BOOST_VMD_TUPLE_REMOVE_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="tuple"/><macro-parameter name="index"/><purpose>removes an element from a tuple. It reenters BOOST_PP_WHILE with maximum efficiency. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 552 tuple = tuple from which an element is to be removed. <sbr/> 553 index = The zero-based position in tuple of the element to be removed.</para><para>If index is greater or equal to the tuple size the result is undefined. If the tuple is a single element and the index is 0 the result is an empty tuple. Otherwise the result is a tuple after removing the index element. </para></description></macro> 554</header> 555<header name="boost/vmd/seq/size.hpp"> 556<macro name="BOOST_VMD_SEQ_SIZE" kind="functionlike"><macro-parameter name="seq"/><purpose>expands to the size of the seq passed to it. </purpose><description><para>seq = seq whose size is to be extracted.</para><para>If the seq is an empty seq its size is 0. Otherwise the result is the number of elements in the seq. </para></description></macro> 557</header> 558<header name="boost/vmd/size.hpp"> 559<macro name="BOOST_VMD_SIZE" kind="functionlike"><macro-parameter name="sequence"/><purpose>Returns the size of a sequence. </purpose><description><para>sequence = A sequence to test.</para><para>returns = If the sequence is empty returns 0, else returns the number of elements in the sequence. </para></description></macro> 560<macro name="BOOST_VMD_SIZE_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="sequence"/><purpose>Returns the size of a sequence. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 561 sequence = A sequence to test.</para><para>returns = If the sequence is empty returns 0, else returns the number of elements in the sequence. </para></description></macro> 562</header> 563<header name="boost/vmd/tuple/size.hpp"> 564<macro name="BOOST_VMD_TUPLE_SIZE" kind="functionlike"><macro-parameter name="tuple"/><purpose>expands to the size of the tuple passed to it. </purpose><description><para>tuple = tuple whose size is to be extracted.</para><para>If the tuple is an empty tuple its size is 0. Otherwise the result is the number of elements in the tuple. </para></description></macro> 565</header> 566<header name="boost/vmd/seq/to_array.hpp"> 567<macro name="BOOST_VMD_SEQ_TO_ARRAY" kind="functionlike"><macro-parameter name="seq"/><purpose>converts a seq to an array. </purpose><description><para>seq = seq to be converted.</para><para>If the seq is an empty seq it is converted to an array with 0 elements. Otherwise the seq is converted to an array with the same number of elements as the seq. </para></description></macro> 568</header> 569<header name="boost/vmd/to_array.hpp"> 570<macro name="BOOST_VMD_TO_ARRAY" kind="functionlike"><macro-parameter name="..."/><purpose>Converts a sequence to a Boost PP array whose elements are the elements of the sequence. </purpose><description><para>... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = A Boost PP array. The sequence is empty the Boost PP array is an empty array. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as the array element. Otherwise just the data is returned as the array element, which is the default. </para></description></macro> 571<macro name="BOOST_VMD_TO_ARRAY_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="..."/><purpose>Converts a sequence to a Boost PP array whose elements are the elements of the sequence. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 572 ... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = A Boost PP array. The sequence is empty the Boost PP array is empty. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as the array element. Otherwise just the data is returned as the array element, which is the default. </para></description></macro> 573</header> 574<header name="boost/vmd/tuple/to_array.hpp"> 575<macro name="BOOST_VMD_TUPLE_TO_ARRAY" kind="functionlike"><macro-parameter name="tuple"/><purpose>converts a tuple to an array. </purpose><description><para>tuple = tuple to be converted.</para><para>If the tuple is an empty tuple it is converted to an array with 0 elements. Otherwise the tuple is converted to an array with the same number of elements as the tuple. </para></description></macro> 576</header> 577<header name="boost/vmd/seq/to_list.hpp"> 578<macro name="BOOST_VMD_SEQ_TO_LIST" kind="functionlike"><macro-parameter name="seq"/><purpose>converts a seq to a list. </purpose><description><para>seq = seq to be converted.</para><para>If the seq is an empty seq it is converted to an empty list (BOOST_PP_NIL). Otherwise the seq is converted to a list with the same number of elements as the seq. </para></description></macro> 579</header> 580<header name="boost/vmd/to_list.hpp"> 581<macro name="BOOST_VMD_TO_LIST" kind="functionlike"><macro-parameter name="..."/><purpose>Converts a sequence to a Boost PP list whose elements are the elements of the sequence. </purpose><description><para>... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = A Boost PP list. The sequence is empty the Boost PP list is an empty list. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as the list element. Otherwise just the data is returned as the list element, which is the default. </para></description></macro> 582<macro name="BOOST_VMD_TO_LIST_D" kind="functionlike"><macro-parameter name="d"/><macro-parameter name="..."/><purpose>Converts a sequence to a Boost PP list whose elements are the elements of the sequence. Re-entrant version. </purpose><description><para>d = The next available BOOST_PP_WHILE iteration. <sbr/> 583 ... = Variadic parameters.</para><para>The first variadic parameter is required and is the sequence to convert.</para><para>Further optional variadic parameters can be return type parameters. Return type parameters allow each element in the sequence to be converted to a two-element tuple where the first tuple element is the type and the second tuple element is the element data.</para><para>The BOOST_VMD_RETURN_NO_TYPE, the default, does not return the type as part of each converted element but just the data. All of the rest return the type and data as the two-element tuple. If BOOST_VMD_RETURN_TYPE is specified the specific type of the element is returned in the tuple. If BOOST_VMD_RETURN_TYPE_ARRAY is specified an array type is returned if the element is an array, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_LIST is specified a list type is returned if the element is a list, else a tuple type is returned if the element is a tuple, else the actual type is returned for non-tuple data. If BOOST_VMD_RETURN_TYPE_TUPLE is specified a tuple type is returned for all tuple-like data, else the actual type is returned for non-tuple data. If more than one return type optional parameter is specified the last one specified determines the return type.</para><para>returns = A Boost PP list. The sequence is empty the Boost PP list is an empty list. If an optional return type other than BOOST_VMD_RETURN_NO_TYPE is specified the type and the data of each element is returned as the list element. Otherwise just the data is returned as the list element, which is the default. </para></description></macro> 584</header> 585<header name="boost/vmd/tuple/to_list.hpp"> 586<macro name="BOOST_VMD_TUPLE_TO_LIST" kind="functionlike"><macro-parameter name="tuple"/><purpose>converts a tuple to a list. </purpose><description><para>tuple = tuple to be converted.</para><para>If the tuple is an empty tuple it is converted to an empty list (BOOST_PP_NIL). Otherwise the tuple is converted to a list with the same number of elements as the tuple. </para></description></macro> 587</header> 588<header name="boost/vmd/tuple/is_vmd_tuple.hpp"> 589<macro name="BOOST_VMD_IS_VMD_TUPLE" kind="functionlike"><macro-parameter name="sequence"/><purpose>Determines if a sequence is a VMD tuple. </purpose><description><para>The macro checks that the sequence is a VMD tuple. A VMD tuple, which may be a Boost PP tuple or emptiness, is a superset of a Boost PP tuple. It returns 1 if it is a VMD tuple, else if returns 0.</para><para>sequence = a possible Boost PP tuple</para><para>returns = 1 if it a VMD tuple, else returns 0. </para></description></macro> 590</header> 591</library-reference>