# Boost-Commit :

From: eldiener_at_[hidden]
Date: 2011-08-11 14:51:30

Author: eldiener
Date: 2011-08-11 14:51:26 EDT (Thu, 11 Aug 2011)
New Revision: 73674
URL: http://svn.boost.org/trac/boost/changeset/73674

Log:
Updated docs and implementation.
Removed:
Text files modified:
40 files changed, 807 insertions(+), 207 deletions(-)

==============================================================================
@@ -11,7 +11,7 @@
#include <boost/preprocessor/logical/bitor.hpp>
#include <boost/preprocessor/logical/not.hpp>

#if BOOST_VMD_MSVC

@@ -62,7 +62,7 @@
#define VMD_DETAIL_ASSERT_IS_LIST_PRED(d,state) \
BOOST_PP_IIF \
( \
- BOOST_VMD_IS_TUPLE_BEGIN(state), \
+ BOOST_VMD_IS_BEGIN_PARENS(state), \
VMD_DETAIL_ASSERT_IS_LIST_GEN_ONE, \
VMD_DETAIL_ASSERT_IS_LIST_NOT_BOOST_PP_NIL \
) \
@@ -72,7 +72,7 @@
#define VMD_DETAIL_ASSERT_IS_LIST_OP(d,state) \
BOOST_PP_IIF \
( \
- BOOST_VMD_IS_TUPLE_BEGIN(state), \
+ BOOST_VMD_IS_BEGIN_PARENS(state), \
VMD_DETAIL_ASSERT_IS_LIST_PROCESS_TUPLE, \
VMD_DETAIL_ASSERT_IS_LIST_PROCESS_IF_BOOST_PP_NIL \
) \

==============================================================================
@@ -11,7 +11,7 @@
#include <boost/preprocessor/facilities/expand.hpp>
#include <boost/preprocessor/logical/not.hpp>

#if BOOST_VMD_MSVC

@@ -22,7 +22,7 @@
#define VMD_DETAIL_ASSERT_IS_SEQ_PRED(d,state) \
BOOST_PP_IIF \
( \
- BOOST_VMD_IS_TUPLE_BEGIN(state), \
+ BOOST_VMD_IS_BEGIN_PARENS(state), \
VMD_DETAIL_ASSERT_IS_SEQ_GEN_ONE, \
VMD_DETAIL_ASSERT_IS_SEQ_PRED_CHECK_SUCCESS \
) \
@@ -49,7 +49,7 @@
#define VMD_DETAIL_ASSERT_IS_SEQ_OP(d,state) \
BOOST_PP_IIF \
( \
- BOOST_VMD_IS_TUPLE_BEGIN(state), \
+ BOOST_VMD_IS_BEGIN_PARENS(state), \
VMD_DETAIL_ASSERT_IS_SEQ_CHECK_FIRST_TUPLE_SIZE, \
VMD_DETAIL_ASSERT_IS_SEQ_GEN_RETURN_ASSERT \
) \
@@ -103,7 +103,7 @@
) \
/**/
#define VMD_DETAIL_ASSERT_IS_SEQ_IS_AFTER_FIRST_TUPLE(x) \
- BOOST_VMD_IS_TUPLE_BEGIN \
+ BOOST_VMD_IS_BEGIN_PARENS \
( \
VMD_DETAIL_ASSERT_IS_SEQ_EMPTY x \
) \
@@ -149,7 +149,7 @@
) \
/**/
#define VMD_DETAIL_ASSERT_IS_SEQ_IS_AFTER_FIRST_TUPLE(x) \
- BOOST_VMD_IS_TUPLE_BEGIN \
+ BOOST_VMD_IS_BEGIN_PARENS \
( \
VMD_DETAIL_ASSERT_IS_SEQ_APPLY(VMD_DETAIL_ASSERT_IS_SEQ_EMPTY,x) \
) \

==============================================================================
@@ -5,7 +5,7 @@

#endif /* VMD_DETAIL_IS_TUPLE_BEGIN_HPP */

==============================================================================
+++ (empty file)
@@ -1,11 +0,0 @@
-#if !defined(VMD_DETAIL_IS_TUPLE_BEGIN_HPP)
-#define VMD_DETAIL_IS_TUPLE_BEGIN_HPP
-
-
-
-
-#endif /* VMD_DETAIL_IS_TUPLE_BEGIN_HPP */

==============================================================================
+++ (empty file)
@@ -1,11 +0,0 @@
-#if !defined(VMD_DETAIL_IS_TUPLE_BEGIN_COMMON_HPP)
-#define VMD_DETAIL_IS_TUPLE_BEGIN_COMMON_HPP
-
-
-
-#define VMD_DETAIL_IS_TUPLE_BEGIN_COMMON_EXPAND(...) 1,1
-
-#endif /* BOOST_VMD_VARIADICS && BOOST_VMD_MSVC */
-#endif /* VMD_DETAIL_IS_TUPLE_BEGIN_COMMON_HPP */

==============================================================================
@@ -6,7 +6,7 @@

#include <boost/preprocessor/facilities/identity.hpp>

#define VMD_DETAIL_REMOVE_PARENS(x) \
BOOST_PP_IDENTITY(VMD_DETAIL_PP_TUPLE_TO_DATA(x)) \

==============================================================================
--- (empty file)
@@ -0,0 +1,13 @@
+#if !defined(VMD_DETAIL_TO_DATA_HPP)
+#define VMD_DETAIL_TO_DATA_HPP
+
+
+
+#if !BOOST_VMD_PPLIB
+#endif /* BOOST_VMD_PPLIB */
+
+#endif /* VMD_DETAIL_TO_DATA_HPP */

==============================================================================
--- (empty file)
@@ -0,0 +1,16 @@
+#if !defined(VMD_DETAIL_TO_DATA_NATIVE_HPP)
+#define VMD_DETAIL_TO_DATA_NATIVE_HPP
+
+
+
+#define VMD_DETAIL_REMOVE_TUPLE_PARENS(...) \
+ __VA_ARGS__ \
+/**/
+#define VMD_DETAIL_PP_TUPLE_TO_DATA(tuple) \
+ VMD_DETAIL_REMOVE_TUPLE_PARENS tuple \
+/**/
+
+#endif /* VMD_DETAIL_TO_DATA_NATIVE_HPP */

==============================================================================
@@ -9,6 +9,7 @@
#include <boost/preprocessor/tuple/reverse.hpp>
#include <boost/preprocessor/tuple/rem.hpp>

#if BOOST_VMD_MSVC

@@ -21,12 +22,6 @@

#endif

-#define VMD_DETAIL_REMOVE_TUPLE_PARENS(...) \
- __VA_ARGS__ \
-/**/
-#define VMD_DETAIL_PP_TUPLE_TO_DATA(tuple) \
- VMD_DETAIL_REMOVE_TUPLE_PARENS tuple \
-/**/
#define VMD_DETAIL_PP_TUPLE_ELEM(size,i,tuple) \
BOOST_PP_TUPLE_ELEM(size,i,tuple) \
/**/

==============================================================================
@@ -9,7 +9,7 @@

==============================================================================
@@ -14,20 +14,43 @@

