+ An array is a data structure consisting of a two-element tuple.
+ The first element is the number of elements in the array.
+ The second element is another tuple of the elements in the array.
+ For example,
+
+
+ (3, (a, b, c))
+
+
+ ...is an array of 3 elements--a, b, and c.
+
+
+ The primary strength of arrays is that they store their own size.
+ Because of this, access to elements does not require the size.
+ It only requires that the element exists at a certain index.
+
+
+ This allows macro parameters to be variable in size and allows data states to change
+ size without the user explicitly keeping track of the size independently.
+
+
+ Elements of an array can be extracted with BOOST_PP_ARRAY_ELEM,
+ an array's size can be extracted with BOOST_PP_ARRAY_SIZE, and
+ an array can be converted to the more primitive tuple data structure
+ with BOOST_PP_ARRAY_DATA.
+
+ A list is a simple cons-style list with a head and a tail.
+ The head of a list is an element,
+ and the tail is either another list or BOOST_PP_NIL.
+ For example,
+
+
+ (a, (b, (c, BOOST_PP_NIL)))
+
+
+ ...is a list of 3 elements--a, b, and c.
+
+
+ This allows macro parameters to be variable in size and allows data states to change
+ size without the user explicitly keeping track of the size independently.
+
+
+ Elements of a list can be extracted with
+ BOOST_PP_LIST_FIRST and BOOST_PP_LIST_REST.
+
+ The repetition/enum_params_with_a_default.hpp header defines a construct that produces a comma-separated list of parameters with a default argument.
+
+ The BOOST_PP_ADD macro expands to the sum of its arguments.
+
+
Usage
+
+ BOOST_PP_ADD(x, y)
+
+
Arguments
+
+
x
+
+ The first addend of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The second addend of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If the sum of x and y is greater than BOOST_PP_LIMIT_MAG, the result is saturated to BOOST_PP_LIMIT_MAG.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_ADD_D in such a situation.
+
+
+ This macro is the most efficient when x is less than or equal to y.
+ However, the efficiency gain is not worth actually comparing the two arguments prior to invocation.
+ In other words, x should be the addend that is most likely to be the largest of the two operands.
+
+ The BOOST_PP_ADD_D macro expands to the sum of its second and third arguments.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+
Usage
+
+ BOOST_PP_ADD_D(d, x, y)
+
+
Arguments
+
+
d
+
+ The next available BOOST_PP_WHILE iteration.
+
+
x
+
+ The first addend of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The second addend of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If the sum of x and y is greater than BOOST_PP_LIMIT_MAG, the result is saturated to BOOST_PP_LIMIT_MAG.
+
+
+ This macro is the most efficient when x is less than or equal to y.
+ However, the efficiency gain is not worth actually comparing the two arguments prior to invocation.
+ In other words, x should be the addend that is most likely to be the largest of the two operands.
+
+ The BOOST_PP_AND macro expands to the logical AND of its operands.
+
+
Usage
+
+ BOOST_PP_AND(p, q)
+
+
Arguments
+
+
p
+
+ The left operand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
q
+
+ The right operand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If both p and q are non-zero, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro performs a boolean conversion on each operand before performing the logical AND operation.
+ If that conversion is not necessary, use BOOST_PP_BITAND instead.
+
+ The BOOST_PP_ASSIGN_SLOT macro fully evaluates a numeric macro or expression.
+
+
Usage
+
+ #include BOOST_PP_ASSIGN_SLOT(i)
+
+
Arguments
+
+
i
+
+ The slot index that is to be assigned.
+ This value must be in the range of 1 to BOOST_PP_LIMIT_SLOT_COUNT.
+
+
+
Remarks
+
+ Prior to use, the named external argumentBOOST_PP_VALUE must be defined.
+ Also, it must expand to a numeric value that is in the range of 0 to 2^32 - 1.
+
+ The BOOST_PP_BITAND macro expands to the bitwise AND of its operands.
+
+
Usage
+
+ BOOST_PP_BITAND(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the operation.
+ This value must expand to 0 or 1.
+
+
y
+
+ The right operand of the operation.
+ This value must expand to 0 or 1.
+
+
+
Remarks
+
+ If both x and y are 1, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro does not perform a boolean conversion on either operand before performing the bitwise AND operation.
+ If that conversion is necessary, use BOOST_PP_AND instead.
+
+ The BOOST_PP_BITNOR macro expands to the bitwise NOR of its operands.
+
+
Usage
+
+ BOOST_PP_BITNOR(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the operation.
+ This value must expand to 0 or 1.
+
+
y
+
+ The right operand of the operation.
+ This value must expand to 0 or 1.
+
+
+
Remarks
+
+ If neither x nor y is 1, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro does not perform a boolean conversion on either operand before performing the bitwise NOR operation.
+ If that conversion is necessary, use BOOST_PP_NOR instead.
+
+ The BOOST_PP_BITOR macro expands to the bitwise OR of its operands.
+
+
Usage
+
+ BOOST_PP_BITOR(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the operation.
+ This value must expand to 0 or 1.
+
+
y
+
+ The right operand of the operation.
+ This value must expand to 0 or 1.
+
+
+
Remarks
+
+ If either x or y is 1, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro does not perform a boolean conversion on either operand before performing the bitwise OR operation.
+ If that conversion is necessary, use BOOST_PP_OR instead.
+
+ The BOOST_PP_BITXOR macro expands to the bitwise XOR of its operands.
+
+
Usage
+
+ BOOST_PP_BITXOR(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the operation.
+ This value must expand to 0 or 1.
+
+
y
+
+ The right operand of the operation.
+ This value must expand to 0 or 1.
+
+
+
Remarks
+
+ If either x or y is 1 exclusively, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro does not perform a boolean conversion on either operand before performing the bitwise OR operation.
+ If that conversion is necessary, use BOOST_PP_XOR instead.
+
+ The BOOST_PP_BOOL macro performs a boolean conversion on its operand.
+
+
Usage
+
+ BOOST_PP_BOOL(x)
+
+
Arguments
+
+
x
+
+ The value to be converted.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG*.
+
+
+
Remarks
+
+ If x is 0, this macro expands to 0.
+ Otherwise it expands to 1.
+
+
+ *If BOOST_PP_CONFIG_FLAGS does not include BOOST_PP_CONFIG_EDG, this macro can convert an infinite range--e.g. BOOST_PP_BOOL(123456789).
+ However, it is not safe to rely on this behavior unless it is known that EDG-based compilers will never be used.
+
+ The BOOST_PP_COMPL macro performs a bitwise inversion (bitwise NOT or one's complement) on its operand.
+
+
Usage
+
+ BOOST_PP_COMPL(x)
+
+
Arguments
+
+
x
+
+ The value to be converted.
+ This value must expand to 0 or 1.
+
+
+
Remarks
+
+ If x is 0, this macro expands to 1.
+ If x is 1, this it expands to 0.
+
+
+ This macro does not perform a boolean conversion on its operand before performing the inversion OR operation.
+ If that conversion is necessary, use BOOST_PP_NOT instead.
+
+ The BOOST_PP_CONFIG_ERRORS is a user-defined macro that determines whether library overflows and certain other errors are expanded to error messages.
+
+
Usage
+
+ #define BOOST_PP_CONFIG_ERRORSn
+
+
Arguments
+
+
n
+
+ The value that determines if error codes are expanded.
+ This value must be 0 or 1.
+
+
+
Remarks
+
+ By default, if NDEBUG is not defined, this macro is set to 1.
+ Otherwise, it is set to 0.
+
+ The BOOST_PP_CONFIG_EXTENDED_LINE_INFO is a user-defined macro that determines whether BOOST_PP_LINE outputs extended file-iteration state information.
+
+
Usage
+
+ #define BOOST_PP_CONFIG_EXTENDED_LINE_INFOn
+
+
Arguments
+
+
n
+
+ The value that determines if BOOST_PP_LINE outputs extended file-iteration information.
+ This value must be 0 or 1.
+
+
+
Remarks
+
+ If n is 1, BOOST_PP_LINE will output extended data.
+ By default, this macro is set to 0.
+
+ The BOOST_PP_DIV macro expands to the quotient of its arguments.
+
+
Usage
+
+ BOOST_PP_DIV(x, y)
+
+
Arguments
+
+
x
+
+ The dividend (numerator) of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The divisor (denominator) of the operation.
+ Valid values range from 1 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_DIV_D in such a situation.
+
+ The BOOST_PP_ENUM macro generates a comma-separated list.
+
+
Usage
+
+ BOOST_PP_ENUM(count, macro, data)
+
+
Arguments
+
+
count
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_ENUM with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
+
Remarks
+
+ This macro expands to the comma-separated sequence:
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_ENUM_z.
+
+
+ Previously, this macro could not be used recursively inside BOOST_PP_REPEAT.
+ This limitation no longer exists, as the library can automatically detect the next available repetition depth.
+
+#include <boost/preprocessor/repetition/enum.hpp>
+
+#define TEXT(z, n, text) text
+
+BOOST_PP_ENUM(4, TEXT, class) // expands to class, class, class, class
+
+ The BOOST_PP_ENUM_BINARY_PARAMS macro generates a comma-separated list of binary parameters.
+
+
Usage
+
+ BOOST_PP_ENUM_BINARY_PARAMS(count, p1, p2)
+
+
Arguments
+
+
count
+
+ The number of parameters to generate.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
p1
+
+ The text of the first part of the parameter.
+ BOOST_PP_ENUM_BINARY_PARAMS concatenates numbers ranging from 0 to count - 1
+ to generate parameters.
+
+
p2
+
+ The text of the first part of the parameter.
+ BOOST_PP_ENUM_BINARY_PARAMS concatenates numbers ranging from 0 to count - 1
+ to generate parameters.
+
+
+
Remarks
+
+ This macro expands to the comma-separated sequence:
+
+ The BOOST_PP_ENUM_BINARY_PARAMS_Z macro generates a comma-separated list of binary parameters.
+ It reenters BOOST_PP_REPEAT with maximum efficiency.
+
+ The number of parameters to generate.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
p1
+
+ The text of the first part of the parameter.
+ BOOST_PP_ENUM_BINARY_PARAMS concatenates numbers ranging from 0 to count - 1
+ to generate parameters.
+
+
p2
+
+ The text of the first part of the parameter.
+ BOOST_PP_ENUM_BINARY_PARAMS concatenates numbers ranging from 0 to count - 1
+ to generate parameters.
+
+
+
Remarks
+
+ This macro expands to the comma-separated sequence:
+
+ To use the z parameter passed from other macros that use BOOST_PP_REPEAT, see BOOST_PP_ENUM_PARAMS_Z.
+
+
+ Previously, this macro could not be used recursively inside BOOST_PP_REPEAT.
+ This limitation no longer exists, as the library can automatically detect the next available repetition depth.
+
+ Previously, this macro could not be used recursively inside BOOST_PP_REPEAT.
+ This limitation no longer exists, as the library can automatically detect the next available repetition depth.
+
+
+ This macro is deprecated.
+ It only exists for backward compatibility.
+ Use BOOST_PP_ENUM_BINARY_PARAMS with BOOST_PP_INTERCEPT instead:
+
+ The number of parameters to generate.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
param
+
+ The text of the parameter.
+ BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS concatenates numbers ranging from 0 to count - 1
+ to generate parameters.
+
+
def
+
+ The default value that trails each parameter.
+ BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS concatenates numbers ranging from 0 to count - 1
+ to generate default arguments.
+
+
+
Remarks
+
+ This macro expands to the comma-separated sequence:
+
+ Previously, this macro could not be used recursively inside BOOST_PP_REPEAT.
+ This limitation no longer exists, as the library can automatically detect the next available repetition depth.
+
+
+ This macro is deprecated.
+ It only exists for backward compatibility.
+ Use BOOST_PP_ENUM_BINARY_PARAMS instead:
+
+ The BOOST_PP_ENUM_SHIFTED macro generates a comma-separated, shifted list.
+
+
Usage
+
+ BOOST_PP_ENUM_SHIFTED(count, macro, data)
+
+
Arguments
+
+
count
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_ENUM_SHIFTED with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
+
Remarks
+
+ This macro expands to the comma-separated sequence:
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_ENUM_SHIFTED_z.
+
+
+ Previously, this macro could not be used recursively inside BOOST_PP_REPEAT.
+ This limitation no longer exists, as the library can automatically detect the next available repetition depth.
+
+ The BOOST_PP_ENUM_SHIFTED_PARAMS macro generates a comma-separated, shifted list of parameters.
+
+
Usage
+
+ BOOST_PP_ENUM_SHIFTED_PARAMS(count, param)
+
+
Arguments
+
+
count
+
+ The number of parameters to generate.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
param
+
+ The text of the parameter.
+ BOOST_PP_ENUM_SHIFTED_PARAMS concatenates numbers ranging from 1 to count - 1
+ to generate parameters.
+
+
+
Remarks
+
+ This macro expands to the comma-separated sequence:
+
+ param ## 1, ... param ## count - 1
+
+
+
+ This macro facilitates a typical usage of the library.
+ Shifted parameter lists are common in template metaprograms.
+
+
+ To use the z parameter passed from other macros that use BOOST_PP_REPEAT, see BOOST_PP_ENUM_SHIFTED_PARAMS_Z.
+
+
+ Previously, this macro could not be used recursively inside BOOST_PP_REPEAT.
+ This limitation no longer exists, as the library can automatically detect the next available repetition depth.
+
+ The BOOST_PP_ENUM_SHIFTED_PARAMS_Z macro generates a comma-separated, shifted list of parameters.
+ It reenters BOOST_PP_REPEAT with maximum efficiency.
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_ENUM_SHIFTED with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+ At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator.
+ This happens when the z value is a macro invocation itself.
+ It needs a delay to allow it to expand.
+ The syntax in such a scenario becomes:
+
+ The BOOST_PP_ENUM_z macro represents a reentry into the BOOST_PP_ENUM repetition construct.
+
+
Usage
+
+ BOOST_PP_ENUM_ ## z(count, macro, data)
+
+
Arguments
+
+
z
+
+ The next available BOOST_PP_REPEAT dimension.
+
+
count
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_ENUM with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+ At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator.
+ This happens when the z value is a macro invocation itself.
+ It needs a delay to allow it to expand.
+ The syntax in such a scenario becomes:
+
+ The BOOST_PP_EQUAL macro compares two values for equality.
+
+
Usage
+
+ BOOST_PP_EQUAL(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The right operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If x is equal to y, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction because this macro no longer uses BOOST_PP_WHILE.
+
+ The BOOST_PP_EXPAND macro performs a double macro-expansion on its argument.
+
+
Usage
+
+ BOOST_PP_EXPAND(x)
+
+
Arguments
+
+
x
+
+ The argument to be expanded twice.
+
+
+
Remarks
+
+ This macro is useful when a delay is necessary to produce the correct semantics of a macro invocation.
+ For example, when a macro expands to an argument list to another macro.
+ This macro will expand the the argument list on the first pass, and then rescan to expand any more macros.
+
+ The BOOST_PP_FOR macro represents a generalized horizontal repetition construct.
+
+
Usage
+
+ BOOST_PP_FOR(state, pred, op, macro)
+
+
Arguments
+
+
state
+
+ The initial state.
+
+
pred
+
+ A binary predicate of the form pred(r, state).
+ This macro must expand to an integer in the range of 0 to BOOST_PP_LIMIT_MAG.
+ BOOST_PP_FOR repeatedly expands macro while this predicate returns non-zero.
+ This macro is called with the next available BOOST_PP_FOR repetition and the current state.
+
+
op
+
+ A binary operation of the form op(r, state).
+ This operation is expanded by BOOST_PP_FOR with the next available BOOST_PP_FOR repetition and the current state.
+ This macro is repeatedly applied to the state, each time producing a new state, until pred returns 0.
+
+
macro
+
+ A binary macro of the form macro(r, state).
+ This macro is expanded by BOOST_PP_FOR with the next available BOOST_PP_FOR repetition and the current state.
+ This macro is is repeated by BOOST_PP_FOR until pred returns 0.
+
+ The r value that is passed to pred, op, and macro represents the next available BOOST_PP_FOR repetition.
+ Other macros that have _R suffix variants internally use BOOST_PP_FOR--for example, BOOST_PP_LIST_FOR_EACH and BOOST_PP_LIST_FOR_EACH_R.
+ Using these _R versions is not strictly necessary, but passing the r value (that is passed to pred, op, and macro) to these macros allows them to reenter BOOST_PP_FOR with maximum efficiency.
+
+
+ To directly use this r value, rather than simply passing it to another macro, see BOOST_PP_FOR_r.
+
+
+ Previously, this macro could not be used recursively inside BOOST_PP_FOR.
+ This limitation no longer exists, as the library can automatically detect the next available BOOST_PP_FOR repetition.
+
+ The BOOST_PP_FOR_r macro represents a reentry into the BOOST_PP_FOR repetition construct.
+
+
Usage
+
+ BOOST_PP_FOR_ ## r(state, pred, op, macro)
+
+
Arguments
+
+
r
+
+ The next available BOOST_PP_FOR repetition.
+
+
state
+
+ The initial state.
+
+
pred
+
+ A binary predicate of the form pred(r, state).
+ This macro must expand to an integer in the range of 0 to BOOST_PP_LIMIT_MAG.
+ BOOST_PP_FOR repeatedly expands macro while this predicate returns non-zero.
+ This macro is called with the next available BOOST_PP_FOR repetition and the current state.
+
+
op
+
+ A binary operation of the form op(r, state).
+ This operation is expanded by BOOST_PP_FOR with the next available BOOST_PP_FOR repetition and the current state.
+ This macro is repeatedly applied to the state, each time producing a new state, until pred returns 0.
+
+
macro
+
+ A binary macro of the form macro(r, state).
+ This macro is expanded by BOOST_PP_FOR with the next available BOOST_PP_FOR repetition and the current state.
+ This macro is is repeated by BOOST_PP_FOR until pred returns 0.
+
+ At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator.
+ This happens when the r value is a macro invocation itself.
+ It needs a delay to allow it to expand.
+ The syntax in such a scenario becomes:
+
+ The BOOST_PP_GREATER macro compares two values for greater magnitude.
+
+
Usage
+
+ BOOST_PP_GREATER(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The right operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If x is greater than y, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_GREATER_D in such a situation.
+
+ The BOOST_PP_GREATER_EQUAL macro compares two values for equality or greater magnitude.
+
+
Usage
+
+ BOOST_PP_GREATER_EQUAL(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The right operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If x is greater than or equal to y, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_GREATER_EQUAL_D in such a situation.
+
+ The BOOST_PP_INCLUDE_SELF macro includes a file indirectly.
+
+
Usage
+
+ #include BOOST_PP_INCLUDE_SELF()
+
+
Arguments
+
+
filename
+
+ A quoted or angle-bracketed filename to be included by BOOST_PP_INCLUDE_SELF.
+
+
+
Remarks
+
+ BOOST_PP_INDIRECT_SELF must be defined prior to using this macro.
+
+
+ Most preprocessors will not allow a file to directly include itself--even when the file protects itself from such a scenario.
+ This macro, in combination with BOOST_PP_INDIRECT_SELF allows a file to include itself indirectly.
+
+
+ While BOOST_PP_INDIRECT_SELF is being included, BOOST_PP_INCLUDE_SELF defines the macro BOOST_PP_IS_SELFISH to 1.
+ When it returns from the inclusion, BOOST_PP_IS_SELFISH is undefined.
+
+ The BOOST_PP_INDIRECT_SELF macro is a user-defined named external argument used by BOOST_PP_INCLUDE_SELF.
+
+
Usage
+
+ #define BOOST_PP_INDIRECT_SELFfilename
+
+
Arguments
+
+
filename
+
+ A quoted or angle-bracketed filename to be included by BOOST_PP_INCLUDE_SELF.
+
+
+
Remarks
+
+ Most preprocessors will not allow a file to directly include itself--even when the file protects itself from such a scenario.
+ This macro, in combination with BOOST_PP_INCLUDE_SELF allows a file to include itself indirectly.
+
+
+ This macro is automatically undefined for reuse by a call to BOOST_PP_INCLUDE_SELF.
+
+ The BOOST_PP_INTERCEPT macro intercepts a numeric concatenation and expands to nothing.
+
+
Usage
+
+ BOOST_PP_INTERCEPT
+
+
Remarks
+
+ This macro is used to intercept concatenations performed by various other library constructs.
+ It is typically used after other text to prevent eat the concatenation expand to nothing.
+ This macro can only intercept integer constants in the range of 0 to BOOST_PP_LIMIT_MAG.
+
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+BOOST_PP_ENUM_BINARY_PARAMS(3, class T, = U)
+// expands to class T0 = U0, class T1 = U1, class T2 = U2
+
+BOOST_PP_ENUM_BINARY_PARAMS(3, class T, = int BOOST_PP_INTERCEPT)
+// expands to class T0 = int, class T1 = int, class T2 = int
+
+ The BOOST_PP_ITERATE macro initiates a file-iteration.
+
+
Usage
+
+ #include BOOST_PP_ITERATE()
+
+
Remarks
+
+ Arguments to this macro are passed as external named arguments in one of two
+ ways--either through BOOST_PP_FILENAME_x and BOOST_PP_ITERATION_LIMITSor
+ through BOOST_PP_ITERATION_PARAMS_x.
+
+
+ Three pieces of information are required to perform a file-iteration.
+ First, the name of a file to iterate over.
+ This is passed via BOOST_PP_FILENAME_xor as part of BOOST_PP_ITERATION_PARAMS_x.
+ The file-iteration mechanism will repeatedly include this file with iteration values ranging from a lower bound to an upper bound--the second and third required parameters.
+ These two boundaries are either passed through BOOST_PP_ITERATION_LIMITSor as part of BOOST_PP_ITERATION_PARAMS_x.
+
+
+ Optionally, a fourth parameter may be passed that associates flags with an iteration.
+ These flags are primarily useful to distinguish one iteration from another in the same file.
+ This parameter can only be passed through BOOST_PP_ITERATION_PARAMS_x.
+
+
+ While a file-iteration is in progress, BOOST_PP_IS_ITERATING is defined as 1.
+
+ The BOOST_PP_ITERATION_LIMITS macro is a user-defined named external argument used by BOOST_PP_ITERATE.
+ It denotes the lower and upper bounds of a file-iteration.
+
+ The lower bound (inclusive) of a file-iteration.
+ Valid values range from 0 to BOOST_PP_LIMIT_ITERATION.
+
+
finish
+
+ The upper bound (inclusive) of a file-iteration.
+ Valid values range from 0 to BOOST_PP_LIMIT_ITERATION.
+
+
+
Remarks
+
+ Note that there is a whitespace character after the macro identifier.
+
+
+ This macro is part of the secondary method of passing arguments to BOOST_PP_ITERATE.
+ The other part is BOOST_PP_FILENAME_x. Both start and finish are evaluated parameters.
+ This implies that they may include simple arithmetic.
+
+
+ This macro is automatically undefined for reuse by a call to BOOST_PP_ITERATE.
+
+ The BOOST_PP_ITERATION_PARAMS_x macro is a user-defined named external argument used by BOOST_PP_ITERATE.
+ It denotes the lower bound, upper bound, and the filename of a file-iteration. It can optionally denote flags associated with a file-iteration as well.
+
+ The iteration depth of the next file-iteration.
+ This value must be the current iteration depth + 1.
+
+
c
+
+ The number of parameters.
+ If flags is specified, this value must be 4.
+ Otherwise, it must be 3.
+
+
start
+
+ The lower bound (inclusive) of a file-iteration.
+ Valid values range from 0 to BOOST_PP_LIMIT_ITERATION.
+
+
finish
+
+ The upper bound (inclusive) of a file-iteration.
+ Valid values range from 0 to BOOST_PP_LIMIT_ITERATION.
+
+
filename
+
+ A quoted or angle-bracketed filename to used as the target of a file-iteration.
+
+
[flags]
+
+ A quoted or angle-bracketed filename to used as the target of a file-iteration.
+
+
+
Remarks
+
+ Note that there is a whitespace character after the macro identifier.
+
+
+ This macro is must be defined as an array of arguments in one of the two formats above (with or without flags).
+ It is the primary method of passing arguments to BOOST_PP_ITERATE.
+ Both start and finish are evaluated parameters, which implies that simple arithmetic can be used.
+
+
+ This macro is automatically undefined for reuse by a call to BOOST_PP_ITERATE.
+
+ The BOOST_PP_LESS macro compares two values for lesser magnitude.
+
+
Usage
+
+ BOOST_PP_LESS(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The right operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If x is less than y, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LESS_D in such a situation.
+
+ The BOOST_PP_LESS_EQUAL macro compares two values for equality or lesser magnitude.
+
+
Usage
+
+ BOOST_PP_LESS_EQUAL(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The right operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If x is lesser than or equal to y, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LESS_EQUAL_D in such a situation.
+
+ The BOOST_PP_LIMIT_BOOL macro defines the maximum integer value that can be passed to BOOST_PP_BOOL.
+
+
Usage
+
+ BOOST_PP_LIMIT_BOOL
+
+
Remarks
+
+ If BOOST_PP_CONFIG_FLAGS does not include BOOST_PP_CONFIG_EDG,
+ this macro expands to BOOST_PP_INFINITY.
+ Otherwise it expands to BOOST_PP_LIMIT_MAG.
+
+ The BOOST_PP_LINE macro places notes encoded as line directives in the preprocessing output.
+
+
Usage
+
+ #line BOOST_PP_LINE(line, file)
+
+
Arguments
+
+
line
+
+ The new line number of the trailing line.
+ The predefined macro __LINE__ is commonly used.
+
+
file
+
+ Typically the name of the current file.
+ However, any informative text will work.
+ This text is internally stringized, so quotation marks are unnecessary.
+
+
+
Remarks
+
+ If the macro BOOST_PP_CONFIG_EXTENDED_LINE_INFO is defined as 1 and a file-iteration
+ is in progress, this macro will automatically insert debugging information about the state of file-iteration.
+ This information will show the all of the current iteration values with the inner most iteration last.
+
+
+ This information is useful when errors might be spanning multiple iterations of the same source text.
+ Finding any errors is sometimes less than straightforward.
+ Use of this macro can provide information to make this much easier.
+ For example, instead of getting several errors like this:
+
+ "file.hpp", line 2: error: expected a ";"
+ "file.hpp", line 4: error: improperly terminated macro invocation
+
+ You might get something like this instead....
+
+ "file.hpp [1]", line 2: error: expected a ";"
+ "file.hpp [5]", line 4: error: improperly terminated macro invocation
+
+ It is immediately evident that this error is spanning multiple iterations of the same source text.
+ If it wasn't, the same errors would occur on each iteration.
+
+
+ It must be noted however, that some compilers don't like filenames that aren't actually files.
+ Those compilers typically issues warnings about the bad filename.
+ This makes it a good idea to only define BOOST_PP_CONFIG_EXTENDED_LINE_INFO to 1only when debugging.
+
+ The BOOST_PP_LIST_APPEND macro appends two lists.
+
+
Usage
+
+ BOOST_PP_LIST_APPEND(a, b)
+
+
Arguments
+
+
a
+
+ The first list.
+
+
b
+
+ The second list.
+
+
+
Remarks
+
+ This macro appends two lists.
+ For example, if a is (1, (2, (3, BOOST_PP_NIL))) and b is (4, (5, BOOST_PP_NIL)),
+ this macro will expand to:
+
+ (1, (2, (3, (4, (5, BOOST_PP_NIL)))))
+
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_APPEND_D in such a situation.
+
+ The BOOST_PP_LIST_AT macro extracts an element in a list.
+
+
Usage
+
+ BOOST_PP_LIST_AT(list, index)
+
+
Arguments
+
+
list
+
+ The list from which a element is to be extracted.
+ This list must have at least index + 1 elements.
+
+
index
+
+ The zero-based position in the list of the element to be extracted.
+
+
+
Remarks
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_AT_D in such a situation.
+
+#include <boost/preprocessor/list/at.hpp>
+
+#define LIST (a, (b, (c, BOOST_PP_NIL)))
+
+BOOST_PP_LIST_AT(LIST, 0) // expands to a
+BOOST_PP_LIST_AT(LIST, 2) // expands to c
+
+ The BOOST_PP_LIST_CAT macro concatenates all elements in a list.
+
+
Usage
+
+ BOOST_PP_LIST_CAT(list)
+
+
Arguments
+
+
list
+
+ The list whose elements are to be concatenated.
+
+
+
Remarks
+
+ Elements are concatenated left-to-right starting with index 0.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_CAT_D in such a situation.
+
+ The BOOST_PP_LIST_ENUM macro converts a list to a comma-separated list.
+
+
Usage
+
+ BOOST_PP_LIST_ENUM(list)
+
+
Arguments
+
+
list
+
+ The list to be converted.
+
+
+
Remarks
+
+ If list is, for example, (a, (b, (c, BOOST_PP_NIL))),
+ this macro will produce:
+
+ a, b, c
+
+
+
+ Previously, this macro could not be used inside BOOST_PP_FOR.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_ENUM_R in such a situation.
+
+ The BOOST_PP_LIST_FILTER macro filters a list according to a supplied criterion.
+
+
Usage
+
+ BOOST_PP_LIST_FILTER(pred, data, list)
+
+
Arguments
+
+
pred
+
+ A ternary predicate of the form pred(d, data, elem).
+ This predicate is expanded by BOOST_PP_LIST_FILTER for each element in list with the next available BOOST_PP_WHILE iteration,
+ the auxiliary data, and the current element in list.
+ This macro must return a integral value in the range of 0 to BOOST_PP_LIMIT_MAG.
+ If this predicate expands to non-zero for a certain element, that element is included in the resulting list.
+
+
data
+
+ Auxiliary data passed to pred.
+
+
list
+
+ The list to be filtered.
+
+
+
Remarks
+
+ This macro expands pred for each element in list.
+ It builds a new list out of each element for which pred returns non-zero.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_FILTER_D in such a situation.
+
+ The BOOST_PP_LIST_FILTER_D macro filters a list according to a supplied criterion.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+
Usage
+
+ BOOST_PP_LIST_FILTER_D(d, pred, data, list)
+
+
Arguments
+
+
d
+
+ The next available BOOST_PP_WHILE iteration.
+
+
pred
+
+ A ternary predicate of the form pred(d, data, elem).
+ This predicate is expanded by BOOST_PP_LIST_FILTER for each element in list with the next available BOOST_PP_WHILE iteration,
+ the auxiliary data, and the current element in list.
+ This macro must return a integral value in the range of 0 to BOOST_PP_LIMIT_MAG.
+ If this predicate expands to non-zero for a certain element, that element is included in the resulting list.
+
+
data
+
+ Auxiliary data passed to pred.
+
+
list
+
+ The list to be filtered.
+
+
+
Remarks
+
+ This macro expands pred for each element in list.
+ It builds a new list out of each element for which pred returns non-zero.
+
+ The BOOST_PP_LIST_FIRST_N macro expands to a list of the first count elements of a list.
+
+
Usage
+
+ BOOST_PP_LIST_FIRST_N(count, list)
+
+
Arguments
+
+
count
+
+ The number of elements to extract.
+
+
list
+
+ The list from which the elements are extracted.
+
+
+
Remarks
+
+ This macro extracts count elements from the beginning of list and returns them as a list
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_FIRST_N_D in such a situation.
+
+ The BOOST_PP_LIST_FOLD_LEFT macro folds (or accumulates) the elements of a list left-to-right.
+
+
Usage
+
+ BOOST_PP_LIST_FOLD_LEFT(op, state, list)
+
+
Arguments
+
+
op
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_LEFT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ op(d, op(d, op(d, state, 0), 1), 2)
+
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_FOLD_LEFT_d in such a situation.
+
+ The BOOST_PP_LIST_FOLD_LEFT_2ND macro folds (or accumulates) the elements of a list left-to-right.
+
+
Usage
+
+ BOOST_PP_LIST_FOLD_LEFT_2ND(op, state, list)
+
+
Arguments
+
+
op
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_LEFT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ op(d, op(d, op(d, state, 0), 1), 2)
+
+
+
+ This macro is deprecated.
+ Use BOOST_PP_LIST_FOLD_LEFT_d instead.
+
+ The BOOST_PP_LIST_FOLD_LEFT_2ND_D macro folds (or accumulates) the elements of a list left-to-right.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_LEFT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ op(d, op(d, op(d, state, 0), 1), 2)
+
+
+
+ This macro has been superceded by BOOST_PP_LIST_FOLD_LEFT_d and is deprecated.
+ It only allows a single reentry into BOOST_PP_LIST_FOLD_LEFT.
+
+ The BOOST_PP_LIST_FOLD_LEFT_d macro folds (or accumulates) the elements of a list left-to-right.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_LEFT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ The BOOST_PP_LIST_FOLD_LEFT_D macro folds (or accumulates) the elements of a list left-to-right.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+
Usage
+
+ BOOST_PP_LIST_FOLD_LEFT_D(d, op, state, list)
+
+
Arguments
+
+
d
+
+ The next available BOOST_PP_WHILE iteration.
+
+
op
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_LEFT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ op(d, op(d, op(d, state, 0), 1), 2)
+
+
+
+ This macro has been superceded by BOOST_PP_LIST_FOLD_LEFT_d and is deprecated.
+ It only allows a single reentry into BOOST_PP_LIST_FOLD_LEFT.
+
+ The BOOST_PP_LIST_FOLD_RIGHT macro folds (or accumulates) the elements of a list right-to-left.
+
+
Usage
+
+ BOOST_PP_LIST_FOLD_RIGHT(op, state, list)
+
+
Arguments
+
+
op
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_RIGHT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ This macro does not have the same signature as it previously did.
+ The arguments have been swapped to provide a uniform interface with BOOST_PP_LIST_FOLD_LEFT.
+
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ op(d, op(d, op(d, state, 2), 1), 0)
+
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_FOLD_RIGHT_d in such a situation.
+
+ The BOOST_PP_LIST_FOLD_RIGHT_2ND macro folds (or accumulates) the elements of a list right-to-left.
+
+
Usage
+
+ BOOST_PP_LIST_FOLD_RIGHT_2ND(op, state, list)
+
+
Arguments
+
+
op
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_RIGHT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ This macro does not have the same signature as it previously did.
+ The arguments have been swapped to provide a uniform interface with BOOST_PP_LIST_FOLD_LEFT.
+
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ op(d, op(d, op(d, state, 0), 1), 2)
+
+
+
+ This macro is deprecated.
+ Use BOOST_PP_LIST_FOLD_RIGHT_d instead.
+
+ The BOOST_PP_LIST_FOLD_RIGHT_2ND_D macro folds (or accumulates) the elements of a list right-to-left.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_RIGHT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ op(d, op(d, op(d, state, 0), 1), 2)
+
+
+
+ This macro has been superceded by BOOST_PP_LIST_FOLD_RIGHT_d and is deprecated.
+ It only allows a single reentry into BOOST_PP_LIST_FOLD_RIGHT.
+
+ The BOOST_PP_LIST_FOLD_RIGHT_d macro folds (or accumulates) the elements of a list right-to-left.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_RIGHT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ The BOOST_PP_LIST_FOLD_RIGHT_D macro folds (or accumulates) the elements of a list right-to-left.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+ A ternary operation of the form op(d, state, elem).
+ This macro is called for each element in list--each time returning a new state.
+ This operation is expanded by BOOST_PP_LIST_FOLD_RIGHT with the next available BOOST_PP_WHILE iteration,
+ the current state, and the current element.
+
+
state
+
+ The initial state of the fold.
+
+
list
+
+ The list to be folded.
+
+
+
Remarks
+
+ This macro does not have the same signature as it previously did.
+ The arguments have been swapped to provide a uniform interface with BOOST_PP_LIST_FOLD_LEFT.
+
+
+ For the list, (0, (1, (2, BOOST_PP_NIL))), this macro expands to:
+
+ op(d, op(d, op(d, state, 2), 1), 0)
+
+
+
+ This macro has been superceded by BOOST_PP_LIST_FOLD_RIGHT_d and is deprecated.
+ It only allows a single reentry into BOOST_PP_LIST_FOLD_RIGHT.
+
+ The BOOST_PP_LIST_FOR_EACH macro repeats a macro for each element in a list.
+
+
Usage
+
+ BOOST_PP_LIST_FOR_EACH(macro, data, list)
+
+
Arguments
+
+
macro
+
+ A ternary macro of the form macro(r, data, elem).
+ This macro is expanded by BOOST_PP_LIST_FOR_EACH with each element in list.
+ It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, and the current element.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
list
+
+ The list for which macro will be invoked on each element.
+
+
+
Remarks
+
+ This macro is a repetition construct.
+ If list is (a, (b, (c, BOOST_PP_NIL))), it expands to the sequence:
+
+ macro(r, data, a) macro(r, data, b) macro(r, data, c)
+
+
+
+ Previously, this macro could not be used inside BOOST_PP_FOR.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_FOR_EACH_R in such a situation.
+
+ The BOOST_PP_LIST_FOR_EACH_I macro repeats a macro for each element in a list.
+
+
Usage
+
+ BOOST_PP_LIST_FOR_EACH_I(macro, data, list)
+
+
Arguments
+
+
macro
+
+ A macro of the form macro(r, data, i, elem).
+ This macro is expanded by BOOST_PP_LIST_FOR_EACH with each element in list.
+ It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, the index of the current element, and the current element.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
list
+
+ The list for which macro will be invoked on each element.
+
+
+
Remarks
+
+ This macro is a repetition construct.
+ If list is (a, (b, (c, BOOST_PP_NIL))), it expands to the sequence:
+
+ macro(r, data, 0, a) macro(r, data, 1, b) macro(r, data, 2, c)
+
+
+
+ Previously, this macro could not be used inside BOOST_PP_FOR.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_FOR_EACH_I_R in such a situation.
+
+ A macro of the for macro(r, data, i, elem).
+ This macro is expanded by BOOST_PP_LIST_FOR_EACH_I with each element in list.
+ It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, the index of the current element, and the current element.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
list
+
+ The list for which macro will be invoked on each element.
+
+
+
Remarks
+
+ This macro is a repetition construct.
+ If list is (a, (b, (c, BOOST_PP_NIL))), it expands to the sequence:
+
+ macro(r, data, 0, a) macro(r, data, 1, b) macro(r, data, 2, c)
+
+ The binary macro of the form macro(r, product).
+ This macro is expanded by BOOST_PP_FOR_EACH_PRODUCT with each cartesian product in tuple.
+ It is expanded with the next available BOOST_PP_FOR repetition and a tuple containing a cartesian product.
+ This tuple will have size elements.
+
+
size
+
+ The size of tuple.
+
+
tuple
+
+ A tuple of lists from which cartesian products are obtained.
+
+
+
Remarks
+
+ This macro is a repetition construct.
+ If two lists are (a, (b, (c, BOOST_PP_NIL))) and (x, (y, (z, BOOST_PP_NIL))),
+ this macro will produce the following sequence:
+
+ Previously, this macro could not be used inside BOOST_PP_FOR.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_FOR_EACH_PRODUCT_R in such a situation.
+
+ The BOOST_PP_LIST_FOR_EACH_PRODUCT_R macro repeats a macro for each cartesian product of several lists.
+ It reenters BOOST_PP_FOR with maximum efficiency.
+
+ The binary macro of the form macro(r, product).
+ This macro is expanded by BOOST_PP_FOR_EACH_PRODUCT with each cartesian product in tuple.
+ It is expanded with the next available BOOST_PP_FOR repetition and a tuple containing a cartesian product.
+ This tuple will have size elements.
+
+
size
+
+ The size of tuple.
+
+
tuple
+
+ A tuple of lists from which cartesian products are obtained.
+
+
+
Remarks
+
+ This macro is a repetition construct.
+ If two lists are (a, (b, (c, BOOST_PP_NIL))) and (x, (y, (z, BOOST_PP_NIL))),
+ this macro will produce the following sequence:
+
+ A ternary macro of the form macro(r, data, elem).
+ This macro is expanded by BOOST_PP_LIST_FOR_EACH with each element in list.
+ It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, and the current element.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
list
+
+ The list for which macro will be invoked on each element.
+
+
+
Remarks
+
+ This macro is a repetition construct.
+ If list is (a, (b, (c, BOOST_PP_NIL))), it expands to the sequence:
+
+ macro(r, data, a) macro(r, data, b) macro(r, data, c)
+
+ The BOOST_PP_LIST_REST_N macro expands to a list of all but the first count elements of a list.
+
+
Usage
+
+ BOOST_PP_LIST_REST_N(count, list)
+
+
Arguments
+
+
count
+
+ The number of elements to remove from the beginning of list.
+
+
list
+
+ The list from which the elements are extracted.
+
+
+
Remarks
+
+ This macro removes count elements from the beginning of list and returns the remainder as a list
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_REST_N_D in such a situation.
+
+ The BOOST_PP_LIST_REST_N_D macro expands to a list of all but the first count elements of a list.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+
Usage
+
+ BOOST_PP_LIST_REST_N_D(d, count, list)
+
+
Arguments
+
+
d
+
+ The next available BOOST_PP_WHILE iteration.
+
+
count
+
+ The number of elements to remove from the beginning of list.
+
+
list
+
+ The list from which the elements are extracted.
+
+
+
Remarks
+
+ This macro removes count elements from the beginning of list and returns the remainder as a list
+
+ The BOOST_PP_LIST_REVERSE macro expands to the reverse a list.
+
+
Usage
+
+ BOOST_PP_LIST_REVERSE(list)
+
+
Arguments
+
+
list
+
+ A list to be reversed.
+
+
+
Remarks
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_REVERSE_D in such a situation.
+
+ The BOOST_PP_LIST_SIZE macro expands to the size of a list.
+
+
Usage
+
+ BOOST_PP_LIST_SIZE(list)
+
+
Arguments
+
+
list
+
+ A list whose size is to be calculated.
+
+
+
Remarks
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_SIZE_D in such a situation.
+
+ The BOOST_PP_LIST_TRANSFORM macro transforms each element in a list according to a supplied transformation.
+
+
Usage
+
+ BOOST_PP_LIST_TRANSFORM(op, data, list)
+
+
Arguments
+
+
op
+
+ A ternary predicate of the form op(d, data, elem).
+ This transformation is expanded by BOOST_PP_LIST_TRANSFORM for each element in list with the next available BOOST_PP_WHILE iteration,
+ the auxiliary data, and the current element in list.
+
+
data
+
+ Auxiliary data passed to pred.
+
+
list
+
+ The list to be transformed.
+
+
+
Remarks
+
+ This macro expands op for each element in list.
+ It builds a new list out of the results of each call.
+ If, for example, list is (a, (b, (c, BOOST_PP_NIL))),
+ this macro expands to...
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_TRANSFORM_D in such a situation.
+
+ The BOOST_PP_LIST_TRANSFORM_D macro transforms each element in a list according to a supplied transformation.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+
Usage
+
+ BOOST_PP_LIST_TRANSFORM_D(d, op, data, list)
+
+
Arguments
+
+
d
+
+ The next available BOOST_PP_WHILE iteration.
+
+
op
+
+ A ternary predicate of the form op(d, data, elem).
+ This transformation is expanded by BOOST_PP_LIST_TRANSFORM for each element in list with the next available BOOST_PP_WHILE iteration,
+ the auxiliary data, and the current element in list.
+
+
data
+
+ Auxiliary data passed to pred.
+
+
list
+
+ The list to be transformed.
+
+
+
Remarks
+
+ This macro expands op for each element in list.
+ It builds a new list out of the results of each call.
+ If, for example, list is (a, (b, (c, BOOST_PP_NIL))),
+ this macro expands to...
+
+ The BOOST_PP_LOCAL_ITERATE macro initiates a local-iteration.
+
+
Usage
+
+ #include BOOST_PP_LOCAL_ITERATE()
+
+
Remarks
+
+ This macro causes the user-defined macro BOOST_PP_LOCAL_MACRO to be expanded vertically with values in the range specified by BOOST_PP_LOCAL_LIMITS.
+
+ The BOOST_PP_LOCAL_LIMITS macro is a user-defined named external argument used by BOOST_PP_LOCAL_ITERATE.
+
+
Usage
+
+ #define BOOST_PP_LOCAL_LIMITS (start, finish)
+
+
Arguments
+
+
start
+
+ The lower bound (inclusive) of a local iteration.
+ Valid values range from 0 to BOOST_PP_LIMIT_ITERATION.
+
+
finish
+
+ The upper bound (inclusive) of a local iteration.
+ Valid values range from 0 to BOOST_PP_LIMIT_ITERATION.
+
+
+
Remarks
+
+ Note that there is a whitespace character after the macro identifier.
+
+
+ This macro must expand to a 2-element tuple.
+ The elements of this tuple represent the lower and upper boundaries of a local iteration.
+ Both start and finish are evaluated parameters.
+ This implies that they can include simple arithmetic expressions (such as 1 + 3), etc..
+
+
+ This macro is automatically undefined for reuse by a call to BOOST_PP_LOCAL_ITERATE.
+
+#include <boost/preprocessor/punctuation/paren.hpp>
+
+#define X(x) x
+#define MACRO(p, x) X p x )
+
+MACRO(BOOST_PP_LPAREN(), abc) // expands to abc
+
+#define Y(x)
+
+MACRO((10) Y BOOST_PP_LPAREN(), result) // expands to 10
+
+ The BOOST_PP_MAX macro expands to the greater of its two arguments.
+
+
Usage
+
+ BOOST_PP_MAX(x, y)
+
+
Arguments
+
+
x
+
+ The first operand.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The second operand.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ This macro returns the greater of its two arguments or the value of both arguments if they are equal.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_MAX_D in such a situation.
+
+ The BOOST_PP_MIN macro expands to the lesser of its two arguments.
+
+
Usage
+
+ BOOST_PP_MIN(x, y)
+
+
Arguments
+
+
x
+
+ The first operand.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The second operand.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ This macro returns the lesser of its two arguments or the value of both arguments if they are equal.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_MIN_D in such a situation.
+
+ The BOOST_PP_MOD macro expands to the modulus of its arguments.
+
+
Usage
+
+ BOOST_PP_MOD(x, y)
+
+
Arguments
+
+
x
+
+ The dividend (numerator) of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The divisor (denominator) of the operation.
+ Valid values range from 1 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_MOD_D in such a situation.
+
+ The BOOST_PP_MUL macro expands to the product of its arguments.
+
+
Usage
+
+ BOOST_PP_MUL(x, y)
+
+
Arguments
+
+
x
+
+ The multiplicand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The multiplier of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If the product of x and y is greater than BOOST_PP_LIMIT_MAG, the result is saturated to BOOST_PP_LIMIT_MAG.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_MUL_D in such a situation.
+
+
+ This macro is the most efficient when x is less than or equal to y.
+ However, the efficiency gain is not worth actually comparing the two arguments prior to invocation.
+ In other words, x should be the value that is most likely to be the largest of the two operands.
+
+ The BOOST_PP_MUL_D macro expands to the product of its second and third arguments.
+ It reenters BOOST_PP_WHILE with maximum efficiency.
+
+
Usage
+
+ BOOST_PP_MUL_D(d, x, y)
+
+
Arguments
+
+
d
+
+ The next available BOOST_PP_WHILE iteration.
+
+
x
+
+ The multiplicand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The multiplier of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If the product of x and y is greater than BOOST_PP_LIMIT_MAG, the result is saturated to BOOST_PP_LIMIT_MAG.
+
+
+ This macro is the most efficient when x is less than or equal to y.
+ However, the efficiency gain is not worth actually comparing the two arguments prior to invocation.
+ In other words, x should be the value that is most likely to be the largest of the two operands.
+
+ The BOOST_PP_NOR macro expands to the logical NOR of its operands.
+
+
Usage
+
+ BOOST_PP_NOR(p, q)
+
+
Arguments
+
+
p
+
+ The left operand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
q
+
+ The right operand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If both p and q are both 0, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro performs a boolean conversion on each operand before performing the logical NOR operation.
+ If that conversion is not necessary, use BOOST_PP_BITNOR instead.
+
+ The BOOST_PP_NOT macro performs a logical NOT on its operand.
+
+
Usage
+
+ BOOST_PP_NOT(x)
+
+
Arguments
+
+
x
+
+ The value to be converted.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If x is non-zero, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro performs a boolean conversion on its operand before performing the logical NOT operation.
+ If that conversion is not necessary, use BOOST_PP_COMPL instead.
+
+ The BOOST_PP_NOT_EQUAL macro compares two values for inequality.
+
+
Usage
+
+ BOOST_PP_NOT_EQUAL(x, y)
+
+
Arguments
+
+
x
+
+ The left operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The right operand of the comparison.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If x is equal to y, this macro expands to 0.
+ Otherwise, it expands to 1.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction because this macro no longer uses BOOST_PP_WHILE.
+
+ The BOOST_PP_OR macro expands to the logical OR of its operands.
+
+
Usage
+
+ BOOST_PP_OR(p, q)
+
+
Arguments
+
+
p
+
+ The left operand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
q
+
+ The right operand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If either p or q is non-zero, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro performs a boolean conversion on each operand before performing the logical OR operation.
+ If that conversion is not necessary, use BOOST_PP_BITOR instead.
+
+ The BOOST_PP_RELATIVE_ITERATION macro expands to the iteration value of a file-iteration depth relative to the current depth.
+
+
Usage
+
+ BOOST_PP_RELATIVE_ITERATION(i)
+
+
Arguments
+
+
i
+
+ The relative depth of the frame whose iteration value is to be retreived.
+ Valid values range from 0 to BOOST_PP_ITERATION_DEPTH() - 1.
+
+
+
Remarks
+
+ This macro is only valid when a file-iteration is in progress.
+
+
+ The argument i is interpreted as the number of frames outward from the current frame.
+ Therefore, BOOST_PP_RELATIVE_ITERATION(0) is equivalent to BOOST_PP_ITERATION().
+
+ The BOOST_PP_REPEAT macro represents a fast horizontal repetition construct.
+
+
Usage
+
+ BOOST_PP_REPEAT(count, macro, data)
+
+
Arguments
+
+
count
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_REPEAT_z.
+
+
+ Previously, this macro could not be used recursively inside BOOST_PP_REPEAT.
+ This limitation no longer exists, as the library can automatically detect the next available repetition depth.
+
+ The BOOST_PP_REPEAT_1ST macro represents the first dimension of BOOST_PP_REPEAT.
+
+
Usage
+
+ BOOST_PP_REPEAT_1ST(count, macro, data)
+
+
Arguments
+
+
count
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT_1ST with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_REPEAT_z.
+
+
+ This macro is deprecated.
+ It only exists for backward compatibility.
+ Use BOOST_PP_REPEAT instead.
+
+ The BOOST_PP_REPEAT_2ND macro represents the second dimension of BOOST_PP_REPEAT.
+
+
Usage
+
+ BOOST_PP_REPEAT_2ND(count, macro, data)
+
+
Arguments
+
+
count
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT_2ND with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_REPEAT_z.
+
+
+ This macro is deprecated.
+ It only exists for backward compatibility.
+ Use BOOST_PP_REPEAT instead.
+
+ The BOOST_PP_REPEAT_3RD macro represents the third dimension of BOOST_PP_REPEAT.
+
+
Usage
+
+ BOOST_PP_REPEAT_3RD(count, macro, data)
+
+
Arguments
+
+
count
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT_3RD with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_REPEAT_z.
+
+
+ This macro is deprecated.
+ It only exists for backward compatibility.
+ Use BOOST_PP_REPEAT instead.
+
+ The BOOST_PP_REPEAT_FROM_TO macro represents a fast horizontal repetition construct.
+
+
Usage
+
+ BOOST_PP_REPEAT_FROM_TO(first, last, macro, data)
+
+
Arguments
+
+
first
+
+ The lower bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
last
+
+ The upper bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
+
Remarks
+
+ This macro expands to the sequence:
+
+ macro(z, first, data) macro(z, first + 1, data) ... macro(z, last - 1, data)
+
+
+
+ The number of repetitions (i.e. last - first) must not exceed BOOST_PP_LIMIT_REPEAT.
+
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_REPEAT_FROM_TO_z.
+
+
+ Previously, this macro could not be used recursively inside BOOST_PP_REPEAT.
+ This limitation no longer exists, as the library can automatically detect the next available repetition depth.
+
+ The BOOST_PP_REPEAT_FROM_TO_1ST macro represents the first dimension of BOOST_PP_REPEAT_FROM_TO.
+
+
Usage
+
+ BOOST_PP_REPEAT_FROM_TO_1ST(first, last, macro, data)
+
+
Arguments
+
+
first
+
+ The lower bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
last
+
+ The upper bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT_FROM_TO_1ST with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
+
Remarks
+
+ This macro expands to the sequence:
+
+ macro(z, first, data) macro(z, first + 1, data) ... macro(z, last - 1, data)
+
+
+
+ The number of repetitions (i.e. last - first) must not exceed BOOST_PP_LIMIT_REPEAT.
+
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_REPEAT_FROM_TO_z.
+
+
+ This macro is deprecated.
+ It only exists for backward compatibility.
+ Use BOOST_PP_REPEAT_FROM_TO instead.
+
+ The BOOST_PP_REPEAT_FROM_TO_2ND macro represents the second dimension of BOOST_PP_REPEAT_FROM_TO.
+
+
Usage
+
+ BOOST_PP_REPEAT_FROM_TO_2ND(first, last, macro, data)
+
+
Arguments
+
+
first
+
+ The lower bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
last
+
+ The upper bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT_FROM_TO_2ND with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
+
Remarks
+
+ This macro expands to the sequence:
+
+ macro(z, first, data) macro(z, first + 1, data) ... macro(z, last - 1, data)
+
+
+
+ The number of repetitions (i.e. last - first) must not exceed BOOST_PP_LIMIT_REPEAT.
+
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_REPEAT_FROM_TO_z.
+
+
+ This macro is deprecated.
+ It only exists for backward compatibility.
+ Use BOOST_PP_REPEAT_FROM_TO instead.
+
+ The BOOST_PP_REPEAT_FROM_TO_3RD macro represents the third dimension of BOOST_PP_REPEAT_FROM_TO.
+
+
Usage
+
+ BOOST_PP_REPEAT_FROM_TO_3RD(first, last, macro, data)
+
+
Arguments
+
+
first
+
+ The lower bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
last
+
+ The upper bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT_FROM_TO_3RD with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
+
Remarks
+
+ This macro expands to the sequence:
+
+ macro(z, first, data) macro(z, first + 1, data) ... macro(z, last - 1, data)
+
+
+
+ The number of repetitions (i.e. last - first) must not exceed BOOST_PP_LIMIT_REPEAT.
+
+
+ The z value that is passed to macro represents the next available repetition dimension.
+ Other macros that have _Z suffix variants internally use BOOST_PP_REPEAT--for example, BOOST_PP_ENUM_PARAMS and BOOST_PP_ENUM_PARAMS_Z.
+ Using these _Z versions is not strictly necessary, but passing the z value (that is passed to macro) to these macros allows them to reenter BOOST_PP_REPEAT with maximum efficiency.
+
+
+ To directly use this z value, rather than simply passing it to another macro, see BOOST_PP_REPEAT_FROM_TO_z.
+
+
+ This macro is deprecated.
+ It only exists for backward compatibility.
+ Use BOOST_PP_REPEAT_FROM_TO instead.
+
+ The BOOST_PP_REPEAT_FROM_TO_z macro represents a reentry into the BOOST_PP_REPEAT_FROM_TO repetition construct.
+
+
Usage
+
+ BOOST_PP_REPEAT_FROM_TO_ ## z(first, last, macro, data)
+
+
Arguments
+
+
z
+
+ The next available BOOST_PP_REPEAT dimension.
+
+
first
+
+ The lower bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
last
+
+ The upper bound of the repetition.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+
data
+
+ Auxiliary data passed to macro.
+
+
+
Remarks
+
+ This macro expands to the sequence:
+
+ macro(z, first, data) macro(z, first + 1, data) ... macro(z, last - 1, data)
+
+
+
+ The number of repetitions (i.e. last - first) must not exceed BOOST_PP_LIMIT_REPEAT.
+
+
+ At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator.
+ This happens when the z value is a macro invocation itself.
+ It needs a delay to allow it to expand.
+ The syntax in such a scenario becomes:
+
+ The BOOST_PP_REPEAT_z macro represents a reentry into the BOOST_PP_REPEAT repetition construct.
+
+
Usage
+
+ BOOST_PP_REPEAT_ ## z(count, macro, data)
+
+
Arguments
+
+
z
+
+ The next available BOOST_PP_REPEAT dimension.
+
+
count
+
+ The number of repetitious calls to macro.
+ Valid values range from 0 to BOOST_PP_LIMIT_REPEAT.
+
+
macro
+
+ A ternary operation of the form macro(z, n, data).
+ This macro is expanded by BOOST_PP_REPEAT with the next available repetition depth,
+ the current repetition number, and the auxiliary data argument.
+
+ At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator.
+ This happens when the z value is a macro invocation itself.
+ It needs a delay to allow it to expand.
+ The syntax in such a scenario becomes:
+
+ The BOOST_PP_SUB macro expands to the difference between its arguments.
+
+
Usage
+
+ BOOST_PP_SUB(x, y)
+
+
Arguments
+
+
x
+
+ The minuend of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
y
+
+ The subtrahend of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If the difference between x and y is less than 0, the result is saturated to 0.
+
+
+ Previously, this macro could not be used inside BOOST_PP_WHILE.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_SUB_D in such a situation.
+
+ The BOOST_PP_LIST_TO_TUPLE macro converts a list to a tuple.
+
+
Usage
+
+ BOOST_PP_LIST_TO_TUPLE(list)
+
+
Arguments
+
+
list
+
+ The list to be converted.
+
+
+
Remarks
+
+ If list is, for example, (a, (b, (c, BOOST_PP_NIL))),
+ this macro will produce:
+
+ (a, b, c)
+
+
+
+ Previously, this macro could not be used inside BOOST_PP_FOR.
+ There is no longer any such restriction.
+ It is more efficient, however, to use BOOST_PP_LIST_TO_TUPLE_R in such a situation.
+
+ The BOOST_PP_WHILE macro represents a looping construct.
+
+
Usage
+
+ BOOST_PP_WHILE(pred, op, state)
+
+
Arguments
+
+
pred
+
+ A binary predicate of the form pred(d, state).
+ This predicate is expanded by BOOST_PP_WHILE with the next available
+ iteration d and the current state.
+ This predicate must expand to value in the range of 0 to BOOST_PP_LIMIT_MAG.
+ The construct continues to loop until this predicate returns 0.
+ When this predicate returns 0, BOOST_PP_WHILE returns the current state.
+
+
op
+
+ A binary operation of the form op(d, state).
+ This operation is expanded by BOOST_PP_WHILE with the next available
+ iteration d and the current state.
+ This macro is repeatedly applied to the state, each time producing a new state, until pred returns 0.
+
+
state
+
+ The initial state.
+ Often this argument is a tuple.
+
+
+
Remarks
+
+ This macro iterates op(d, state) while pred(d, state) is non-zero.
+ In other words expands to:
+
+ op(d, ... op(d, op(d, state)) ... ).
+
+
+
+ The d value that is passed to both pred and op represents the next available iteration.
+ Other macros that have _D suffix variants internally use BOOST_PP_WHILE--for example, BOOST_PP_ADD and BOOST_PP_ADD_D.
+ Using these _D versions is not strictly necessary, but passing the d value (that passed to pred or op) to these macros allows them to reenter BOOST_PP_WHILE with maximum efficiency.
+
+
+ To directly use this d value, rather than simply passing it to another macro, see BOOST_PP_WHILE_d.
+
+
+ Previously, this macro could not be used recursively inside BOOST_PP_WHILE.
+ This limitation no longer exists, as the library can automatically detect the next available iteration.
+
+ The BOOST_PP_WHILE_d macro represents a reentry into the BOOST_PP_WHILE looping construct.
+
+
Usage
+
+ BOOST_PP_WHILE_ ## d(pred, op, state)
+
+
Arguments
+
+
d
+
+ The next available BOOST_PP_WHILE iteration.
+
+
pred
+
+ A binary predicate of the form pred(d, state).
+ This predicate is expanded by BOOST_PP_WHILE with the next available
+ iteration d and the current state.
+ This predicate must expand to value in the range of 0 to BOOST_PP_LIMIT_MAG.
+ The construct continues to loop until this predicate returns 0.
+ When this predicate returns 0, BOOST_PP_WHILE returns the current state.
+
+
op
+
+ A binary operation of the form op(d, state).
+ This operation is expanded by BOOST_PP_WHILE with the next available
+ iteration d and the current state.
+ This macro is repeatedly applied to the state, each time producing a new state, until pred returns 0.
+
+
state
+
+ The initial state.
+ Often this argument is a tuple.
+
+
+
Remarks
+
+ This macro iterates op(d, state) while pred(d, state) is non-zero.
+ In other words expands to:
+
+ op(d, ... op(d, op(d, state)) ... ).
+
+
+
+ At certain times, it may be necessary to perform the concatenation with BOOST_PP_CAT rather than the preprocessor token-pasting operator.
+ This happens when the d value is a macro invocation itself.
+ It needs a delay to allow it to expand.
+ The syntax in such a scenario becomes:
+
+ The BOOST_PP_XOR macro expands to the logical XOR of its operands.
+
+
Usage
+
+ BOOST_PP_XOR(p, q)
+
+
Arguments
+
+
p
+
+ The left operand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
q
+
+ The right operand of the operation.
+ Valid values range from 0 to BOOST_PP_LIMIT_MAG.
+
+
+
Remarks
+
+ If either p or q is non-zero exclusively, this macro expands to 1.
+ Otherwise, it expands to 0.
+
+
+ This macro performs a boolean conversion on each operand before performing the logical XOR operation.
+ If that conversion is not necessary, use BOOST_PP_BITXOR instead.
+