- 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_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_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_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.
-