+/** \brief Tests whether a parameter is empty or not.
+
+ The macro checks to see if the parameter is empty or not.
+ It returns 1 if the parameter is empty, else returns 0.
+
+ The macro works through variadic macro support.
+
+ The macro is not perfect, and can not be so. The problem
+ area is if the parameter to be checked is a function-like
+ macro name, in which case either a compiler error can result
+ or a false result can occur.
+
+ This macro is a replacement, using variadic macro support,
+ for the undocumented macro BOOST_PP_IS_EMPTY in the Boost
+ pplib. The code is taken from a posting by Paul Mensonides
+ of a variadic version for BOOST_PP_IS_EMPTY, and changed
+ in order to also support VC++.
+
+
+ returns = 1 if the param is empty, 0 if it is not
+
+*/
#define BOOST_VMD_IS_EMPTY(...) \
VMD_DETAIL_IS_EMPTY_IIF \
( \
- BOOST_VMD_IS_TUPLE_BEGIN \
+ BOOST_VMD_IS_BEGIN_PARENS \
( \
__VA_ARGS__ \
) \
) \
( \
0, \
- BOOST_VMD_IS_TUPLE_BEGIN \
+ BOOST_VMD_IS_BEGIN_PARENS \
( \
VMD_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ () \
) \

==============================================================================
@@ -18,6 +18,29 @@

+/** \brief Tests whether a parameter is empty or not.
+
+ The macro checks to see if the parameter is empty or not.
+ It returns 1 if the parameter is empty, else returns 0.
+
+ The macro works through variadic macro support.
+
+ The macro is not perfect, and can not be so. The problem
+ area is if the parameter to be checked is a function-like
+ macro name, in which case either a compiler error can result
+ or a false result can occur.
+
+ This macro is a replacement, using variadic macro support,
+ for the undocumented macro BOOST_PP_IS_EMPTY in the Boost
+ pplib. The code is taken from a posting by Paul Mensonides
+ of a variadic version for BOOST_PP_IS_EMPTY, and changed
+ in order to also support VC++.
+
+ param = a parameter
+
+ returns = 1 if the param is empty, 0 if it is not
+
+*/
#define BOOST_VMD_IS_EMPTY(param) \
VMD_DETAIL_IS_EMPTY_IIF \
( \

==============================================================================
@@ -25,9 +25,47 @@

-#define BOOST_VMD_ASSERT_IS_ARRAY(x) \
- BOOST_VMD_ASSERT_IS_TUPLE(x) \
- VMD_DETAIL_ASSERT_IS_ARRAY_VC_CHECK_RETURN_FAILURE VMD_DETAIL_ASSERT_IS_ARRAY_VC_IMP(x) \
+/** \brief Asserts that the parameter is a pplib array.
+
+ The macro checks that the parameter is a pplib array.
+ If it is not a pplib array, it forces a compiler error.
+
+ The macro works through variadic macro support.
+
+ The macro normally checks for a pplib array only in
+ debug mode. However an end-user can force the macro
+ to check or not check by defining the macro
+ BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.
+
+ array = a possible pplib array.
+
+ returns = Normally the macro returns nothing.
+
+ If the parameter is a pplib array, nothing is
+ output.
+
+ For VC++, because there is no sure way of forcing
+ a compiler error from within a macro without producing
+ output, if the parameter is not a pplib array the
+ macro forces a compiler error by outputting invalid C++.
+
+ For all other compilers a compiler error is forced
+ without producing output if the parameter is not a
+ pplib array.
+
+ There is no completely fool-proof way to check if a
+ parameter is empty without possible producing a compiler
+ error if it is not. Because a macro checking if a parameter
+ is a pplib array needs to perform such a check, the best
+ that one can do is to create a compiler error if a parameter
+ is not a pplib array rather than having a macro which
+ returns 1 or 0, depending on whether a parameter is a pplib
+ array.
+
+*/
+#define BOOST_VMD_ASSERT_IS_ARRAY(array) \
+ BOOST_VMD_ASSERT_IS_TUPLE(array) \
+ VMD_DETAIL_ASSERT_IS_ARRAY_VC_CHECK_RETURN_FAILURE VMD_DETAIL_ASSERT_IS_ARRAY_VC_IMP(array) \
/**/

#endif /* BOOST_VMD_MSVC */

==============================================================================
@@ -22,17 +22,55 @@

-#define BOOST_VMD_ASSERT_IS_ARRAY(x) \
- BOOST_VMD_ASSERT_IS_TUPLE(x) \
+/** \brief Asserts that the parameter is a pplib array.
+
+ The macro checks that the parameter is a pplib array.
+ If it is not a pplib array, it forces a compiler error.
+
+ The macro works through variadic macro support.
+
+ The macro normally checks for a pplib array only in
+ debug mode. However an end-user can force the macro
+ to check or not check by defining the macro
+ BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.
+
+ array = a possible pplib array.
+
+ returns = Normally the macro returns nothing.
+
+ If the parameter is a pplib array, nothing is
+ output.
+
+ For VC++, because there is no sure way of forcing
+ a compiler error from within a macro without producing
+ output, if the parameter is not a pplib array the
+ macro forces a compiler error by outputting invalid C++.
+
+ For all other compilers a compiler error is forced
+ without producing output if the parameter is not a
+ pplib array.
+
+ There is no completely fool-proof way to check if a
+ parameter is empty without possible producing a compiler
+ error if it is not. Because a macro checking if a parameter
+ is a pplib array needs to perform such a check, the best
+ that one can do is to create a compiler error if a parameter
+ is not a pplib array rather than having a macro which
+ returns 1 or 0, depending on whether a parameter is a pplib
+ array.
+
+*/
+#define BOOST_VMD_ASSERT_IS_ARRAY(array) \
+ BOOST_VMD_ASSERT_IS_TUPLE(array) \
BOOST_PP_ASSERT \
( \
BOOST_PP_IIF \
( \
- BOOST_PP_EQUAL(2,BOOST_VMD_PP_TUPLE_SIZE(x)), \
+ BOOST_PP_EQUAL(2,BOOST_VMD_PP_TUPLE_SIZE(array)), \
VMD_DETAIL_ASSERT_IS_ARRAY_CHECK_ARRAY_FORM, \
VMD_DETAIL_GEN_ZERO \
) \
- (x) \
+ (array) \
) \
/**/

==============================================================================
@@ -22,17 +22,55 @@

-#define BOOST_VMD_ASSERT_IS_ARRAY(x) \
- BOOST_VMD_ASSERT_IS_TUPLE(x) \
+/** \brief Asserts that the parameter is a pplib array.
+
+ The macro checks that the parameter is a pplib array.
+ If it is not a pplib array, it forces a compiler error.
+
+ The macro works through variadic macro support.
+
+ The macro normally checks for a pplib array only in
+ debug mode. However an end-user can force the macro
+ to check or not check by defining the macro
+ BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.
+
+ array = a possible pplib array.
+
+ returns = Normally the macro returns nothing.
+
+ If the parameter is a pplib array, nothing is
+ output.
+
+ For VC++, because there is no sure way of forcing
+ a compiler error from within a macro without producing
+ output, if the parameter is not a pplib array the
+ macro forces a compiler error by outputting invalid C++.
+
+ For all other compilers a compiler error is forced
+ without producing output if the parameter is not a
+ pplib array.
+
+ There is no completely fool-proof way to check if a
+ parameter is empty without possible producing a compiler
+ error if it is not. Because a macro checking if a parameter
+ is a pplib array needs to perform such a check, the best
+ that one can do is to create a compiler error if a parameter
+ is not a pplib array rather than having a macro which
+ returns 1 or 0, depending on whether a parameter is a pplib
+ array.
+
+*/
+#define BOOST_VMD_ASSERT_IS_ARRAY(array) \
+ BOOST_VMD_ASSERT_IS_TUPLE(array) \
BOOST_PP_ASSERT \
( \
BOOST_PP_IIF \
( \
- BOOST_PP_EQUAL(2,BOOST_PP_TUPLE_SIZE(x)), \
+ BOOST_PP_EQUAL(2,BOOST_PP_TUPLE_SIZE(array)), \
VMD_DETAIL_ASSERT_IS_ARRAY_CHECK_ARRAY_FORM, \
VMD_DETAIL_GEN_ZERO \
) \
- (x) \
+ (array) \
) \
/**/

==============================================================================
@@ -23,14 +23,52 @@
#include <boost/preprocessor/control/while.hpp>

-#define BOOST_VMD_ASSERT_IS_LIST(x) \
+/** \brief Asserts that the parameter is a pplib list.
+
+ The macro checks that the parameter is a pplib list.
+ If it is not a pplib list, it forces a compiler error.
+
+ The macro works through variadic macro support.
+
+ The macro normally checks for a pplib list only in
+ debug mode. However an end-user can force the macro
+ to check or not check by defining the macro
+ BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.
+
+ list = a possible pplib list.
+
+ returns = Normally the macro returns nothing.
+
+ If the parameter is a pplib list, nothing is
+ output.
+
+ For VC++, because there is no sure way of forcing
+ a compiler error from within a macro without producing
+ output, if the parameter is not a pplib list the
+ macro forces a compiler error by outputting invalid C++.
+
+ For all other compilers a compiler error is forced
+ without producing output if the parameter is not a
+ pplib list.
+
+ There is no completely fool-proof way to check if a
+ parameter is empty without possible producing a compiler
+ error if it is not. Because a macro checking if a parameter
+ is a pplib list needs to perform such a check, the best
+ that one can do is to create a compiler error if a parameter
+ is not a pplib list rather than having a macro which
+ returns 1 or 0, depending on whether a parameter is a pplib
+ list.
+
+*/
+#define BOOST_VMD_ASSERT_IS_LIST(list) \
VMD_DETAIL_ASSERT_IS_LIST_CHECK_RETURN_FAILURE \
( \
BOOST_PP_WHILE \
( \
VMD_DETAIL_ASSERT_IS_LIST_PRED, \
VMD_DETAIL_ASSERT_IS_LIST_OP, \
- x \
+ list \
) \
) \
/**/

==============================================================================
@@ -23,14 +23,52 @@
#include <boost/preprocessor/control/while.hpp>

-#define BOOST_VMD_ASSERT_IS_SEQ(x) \
+/** \brief Asserts that the parameter is a pplib seq.
+
+ The macro checks that the parameter is a pplib seq.
+ If it is not a pplib seq, it forces a compiler error.
+
+ The macro works through variadic macro support.
+
+ The macro normally checks for a pplib seq only in
+ debug mode. However an end-user can force the macro
+ to check or not check by defining the macro
+ BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.
+
+ seq = a possible pplib seq.
+
+ returns = Normally the macro returns nothing.
+
+ If the parameter is a pplib seq, nothing is
+ output.
+
+ For VC++, because there is no sure way of forcing
+ a compiler error from within a macro without producing
+ output, if the parameter is not a pplib seq the
+ macro forces a compiler error by outputting invalid C++.
+
+ For all other compilers a compiler error is forced
+ without producing output if the parameter is not a
+ pplib seq.
+
+ There is no completely fool-proof way to check if a
+ parameter is empty without possible producing a compiler
+ error if it is not. Because a macro checking if a parameter
+ is a pplib seq needs to perform such a check, the best
+ that one can do is to create a compiler error if a parameter
+ is not a pplib seq rather than having a macro which
+ returns 1 or 0, depending on whether a parameter is a pplib
+ seq.
+
+*/
+#define BOOST_VMD_ASSERT_IS_SEQ(seq) \
VMD_DETAIL_ASSERT_IS_SEQ_CHECK_RETURN_FAILURE \
( \
BOOST_PP_WHILE \
( \
VMD_DETAIL_ASSERT_IS_SEQ_PRED, \
VMD_DETAIL_ASSERT_IS_SEQ_OP, \
- x \
+ seq \
) \
) \
/**/

==============================================================================
@@ -29,19 +29,57 @@

#endif

#if BOOST_VMD_MSVC

#include <boost/preprocessor/facilities/empty.hpp>

+/** \brief Asserts that the parameter is a pplib tuple.
+
+ The macro checks that the parameter is a pplib tuple.
+ If it is not a pplib tuple, it forces a compiler error.
+
+ The macro works through variadic macro support.
+
+ The macro normally checks for a pplib tuple only in
+ debug mode. However an end-user can force the macro
+ to check or not check by defining the macro
+ BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.
+
+ tuple = a possible pplib tuple.
+
+ returns = Normally the macro returns nothing.
+
+ If the parameter is a pplib tuple, nothing is
+ output.
+
+ For VC++, because there is no sure way of forcing
+ a compiler error from within a macro without producing
+ output, if the parameter is not a pplib tuple the
+ macro forces a compiler error by outputting invalid C++.
+
+ For all other compilers a compiler error is forced
+ without producing output if the parameter is not a
+ pplib tuple.
+
+ There is no completely fool-proof way to check if a
+ parameter is empty without possible producing a compiler
+ error if it is not. Because a macro checking if a parameter
+ is a pplib tuple needs to perform such a check, the best
+ that one can do is to create a compiler error if a parameter
+ is not a pplib tuple rather than having a macro which
+ returns 1 or 0, depending on whether a parameter is a pplib
+ tuple.
+
+*/
#define BOOST_VMD_ASSERT_IS_TUPLE(x) \
VMD_DETAIL_ASSERT_IS_TUPLE_VC_CHECK_RETURN_FAILURE \
( \
BOOST_PP_IIF \
( \
- BOOST_VMD_IS_TUPLE_BEGIN(x), \
+ BOOST_VMD_IS_BEGIN_PARENS(x), \
VMD_DETAIL_ASSERT_IS_TUPLE_IS_NOT_AFTER, \
VMD_DETAIL_ASSERT_IS_TUPLE_GEN_ZERO \
) \
@@ -51,12 +89,50 @@

#else

+/** \brief Asserts that the parameter is a pplib tuple.
+
+ The macro checks that the parameter is a pplib tuple.
+ If it is not a pplib tuple, it forces a compiler error.
+
+ The macro works through variadic macro support.
+
+ The macro normally checks for a pplib tuple only in
+ debug mode. However an end-user can force the macro
+ to check or not check by defining the macro
+ BOOST_VMD_ASSERT_DATA to 1 or 0 respectively.
+
+ tuple = a possible pplib tuple.
+
+ returns = Normally the macro returns nothing.
+
+ If the parameter is a pplib tuple, nothing is
+ output.
+
+ For VC++, because there is no sure way of forcing
+ a compiler error from within a macro without producing
+ output, if the parameter is not a pplib tuple the
+ macro forces a compiler error by outputting invalid C++.
+
+ For all other compilers a compiler error is forced
+ without producing output if the parameter is not a
+ pplib tuple.
+
+ There is no completely fool-proof way to check if a
+ parameter is empty without possible producing a compiler
+ error if it is not. Because a macro checking if a parameter
+ is a pplib tuple needs to perform such a check, the best
+ that one can do is to create a compiler error if a parameter
+ is not a pplib tuple rather than having a macro which
+ returns 1 or 0, depending on whether a parameter is a pplib
+ tuple.
+
+*/
#define BOOST_VMD_ASSERT_IS_TUPLE(x) \
BOOST_PP_ASSERT \
( \
BOOST_PP_IIF \
( \
- BOOST_VMD_IS_TUPLE_BEGIN(x), \
+ BOOST_VMD_IS_BEGIN_PARENS(x), \
VMD_DETAIL_ASSERT_IS_TUPLE_IS_NOT_AFTER, \
VMD_DETAIL_GEN_ZERO \
) \

==============================================================================
@@ -16,8 +16,7 @@

-/// Expands to the number of comma-separated variadic macro data arguments.
-/**
+/** \brief Expands to the number of comma-separated variadic macro data arguments.

@@ -31,8 +30,7 @@
VMD_DETAIL_DATA_SIZE(__VA_ARGS__) \
/**/

-/// Expands to a particular variadic macro data argument.
-/**
+/** \brief Expands to a particular variadic macro data argument.

n = number of the variadic macro data argument.
The number starts from 0 to the number of
@@ -50,8 +48,7 @@
VMD_DETAIL_DATA_ELEM(n,__VA_ARGS__) \
/**/

-/// Expand to a Boost PP tuple data type.
-/**
+/** \brief Expand to a Boost PP tuple data type.

@@ -66,8 +63,7 @@
VMD_DETAIL_DATA_TO_PP_TUPLE(__VA_ARGS__) \
/**/

-/// Expand to a Boost PP array data type.
-/**
+/** \brief Expand to a Boost PP array data type.

@@ -82,8 +78,7 @@
VMD_DETAIL_DATA_TO_PP_ARRAY(__VA_ARGS__) \
/**/

-/// Expand to a Boost PP list data type.
-/**
+/** \brief Expand to a Boost PP list data type.

@@ -98,8 +93,7 @@
VMD_DETAIL_DATA_TO_PP_LIST(__VA_ARGS__) \
/**/

-/// Expand to a Boost PP sequence data type.
-/**
+/** \brief Expand to a Boost PP sequence data type.

==============================================================================
@@ -21,8 +21,7 @@

-/// Expands to the number of comma-separated variadic macro data arguments.
-/**
+/** \brief Expands to the number of comma-separated variadic macro data arguments.

@@ -36,8 +35,7 @@
/**/

-/// Expands to a particular variadic macro data argument.
-/**
+/** \brief Expands to a particular variadic macro data argument.

n = number of the variadic macro data argument.
The number starts from 0 to the number of
@@ -55,8 +53,7 @@
/**/

-/// Expand to a Boost PP tuple data type.
-/**
+/** \brief Expand to a Boost PP tuple data type.

@@ -71,8 +68,7 @@
/**/

-/// Expand to a Boost PP array data type.
-/**
+/** \brief Expand to a Boost PP array data type.

@@ -87,8 +83,7 @@
/**/

-/// Expand to a Boost PP list data type.
-/**
+/** \brief Expand to a Boost PP list data type.

@@ -103,8 +98,7 @@
/**/

-/// Expand to a Boost PP sequence data type.
-/**
+/** \brief Expand to a Boost PP sequence data type.

==============================================================================
@@ -6,12 +6,12 @@

#if BOOST_VMD_PPLIB
#else
#endif /* BOOST_VMD_PPLIB */

#endif /* VMD_IS_TUPLE_BEGIN_HPP */

==============================================================================
@@ -16,7 +16,33 @@

-# define BOOST_VMD_IS_TUPLE_BEGIN(...) \
+/** \brief Tests whether a parameter begins with a set of parentheses.
+
+ The macro checks to see if the parameter begins with a
+ set of parentheses surrounding any tokens.
+
+
+ returns = 1 if the param begins with a set of parentheses,
+ 0 if it does not.
+
+ The macro works through variadic macro support.
+
+ The code for the non-VC++ version of this is taken from a
+ posting by Paul Mensonides.
+
+ This macro is not a test for a parameter which is only
+ single set of parentheses surrounding any tokens ( a Boost
+ pplib tuple ) since the parameter may have other tokens
+ following the beginning set of parentheses and it will still
+ return 1.
+
+ There is no completely safe way to test whether the param is a tuple.
+ At best one can use BOOST_VMD_ASSERT_IS_TUPLE to cause a compiler error
+ if the parameter is not a tuple.
+
+*/
+#define BOOST_VMD_IS_BEGIN_PARENS(...) \
VMD_DETAIL_IS_EMPTY_SPLIT \
( \
0, \

==============================================================================
@@ -16,23 +16,35 @@

#include <boost/preprocessor/arithmetic/dec.hpp>

-/// Tests whether its parameter begins with a tuple.
-/**
+/** \brief Tests whether a parameter begins with a set of parentheses.

- param = a macro parameter.
+ The macro checks to see if the parameter begins with a
+ set of parentheses surrounding any tokens.
+

- returns = 1 if the param begins with a tuple, else 0 if it does not.
- If the param begins with a tuple, it may contain other
- tokens after it.
+ returns = 1 if the param begins with a set of parentheses,
+ 0 if it does not.

+ The macro works through variadic macro support.
+
+ The code for the non-VC++ version of this is taken from a
+ posting by Paul Mensonides.
+
+ This macro is not a test for a parameter which is only
+ single set of parentheses surrounding any tokens ( a Boost
+ pplib tuple ) since the parameter may have other tokens
+ following the beginning set of parentheses and it will still
+ return 1.
+
There is no completely safe way to test whether the param is a tuple.
At best one can use BOOST_VMD_ASSERT_IS_TUPLE to cause a compiler error
if the parameter is not a tuple.

*/
-#define BOOST_VMD_IS_TUPLE_BEGIN(param) \
+#define BOOST_VMD_IS_BEGIN_PARENS(param) \
BOOST_PP_DEC \
( \
BOOST_VMD_DATA_SIZE \

==============================================================================
@@ -16,24 +16,35 @@

#include <boost/preprocessor/arithmetic/dec.hpp>

-/// Tests whether its parameter begins with a tuple.
-/**
+/** \brief Tests whether a parameter begins with a set of parentheses.

- param = a macro parameter.
+ The macro checks to see if the parameter begins with a
+ set of parentheses surrounding any tokens.
+

- returns = 1 if the param begins with a tuple, else 0 if it does not.
- If the param begins with a tuple, it may contain other
- tokens after it.
+ returns = 1 if the param begins with a set of parentheses,
+ 0 if it does not.

+ The macro works through variadic macro support.
+
+ The code for the non-VC++ version of this is taken from a
+ posting by Paul Mensonides.
+
+ This macro is not a test for a parameter which is only
+ single set of parentheses surrounding any tokens ( a Boost
+ pplib tuple ) since the parameter may have other tokens
+ following the beginning set of parentheses and it will still
+ return 1.
+
There is no completely safe way to test whether the param is a tuple.
At best one can use BOOST_VMD_ASSERT_IS_TUPLE to cause a compiler error
if the parameter is not a tuple.
-

*/
-#define BOOST_VMD_IS_TUPLE_BEGIN(param) \
+#define BOOST_VMD_IS_BEGIN_PARENS(param) \
BOOST_PP_DEC \
( \

==============================================================================
@@ -18,6 +18,29 @@

+/** \brief Tests whether a parameter is empty or not.
+
+ The macro checks to see if the parameter is empty or not.
+ It returns 1 if the parameter is empty, else returns 0.
+
+ The macro works through variadic macro support.
+
+ The macro is not perfect, and can not be so. The problem
+ area is if the parameter to be checked is a function-like
+ macro name, in which case either a compiler error can result
+ or a false result can occur.
+
+ This macro is a replacement, using variadic macro support,
+ for the undocumented macro BOOST_PP_IS_EMPTY in the Boost
+ pplib. The code is taken from a posting by Paul Mensonides
+ of a variadic version for BOOST_PP_IS_EMPTY, and changed
+ in order to also support VC++.
+
+ param = a parameter
+
+ returns = 1 if the param is empty, 0 if it is not
+
+*/
#define BOOST_VMD_IS_EMPTY(param) \
VMD_DETAIL_IS_EMPTY_IIF \
( \

==============================================================================
+++ (empty file)
@@ -1,17 +0,0 @@
-#if !defined(VMD_IS_TUPLE_BEGIN_HPP)
-#define VMD_IS_TUPLE_BEGIN_HPP
-
-
-
-#if BOOST_VMD_PPLIB
-#else
-#endif /* BOOST_VMD_PPLIB */
-
-
-#endif /* VMD_IS_TUPLE_BEGIN_HPP */

==============================================================================
+++ (empty file)
@@ -1,32 +0,0 @@
-#if !defined(VMD_IS_TUPLE_BEGIN_COMMON_HPP)
-#define VMD_IS_TUPLE_BEGIN_COMMON_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-
-
-
-# define BOOST_VMD_IS_TUPLE_BEGIN(...) \
- VMD_DETAIL_IS_EMPTY_SPLIT \
- ( \
- 0, \
- VMD_DETAIL_IS_EMPTY_CAT \
- ( \
- ) \
- ) \
-/**/
-
-#endif /* BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC */
-#endif /* VMD_IS_TUPLE_BEGIN_COMMON_HPP */

==============================================================================
+++ (empty file)
@@ -1,46 +0,0 @@
-#if !defined(VMD_IS_TUPLE_BEGIN_NATIVE_HPP)
-#define VMD_IS_TUPLE_BEGIN_NATIVE_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-
-
-#include <boost/preprocessor/arithmetic/dec.hpp>
-
-/// Tests whether its parameter begins with a tuple.
-/**
-
- param = a macro parameter.
-
- returns = 1 if the param begins with a tuple, else 0 if it does not.
- If the param begins with a tuple, it may contain other
- tokens after it.
-
- There is no completely safe way to test whether the param is a tuple.
- At best one can use BOOST_VMD_ASSERT_IS_TUPLE to cause a compiler error
- if the parameter is not a tuple.
-
-*/
-#define BOOST_VMD_IS_TUPLE_BEGIN(param) \
- BOOST_PP_DEC \
- ( \
- BOOST_VMD_DATA_SIZE \
- ( \
- VMD_DETAIL_IS_TUPLE_BEGIN_COMMON_EXPAND param \
- ) \
- ) \
-/**/
-
-#endif /* BOOST_VMD_VARIADICS && BOOST_VMD_MSVC */
-#endif /* VMD_IS_TUPLE_BEGIN_NATIVE_HPP */

==============================================================================
+++ (empty file)
@@ -1,47 +0,0 @@
-#if !defined(VMD_IS_TUPLE_BEGIN_PPLIB_HPP)
-#define VMD_IS_TUPLE_BEGIN_PPLIB_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-
-
-#include <boost/preprocessor/arithmetic/dec.hpp>
-
-/// Tests whether its parameter begins with a tuple.
-/**
-
- param = a macro parameter.
-
- returns = 1 if the param begins with a tuple, else 0 if it does not.
- If the param begins with a tuple, it may contain other
- tokens after it.
-
- There is no completely safe way to test whether the param is a tuple.
- At best one can use BOOST_VMD_ASSERT_IS_TUPLE to cause a compiler error
- if the parameter is not a tuple.
-
-
-*/
-#define BOOST_VMD_IS_TUPLE_BEGIN(param) \
- BOOST_PP_DEC \
- ( \
- ( \
- VMD_DETAIL_IS_TUPLE_BEGIN_COMMON_EXPAND param \
- ) \
- ) \
-/**/
-
-#endif /* BOOST_VMD_VARIADICS && BOOST_VMD_MSVC */
-#endif /* VMD_IS_TUPLE_BEGIN_PPLIB_HPP */

==============================================================================
@@ -16,11 +16,10 @@

#include <boost/preprocessor/control/iif.hpp>
#include <boost/preprocessor/facilities/identity.hpp>

-/// Removes the set of parens from the start of a parameter if it has any.
-/**
+/** \brief Removes the set of parens from the start of a parameter if it has any.

param = a macro parameter.

@@ -34,7 +33,7 @@
# define BOOST_VMD_REMOVE_PARENS(param) \
BOOST_PP_IIF \
( \
- BOOST_VMD_IS_TUPLE_BEGIN(param), \
+ BOOST_VMD_IS_BEGIN_PARENS(param), \
VMD_DETAIL_REMOVE_PARENS, \
BOOST_PP_IDENTITY \
) \

==============================================================================
@@ -17,10 +17,9 @@
#include <boost/preprocessor/array/data.hpp>
#include <boost/preprocessor/list/to_tuple.hpp>
#include <boost/preprocessor/seq/to_tuple.hpp>

-/// Expands to variadic macro data whose arguments are the same as an array's elements.
-/**
+/** \brief Expands to variadic macro data whose arguments are the same as an array's elements.

array = a Boost PP library array data type.

@@ -37,8 +36,7 @@
BOOST_VMD_PP_TUPLE_TO_DATA(BOOST_PP_ARRAY_DATA(array)) \
/**/

-/// Expands to variadic macro data whose arguments are the same as a list's elements.
-/**
+/** \brief Expands to variadic macro data whose arguments are the same as a list's elements.

list = a Boost PP library list data type.

@@ -55,8 +53,7 @@
BOOST_VMD_PP_TUPLE_TO_DATA(BOOST_PP_LIST_TO_TUPLE(list)) \
/**/

-/// Expands to variadic macro data whose arguments are the same as a sequence's elements.
-/**
+/** \brief Expands to variadic macro data whose arguments are the same as a sequence's elements.

seq = a Boost PP library sequence data type.

@@ -73,5 +70,22 @@
BOOST_VMD_PP_TUPLE_TO_DATA(BOOST_PP_SEQ_TO_TUPLE(seq)) \
/**/

+/** \brief Expands to variadic macro data whose arguments are the same as a tuple's elements.
+
+ tuple = a Boost PP library tuple data type.
+
+ returns = variadic macro data whose arguments are the same as the
+ elements of a tuple that is inputted.
+
+ The variadic macro data that is returned is in the form of
+ of comma separated arguments. The variadic macro data can be
+ passed to any macro which takes variadic macro data in the form
+ of a final variadic macro data '...' macro parameter.
+
+*/
+#define BOOST_VMD_PP_TUPLE_TO_DATA(tuple) \
+ VMD_DETAIL_PP_TUPLE_TO_DATA(tuple) \
+/**/
+
#endif /* VMD_TO_DATA_NATIVE_HPP */

==============================================================================
@@ -17,9 +17,9 @@
#include <boost/preprocessor/array/enum.hpp>
#include <boost/preprocessor/list/enum.hpp>
#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/preprocessor/tuple/enum.hpp>

-/// Expands to variadic macro data whose arguments are the same as an array's elements.
-/**
+/** \brief Expands to variadic macro data whose arguments are the same as an array's elements.

array = a Boost PP library array data type.

@@ -36,8 +36,7 @@
BOOST_PP_ARRAY_ENUM(array) \
/**/

-/// Expands to variadic macro data whose arguments are the same as a list's elements.
-/**
+/** \brief Expands to variadic macro data whose arguments are the same as a list's elements.

list = a Boost PP library list data type.

@@ -54,8 +53,7 @@
BOOST_PP_LIST_ENUM(list) \
/**/

-/// Expands to variadic macro data whose arguments are the same as a sequence's elements.
-/**
+/** \brief Expands to variadic macro data whose arguments are the same as a sequence's elements.

seq = a Boost PP library sequence data type.

@@ -72,5 +70,22 @@
BOOST_PP_SEQ_ENUM(seq) \
/**/

+/** \brief Expands to variadic macro data whose arguments are the same as a tuple's elements.
+
+ tuple = a Boost PP library tuple data type.
+
+ returns = variadic macro data whose arguments are the same as the
+ elements of a tuple that is inputted.
+
+ The variadic macro data that is returned is in the form of
+ of comma separated arguments. The variadic macro data can be
+ passed to any macro which takes variadic macro data in the form
+ of a final variadic macro data '...' macro parameter.
+
+*/
+#define BOOST_VMD_PP_TUPLE_TO_DATA(tuple) \
+ BOOST_PP_TUPLE_ENUM(tuple) \
+/**/
+
#endif /* VMD_TO_DATA_PPLIB_HPP */

==============================================================================
@@ -22,8 +22,7 @@

#endif

-/// Expands to the number of elements in a tuple.
-/**
+/** \brief Expands to the number of elements in a tuple.

tuple = a Boost PP library tuple data type.

@@ -41,8 +40,7 @@
VMD_DETAIL_PP_TUPLE_SIZE(tuple) \
/**/

-/// Expands to a particular tuple element.
-/**
+/** \brief Expands to a particular tuple element.

n = number of the tuple element.
The number starts from 0 to the size of
@@ -67,8 +65,7 @@
VMD_DETAIL_PP_TUPLE_ELEM(BOOST_VMD_PP_TUPLE_SIZE(tuple),n,tuple) \
/**/

-/// Expands to a series of tokens which are equivalent to removing the parentheses from a tuple.
-/**
+/** \brief Expands to a series of tokens which are equivalent to removing the parentheses from a tuple.

tuple = a Boost PP library tuple data type.

@@ -92,8 +89,7 @@
VMD_DETAIL_PP_TUPLE_REM_CTOR(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

-/// Expands to a tuple whose elements are in reversed order.
-/**
+/** \brief Expands to a tuple whose elements are in reversed order.

tuple = a Boost PP library tuple data type.

@@ -116,8 +112,7 @@

#if BOOST_VMD_MSVC

-/// Expands to a list whose elements are the same as a tuple.
-/**
+/** \brief Expands to a list whose elements are the same as a tuple.

tuple = a Boost PP library tuple data type.

@@ -138,8 +133,7 @@
VMD_DETAIL_PP_TUPLE_VC_TO_LIST(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

-/// Expands to a sequence whose elements are the same as a tuple.
-/**
+/** \brief Expands to a sequence whose elements are the same as a tuple.

tuple = a Boost PP library tuple data type.

@@ -162,8 +156,7 @@

#else

-/// Expands to a list whose elements are the same as a tuple.
-/**
+/** \brief Expands to a list whose elements are the same as a tuple.

tuple = a Boost PP library tuple data type.

@@ -184,8 +177,7 @@
VMD_DETAIL_PP_TUPLE_TO_LIST(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

-/// Expands to a sequence whose elements are the same as a tuple.
-/**
+/** \brief Expands to a sequence whose elements are the same as a tuple.

tuple = a Boost PP library tuple data type.

@@ -206,25 +198,6 @@
VMD_DETAIL_PP_TUPLE_TO_SEQ(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

-#endif
-
-/// Expands to variadic macro data whose arguments are the same as a tuple's elements.
-/**
-
- tuple = a Boost PP library tuple data type.
-
- returns = variadic macro data whose arguments are the same as the
- elements of a tuple that is inputted.
-
- The variadic macro data that is returned is in the form of
- of comma separated arguments. The variadic macro data can be
- passed to any macro which takes variadic macro data in the form
- of a final variadic macro data '...' macro parameter.
-
-*/
-#define BOOST_VMD_PP_TUPLE_TO_DATA(tuple) \
- VMD_DETAIL_PP_TUPLE_TO_DATA(tuple) \
-/**/
-
+#endif /* BOOST_VMD_MSVC */
#endif /* VMD_TUPLE_NATIVE_HPP */

==============================================================================
@@ -15,15 +15,13 @@

#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/tuple/enum.hpp>
#include <boost/preprocessor/tuple/rem.hpp>
#include <boost/preprocessor/tuple/reverse.hpp>
#include <boost/preprocessor/tuple/size.hpp>
#include <boost/preprocessor/tuple/to_list.hpp>
#include <boost/preprocessor/tuple/to_seq.hpp>

-/// Expands to the number of elements in a tuple.
-/**
+/** \brief Expands to the number of elements in a tuple.

tuple = a Boost PP library tuple data type.

@@ -41,8 +39,7 @@
BOOST_PP_TUPLE_SIZE(tuple) \
/**/

-/// Expands to a particular tuple element.
-/**
+/** \brief Expands to a particular tuple element.

n = number of the tuple element.
The number starts from 0 to the size of
@@ -67,8 +64,7 @@
BOOST_PP_TUPLE_ELEM(n,tuple) \
/**/

-/// Expands to a series of tokens which are equivalent to removing the parentheses from a tuple.
-/**
+/** \brief Expands to a series of tokens which are equivalent to removing the parentheses from a tuple.

tuple = a Boost PP library tuple data type.

@@ -92,8 +88,7 @@
BOOST_PP_TUPLE_REM_CTOR(tuple) \
/**/

-/// Expands to a tuple whose elements are in reversed order.
-/**
+/** \brief Expands to a tuple whose elements are in reversed order.

tuple = a Boost PP library tuple data type.

@@ -114,8 +109,7 @@
BOOST_PP_TUPLE_REVERSE(tuple) \
/**/

-/// Expands to a list whose elements are the same as a tuple.
-/**
+/** \brief Expands to a list whose elements are the same as a tuple.

tuple = a Boost PP library tuple data type.

@@ -136,8 +130,7 @@
BOOST_PP_TUPLE_TO_LIST(tuple) \
/**/

-/// Expands to a sequence whose elements are the same as a tuple.
-/**
+/** \brief Expands to a sequence whose elements are the same as a tuple.

tuple = a Boost PP library tuple data type.

@@ -158,23 +151,5 @@
BOOST_PP_TUPLE_TO_SEQ(tuple) \
/**/

-/// Expands to variadic macro data whose arguments are the same as a tuple's elements.
-/**
-
- tuple = a Boost PP library tuple data type.
-
- returns = variadic macro data whose arguments are the same as the
- elements of a tuple that is inputted.
-
- The variadic macro data that is returned is in the form of
- of comma separated arguments. The variadic macro data can be
- passed to any macro which takes variadic macro data in the form
- of a final variadic macro data '...' macro parameter.
-
-*/
-#define BOOST_VMD_PP_TUPLE_TO_DATA(tuple) \
- BOOST_PP_TUPLE_ENUM(tuple) \
-/**/
-
#endif /* VMD_TUPLE_PPLIB_HPP */

==============================================================================
@@ -2,6 +2,6 @@

==============================================================================
@@ -39,7 +39,7 @@
:

==============================================================================
@@ -1,9 +1,9 @@
[library The Variadic Macro Data Library
[quickbook 1.5]
- [version 1.4]
+ [version 1.5]
- [copyright 2010 Tropic Software East Inc]
+ [copyright 2010-2011 Tropic Software East Inc]
[purpose Integration of variadic macro data with the Boost PP library]
[category preprocessor]
[authors [Diener, Edward]]

==============================================================================
@@ -34,7 +34,7 @@
internally using Boost PP data types to manipulate that data and
pass that data to other Boost PP macros. This library provides
-functionality to do just that with its macros which convert from
+functionality to do just that, with its macros which convert from
variadic macro data to Boost PP data types.

[section:vmd_comp_example An example design]
@@ -65,7 +65,7 @@

ENDUSER_MACRO((a)(b)(c)(d)(e)) // etc. with each "token" in the sequence surrounded by ()

-That is certainly acceptable, and without variadic macros, it is certainly
+That is certainly acceptable, and without variadic macros it is certainly
excellent to have the Boost PP functionality that allows us to design macros
taking variadic data and manipulate that data using the functionality of
Boost PP.
@@ -96,18 +96,18 @@
'''<para>'''In our example, if we wish to support a single macro, for compilers that
both support or do not support variadic macros, the code would be:'''</para>'''
'''<para>'''``
#define ENDUSER_MACRO(ppSequence) ENDUSER_DETAIL_MACRO(ppSequence)
#else
#define ENDUSER_MACRO(...) ENDUSER_DETAIL_MACRO(BOOST_VMD_DATA_TO_PP_SEQ(__VA_ARGS__))
- #endif
+ #endif
``'''</para>'''
'''<para>'''We would now have a single macro which would be used slightly differently by the
end-user depending on whether the compiler being used supported variadic macros
or not. This might not be best if the end-user's code needed to work for different
compilers, some of which support variadic macros and some of which do not. In that
latter case, a dual macro design ( see below ) might be better.'''</para>'''
-'''<para>'''Another solution supporting a single macro is to just ignore variadic macros,
+'''<para>'''Another solution for supporting a single macro is to just ignore variadic macros,
and then our solution would be:'''</para>'''
'''<para>'''``
#define ENDUSER_MACRO(ppSequence) ENDUSER_DETAIL_MACRO(ppSequence)
@@ -115,7 +115,7 @@
'''<para>'''We could also ignore any compilers which do not support variadic macros,
and then our solution would be:'''</para>'''
'''<para>'''``
#define ENDUSER_MACRO(...) ENDUSER_DETAIL_MACRO(BOOST_VMD_DATA_TO_PP_SEQ(__VA_ARGS__))
#endif
``'''</para>'''
@@ -124,7 +124,7 @@
would then be:'''</para>'''
'''<para>'''``
#define ENDUSER_MACRO(ppSequence) ENDUSER_DETAIL_MACRO(ppSequence)
#define ENDUSER_MACRO_VM(...) ENDUSER_DETAIL_MACRO(BOOST_VMD_DATA_TO_PP_SEQ(__VA_ARGS__))
#endif
``'''</para>'''

==============================================================================
@@ -1,8 +1,6 @@
[section:vmd_compilers Compilers]

-A previously mentioned in the section 'Boost Support' the compilers supported
-by this library must not have the Boost Config macro BOOST\_NO\_VARIADIC\_MACROS
-defined. I have tested this library using gcc/MingW and VC++ on Windows. The
+I have tested this library using gcc/MingW and VC++ on Windows. The
compilers tested are gcc 3.3.3, 3.4.2, 3.4.5, 4.3.0, 4.4.0, 4.5.0-1, 4.5.2-1
and VC++ 8.0, 9.0, 10.0. Other compilers which currently should work with this
library are gcc on Linux, Digital Mars C++, and Borland C++ Builder 6/Codegear C++.
@@ -12,4 +10,7 @@
installations but there would be no guarantee that the compilers for which
one wanted to use this library actually support variadic macros.

+In 'pplib' mode the compilers supported are those which are deemed to
+offer C99 variadic macro support for Boost PP.
+
[endsect]

==============================================================================
@@ -19,4 +19,12 @@
be much more important than redundancy, so I added the functionality to
this library.

+I have furthered design the library to offer a few macro programming
+features which are impossible to do effectively without the use of
+variadic macros. But I have kept these features at a minimum because
+of the difficulty of using variadic macros with compilers, most notably
+Visual C++, whose implementation of variadic macros is substandard and
+therefore very difficult to get to work correctly when variadic macros
+must be used.
+
[endsect]

==============================================================================
@@ -1,6 +1,6 @@
[section:vmd_detail Functional groups]

-The macros in VMD can best be explained as falling into four groups.
+The macros in VMD can best be explained as falling into five groups.
These are:

# Macros which directly support variadic macro data usage.
@@ -9,6 +9,9 @@
# Macros which offer an easy to use replacement for Boost PP
tuple macros because they do not require the size of the tuple
to be specified.
+# Macros which offer further functionality for common Boost PP
+ situations through the use of variadic macros.
+# Macros which control internal variadic data functionality.

A further general explanation of each of these groups follow, while
a specific explanation for each macro can be found in the reference
@@ -28,6 +31,9 @@
the comma-separated sequence. Here 'n' stands for the number of
the token, starting with 0, which is returned from the variadic
macro data.
+
+The end-user of VMD can include the individual header file 'vmd_data.hpp'

[endsect]

@@ -41,6 +47,9 @@
# [macroref BOOST_VMD_DATA_TO_PP_LIST](...), which converts to a Boost PP list.
# [macroref BOOST_VMD_DATA_TO_PP_SEQ](...), which converts to a Boost PP sequence.

+The end-user of VMD can include the individual header file 'vmd_data.hpp'
+
[endsect]

[section:vmd_fromPP Convert from Boost PP data types]
@@ -58,6 +67,9 @@
any of these macros can be passed to variadic macros as the final
parameter.

+The end-user of VMD can include the individual header file 'vmd_to_data.hpp'
+
[endsect]

[section:vmd_tuple Boost PP tuple enhancements]
@@ -84,6 +96,177 @@
BOOST\_PP\_TUPLE\_TO\_SEQ without having to pass the size of the
tuple as the first parameter.

+The end-user of VMD can include the individual header file 'vmd_tuple.hpp'
+
+[endsect]
+
+[section:vmd_further_func Further functionality]
+
+There are macros which add further functionality related to Boost PP
+through the use of variadic macros. These can be divided into three
+groups:
+
+[section:vmd_test_empty Testing for emptiness]
+
+Currently Boost PP has an undocumented macro for testing whether
+a parameter is empty of not, written without the use of variadic
+macros. The macro is called [macroref BOOST_PP_IS_EMPTY]. The macro is by its nature flawed,
+since there is no generalized way of determining whether or not a
+parameter is empty using the C++ preprocessor. But the macro will
+work given some limited inputs or emptiness. Paul Mensonides, the
+developer of Boost PP and the BOOST_PP_IS_EMPTY macro there, also wrote a better macro, using variadic
+macros, for determining whether or not a parameter is empty or not.
+This macro is also not perfect, since there is no perfect solution,
+but will work correctly with almost all input. I have adapted his code
+for the VMD and developed my own code to work with the Visual C++
+compiler since Paul's code would not because of deficiencies in the
+Visual C++ preprocessor.
+
+The macro is called BOOST_VMD_IS_EMPTY and will return 1 if its input
+is empty or 0 if its input is not empty. For the standard version the macro
+is a variadic macro which make take any input. For the Visual C++ version the
+macro is not a variadic macro and therefore takes a single parameter,
+although it uses variadic macros in order to work properly.
+
+The one situation where the macro may not work properly is if its
+input is a function-like macro name. In that case the macro may
+either work incorrectly or give a compiler error.
+
+The end-user of VMD can include the individual header file 'vmd_is_empty.hpp'
+
+[endsect]
+
+[section:vmd_test_parens Testing and removing parens]
+
+A common need when using macros and the Boost PP is determining
+whether a parameter begins with a set of parenthesis, within
+which tokens may exist. This is the form of a Boost PP tuple.
+All Boost PP data types begin this way, and both PP arrays and
+lists are tuples of a certain form, while a PP seq is a series
+of one or more single element tuples.
+
+The macro [macroref BOOST_VMD_IS_BEGIN_PARENS] takes as its input a parameter
+and determines whether the parameter begins with a set of parenthesis.
+It returns 1 if its input begins with a set of parenthesis, else it
+returns 0. For the standard version the macro is a variadic macro which make take
+any input. For the Visual C++ version the macro is not a variadic macro
+and therefore takes a single parameter, although it uses variadic macros
+in order to work properly.
+
+There may be other tokens after the set of parameters that begins the
+input, and the macro still returns 1.
+
+Another common need when using macros and the Boost PP is to
+remove the set of parenthesis from the beginning of a parameter.
+This is what [macroref BOOST_VMD_REMOVE_PARENS] does. if the parameter does
+not contain a set of beginning parenthesis, the input parameter
+is returned as is, else the input parameter is returned with the
+beginning parenthesis removed. No other parenthesis after the
+possible beginning parenthesis is removed.
+
+The end-user of VMD can include the individual header file 'vmd_is_begin_parens.hpp'
+macro and the individual header file 'vmd_remove_parens.hpp'
+macro.
+
+[endsect]
+
+[section:vmd_assert_data Asserting Boost PP data types]
+
+There is no way to determine whether a macro parameter is a
+given Boost PP data type. But one can come close to this
+functionality using variadic macros and the test for emptiness
+in the VMD library which the BOOST_VMD_IS_EMPTY macro gives.
+Therefore I have developed four macros, for each of the four
+Boost PP data types, which will produce a compiler error if a
+parameter is not a given data type, else will output nothing.
+These macros are:
+
+# [macroref BOOST_VMD_ASSERT_IS_ARRAY](param), asserts that 'param' is a Boost PP array
+# [macroref BOOST_VMD_ASSERT_IS_LIST](param), asserts that 'param' is a Boost PP list
+# [macroref BOOST_VMD_ASSERT_IS_SEQ](param), asserts that 'param' is a Boost PP seq
+# [macroref BOOST_VMD_ASSERT_IS_TUPLE](param), asserts that 'param' is a Boost PP tuple
+
+Each of these act like a C++ assert-like macro. They do nothing if the 'param'
+is of the known type, else produce a compiler error. Furthermore these macros,
+like 'assert-like macros, only check their 'param' in debug mode. This, however,
+can be overridden by the BOOST_VMD_ASSERT_DATA macro. If it is defined and set
+to 1, the macros will always check their 'param', otherwise if it is set to 0
+the 'param' is never checked.
+
+The assert macros can be used in code to test whether a 'param' is of the expected
+Boost PP data type. It is not possible to create equivalent macros which return 1
+when the 'param' is of the correct type, else return 0, because of the assert macros'
+necessary reliance on BOOST_VMD_IS_EMPTY, which even in the best of conditions is slightly
+flawed. However the flaw in BOOST_VMD_IS_EMPTY, where a function-like macro name
+could produce a compiler error, is made use of in the assert macros so that the
+compiler error produced in that case will only occur when the assert macro verifies
+that its 'param' is not the Boost PP data type being checked. Still there is the
+very slight flaw in the assert macros where its reliance on BOOST_VMD_IS_EMPTY
+could run into input being checked where a function-like macro name will produce
+the incorrect result from the BOOST_VMD_IS_EMPTY macro. However this flaw is thought to be
+so slight, and an end-user's chance of inputting such data so minimal, that it
+was felt that such assert-like macros would be beneficial to macro programmers
+using Boost PP and VMD.
+
+Another point to be made is that Boost PP array and list are also tuples. So
+passing an array or list to BOOST_VMD_ASSERT_IS_TUPLE will assert that either
+is a valid tuple by not producing a compiler error.
+
+A final point concerns using the assert macros with Visual C++. There is no way
+which I have been able to discover to produce a compiler error from within a
+macro using Visual C++ without producing invalid C++ output to trigger the error. Because of this the
+promise to produce no output in case of error from the assert macros must be amended for Visual C++. The
+compiler error when using Visual C++, and an assert macro fails, could be masked by using one of the assert macros in a
+situation where no output is generated by an enclosing macro.
+
+Individual header files can be used for each of the assert macros
+
+'vmd_assert_is_array.hpp' for the BOOST_VMD_ASSERT_IS_ARRAY macro
+'vmd_assert_is_list.hpp' for the BOOST_VMD_ASSERT_IS_LIST macro
+'vmd_assert_is_seq.hpp' for the BOOST_VMD_ASSERT_IS_SEQ macro
+'vmd_assert_is_tuple.hpp' for the BOOST_VMD_ASSERT_IS_TUPLE macro.
+
+[endsect]
+
+[section:vmd_internal_macros Controlling internal usage]
+
+VMD has a few object-like macros which the end-user of the library can use
+to determine or change the way variadic macros are used in the
+library.
+
+data support exists for the particular compiler the end-user is
+using with VMD. VMD automatically sets this macro to 0 if the
+compiler does not support variadic macros, else it sets this macro
+to non-zero if the compiler does support variadic macro data. An
+end-user of VMD can also use this macro in his own design
+to determine whether or not variadic macros are supported. Furthermore
+an end-user of VMD can set this macro to 0 or non-zero, before including
+a VMD header file, to force VMD to treat the particular compiler being
+used as not supporting or supporting variadic macros.
+
+The macro BOOST_VMD_PPLIB controls the 'mode' VMD is operating in. When
+this macro is set to 0, which is currently the default, VMD is operating
+in its 'native' mode, whereas when this macro is set to non-zero VMD is operating
+in its 'pplib' mode. The end-user of VMD can set this macro to control the
+mode before including a VMD header file, or check the value if necessary after
+
+The macro BOOST_VMD_ASSERT_DATA controls whether or not an assert macro
+will check its data. The default is that in compiler debug mode it will check the
+data while in compiler release mode it will not check its data. The end-user can
+change this by setting the macro to 0 to not check the data, or non-zero to check
+the data before including a VMD header file, or check the value if necessary after
+
+[endsect]
+
[endsect]

[endsect]

==============================================================================
@@ -28,8 +28,19 @@
be extracted from the variadic macro data and used in macro expansion
or passed to other macros.

-Finally through the functionality of variadic macros, VMD provides parallel
+Through the functionality of variadic macros, VMD provides parallel
functionality to the Boost PP tuple interface macros with a set of macros
which do not need the size of a tuple to be specified.
+
+All of the previously mentioned variadic macro functionality
+has been added to a version of Boost PP which is currently in
+the Boost trunk. In 'pplib' mode, all of this functionality
+become invocations to the Boost PP trunk equivalent macros.
+
+VMD also offers further macro functionality,
+using variadic macros, centered on the
+verification of Boost PP data types, on the detection and
+removal of beginning parentheses in a macro parameter, and
+on the determination of whether a parameter is empty or not.

[endsect]

==============================================================================
@@ -1,5 +1,13 @@
[section:vmd_history History]

+
+* Added macros for verifying Boost PP data types.
+* Added macros for detecting and removing beginning parens.
+* Added a macro for testing for the emptiness of a parameter.
+* Added support for 'native' and 'pplib' modes.
+

* Removed internal dependency on BOOST_PP_CAT and BOOST_PP_ADD when using VC++.

==============================================================================
@@ -1,6 +1,6 @@
[section:vmd_intro Introduction]

-Welcome to the variadic macro data library version 1.4.
+Welcome to the variadic macro data library version 1.5.

The variadic macro data library, or VMD for short, is a library
of macros which provide important functionality for variadic
@@ -19,10 +19,19 @@
providing equivalent macros to Boost PP tuple macros
which do not require the size of the tuple to be explicitly
passed.
+# Provide additional support for Boost PP data types and other
+ functionality through the use of variadic macros.

The library is a header only library and all macros in the
-library are in a single header, whose name is 'vmd.hpp'.
+library are included by a single header, whose name is 'vmd.hpp'.
+Individual headers may be used for different functionality
+in the library and will be denoted when that functionality is
+explained.

-The library is dependent on Boost PP.
+All the macros in the library begin with the sequence 'BOOST_VMD_'
+to distinguish them from other macros the end-user might use.
+
+The library is dependent on Boost PP and,
+in default 'native' mode, Boost Config.

[endsect]

==============================================================================
@@ -21,9 +21,45 @@
based on the ability of a given compiler/version to support C99's variadic
macros. This support has now been added, as of Boost version 1.4.5, in the form of
a macro which denotes that compiler support for variadic macros does not exist.
-will only work for a compiler/version combination when BOOST\_NO\_VARIADIC\_MACROS
-is not defined.
+
+The Boost PP library has had no support for variadic macros but a version
+has been recently put in the Boost trunk which does offer support for
+in this version of Boost PP whose functionality is taken from the variadic
+macro support in the VMD.
+
+[section:vmd_vmacros_Modes The two modes of the library]
+
+Because of variadic macro support in the Boost PP library currently in the
+Boost trunk, the VMD library can operate in one of two modes.
+In its 'native' mode, which is currently the default mode, the library does not
+forward to the equivalent variadic macro support in the Boost PP library. In its 'pplib'
+mode the VMD library does forward to the equivalent variadic macro support in the
+Boost PP library. The modes can be controlled by the macro BOOST_VMD_PPLIB.
+When this macro is defined and set to 1, the library operates in the 'pplib'
+mode, else it operates in its 'native' mode. The end-user of VMD can also use
+the macro BOOST_VMD_PPLIB to test the mode the VMD library is in.
+
+When the Boost PP library variadic macro support currently in the Boost trunk
+is added to a future official version of Boost, the default mode in a
+subsequent version of VMD will be changed to 'pplib' mode and the end-user
+will be encouraged to use the functionality
+of the Boost PP library instead of the functionality of VMD which duplicates it.
+At that time the functionality in VMD which duplicates the same functionality
+in Boost PP will be deprecated.
+
+Depending on the mode being used VMD determines whether variadic macro support
+is enabled for a particular compiler. The end-user of VMD can also manually
+use the macro BOOST_VMD_VARIADICS to turn on or off compiler support for
+variadic macro data in the VMD library. When BOOST_VMD_VARIADICS is set to 0
+variadic macro data is not supported in the VMD library, otherwise when
+BOOST_VMD_VARIADICS is set to non-zero it is supported in the VMD library. This
+same macro can be used to determine if VMD supports variadic macros for a
+particular compiler.
+
+[endsect]

[endsect]

==============================================================================
@@ -31,7 +31,7 @@
[ run test_data_as_array.cpp ]
[ run test_data_as_list.cpp ]
[ run test_data_as_sequence.cpp ]
- [ run test_tuple_begin.cpp ]
+ [ run test_is_begin_parens.cpp ]
[ run test_remove_parens.cpp ]
[ run test_is_empty.cpp ]
[ compile test_assert_is_tuple.cpp :
@@ -93,9 +93,9 @@
[ run test_data_as_sequence.cpp : : :
test_data_as_sequence_gh ]
- [ run test_tuple_begin.cpp : : :
+ [ run test_is_begin_parens.cpp : : :
- test_tuple_begin_gh ]
+ test_is_begin_parens_gh ]
[ run test_remove_parens.cpp : : :
test_remove_parens_gh ]
@@ -201,9 +201,9 @@
[ run test_data_as_sequence.cpp : : :
<define>BOOST_VMD_PPLIB=1 :
test_data_as_sequence_pplib ]
- [ run test_tuple_begin.cpp : : :
+ [ run test_is_begin_parens.cpp : : :
<define>BOOST_VMD_PPLIB=1 :
- test_tuple_begin_pplib ]
+ test_is_begin_parens_pplib ]
[ run test_remove_parens.cpp : : :
<define>BOOST_VMD_PPLIB=1 :
test_remove_parens_pplib ]
@@ -314,10 +314,10 @@
<define>BOOST_VMD_PPLIB=1 :
test_data_as_sequence_ppgh ]
- [ run test_tuple_begin.cpp : : :
+ [ run test_is_begin_parens.cpp : : :
<define>BOOST_VMD_PPLIB=1 :
- test_tuple_begin_ppgh ]
+ test_is_begin_parens_ppgh ]
[ run test_remove_parens.cpp : : :
<define>BOOST_VMD_PPLIB=1 :

==============================================================================
@@ -3,6 +3,7 @@
#else
#endif
#include <boost/detail/lightweight_test.hpp>

==============================================================================
@@ -1,7 +1,7 @@
#else
#endif
#include <boost/detail/lightweight_test.hpp>

@@ -21,16 +21,16 @@
#define AN_ARRAY (4,(5,7,f,x))
#define A_LIST (e,(g,(&,BOOST_PP_NIL)))

- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_TUPLE));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_TUPLE2));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_TUPLE_PLUS));
- BOOST_TEST(!BOOST_VMD_IS_TUPLE_BEGIN(PLUS_ATUPLE));
- BOOST_TEST(!BOOST_VMD_IS_TUPLE_BEGIN(JDATA));
- BOOST_TEST(!BOOST_VMD_IS_TUPLE_BEGIN(NOT_TUPLE));
- BOOST_TEST(!BOOST_VMD_IS_TUPLE_BEGIN(NOT_TUPLE2));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_SEQ));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(AN_ARRAY));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_LIST));
+ BOOST_TEST(BOOST_VMD_IS_BEGIN_PARENS(A_TUPLE));
+ BOOST_TEST(BOOST_VMD_IS_BEGIN_PARENS(A_TUPLE2));
+ BOOST_TEST(BOOST_VMD_IS_BEGIN_PARENS(A_TUPLE_PLUS));
+ BOOST_TEST(!BOOST_VMD_IS_BEGIN_PARENS(PLUS_ATUPLE));
+ BOOST_TEST(!BOOST_VMD_IS_BEGIN_PARENS(JDATA));
+ BOOST_TEST(!BOOST_VMD_IS_BEGIN_PARENS(NOT_TUPLE));
+ BOOST_TEST(!BOOST_VMD_IS_BEGIN_PARENS(NOT_TUPLE2));
+ BOOST_TEST(BOOST_VMD_IS_BEGIN_PARENS(A_SEQ));
+ BOOST_TEST(BOOST_VMD_IS_BEGIN_PARENS(AN_ARRAY));
+ BOOST_TEST(BOOST_VMD_IS_BEGIN_PARENS(A_LIST));

#endif

==============================================================================
+++ (empty file)
@@ -1,39 +0,0 @@
-#else
-#endif
-#include <boost/detail/lightweight_test.hpp>
-
-int main()
- {
-
-
- #define A_TUPLE (*,#,zz)
- #define A_TUPLE2 (*,#,(zz,44,(e7)))
- #define A_TUPLE_PLUS (mmf,34,^^,!) 456
- #define PLUS_ATUPLE yyt (j,ii%)
- #define JDATA ggh
- #define NOT_TUPLE y6()
- #define NOT_TUPLE2 &(kkkgg,(e))
- #define A_SEQ (r)(\$)(#)
- #define AN_ARRAY (4,(5,7,f,x))
- #define A_LIST (e,(g,(&,BOOST_PP_NIL)))
-
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_TUPLE));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_TUPLE2));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_TUPLE_PLUS));
- BOOST_TEST(!BOOST_VMD_IS_TUPLE_BEGIN(PLUS_ATUPLE));
- BOOST_TEST(!BOOST_VMD_IS_TUPLE_BEGIN(JDATA));
- BOOST_TEST(!BOOST_VMD_IS_TUPLE_BEGIN(NOT_TUPLE));
- BOOST_TEST(!BOOST_VMD_IS_TUPLE_BEGIN(NOT_TUPLE2));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_SEQ));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(AN_ARRAY));
- BOOST_TEST(BOOST_VMD_IS_TUPLE_BEGIN(A_LIST));
-
-#endif
-
- return boost::report_errors();
-
- }