# Boost-Commit :

From: eldiener_at_[hidden]
Date: 2011-08-14 21:09:45

Author: eldiener
Date: 2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
New Revision: 73768
URL: http://svn.boost.org/trac/boost/changeset/73768

Log:
Removed:
Text files modified:
22 files changed, 799 insertions(+), 721 deletions(-)

==============================================================================
+++ (empty file)
@@ -1,66 +0,0 @@
-#if !defined(VMD_IS_EMPTY_COMMON_HPP)
-#define VMD_IS_EMPTY_COMMON_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-
-
-
-/** \brief Tests whether its input is empty or not.
-
- The macro checks to see if the input is empty or not.
- It returns 1 if the input is empty, else returns 0.
-
- The macro is a variadic macro taking any input and works through variadic macro support.
-
- The macro is not perfect, and can not be so. The problem
- area is if the input to be checked is a function-like
- macro name, in which case either a compiler error can result
- or a false result can occur.
-
- 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 input is empty, 0 if it is not
-
- It is recommended to append BOOST_PP_EMPTY() to whatever input
- is being tested in order to avoid possible warning messages
- from some compilers about no parameters being passed to the macro
- when the input is truly empty.
-
-*/
-#define BOOST_VMD_IS_EMPTY(...) \
- VMD_DETAIL_IS_EMPTY_IIF \
- ( \
- BOOST_VMD_IS_BEGIN_PARENS \
- ( \
- __VA_ARGS__ \
- ) \
- ) \
- ( \
- 0, \
- BOOST_VMD_IS_BEGIN_PARENS \
- ( \
- VMD_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ () \
- ) \
- ) \
-/**/
-
-#endif /* BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC */
-#endif /* VMD_IS_EMPTY_COMMON_HPP */

==============================================================================
+++ (empty file)
@@ -1,61 +0,0 @@
-#if !defined(VMD_IS_EMPTY_PPLIB_HPP)
-#define VMD_IS_EMPTY_PPLIB_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-
-
-
-/** \brief Tests whether its input is empty or not.
-
- The macro checks to see if the input is empty or not.
- It returns 1 if the input is empty, else returns 0.
-
- The macro is a variadic macro taking any input and works through variadic macro support.
-
- The macro is not perfect, and can not be so. The problem
- area is if the input to be checked is a function-like
- macro name, in which case either a compiler error can result
- or a false result can occur.
-
- 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 input is empty, 0 if it is not
-
- It is recommended to append BOOST_PP_EMPTY() to whatever input
- is being tested in order to avoid possible warning messages
- from some compilers about no parameters being passed to the macro
- when the input is truly empty.
-
-*/
-#define BOOST_VMD_IS_EMPTY(...) \
- VMD_DETAIL_IS_EMPTY_IIF \
- ( \
- BOOST_VMD_IS_BEGIN_PARENS(__VA_ARGS__) \
- ) \
- ( \
- VMD_DETAIL_IS_EMPTY_GEN_ZERO, \
- BOOST_VMD_IS_BEGIN_PARENS \
- ) \
- (VMD_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ ()) \
-/**/
-
-#endif /* BOOST_VMD_VARIADICS && BOOST_VMD_MSVC */
-#endif /* VMD_IS_EMPTY_PPLIB_HPP */

==============================================================================
@@ -5,6 +5,56 @@

+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_ASSERT_IS_ARRAY(array)
+
+ \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.
+
+*/
+
#if BOOST_VMD_PPLIB
#else

==============================================================================
@@ -1,56 +1,6 @@
#if !defined(VMD_ASSERT_IS_ARRAY_COMMON_HPP)
#define VMD_ASSERT_IS_ARRAY_COMMON_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-/** \def BOOST_VMD_ASSERT_IS_ARRAY(array)
-
- \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.
-
-*/
-

==============================================================================
@@ -1,15 +1,6 @@
#if !defined(VMD_ASSERT_IS_ARRAY_NATIVE_HPP)
#define VMD_ASSERT_IS_ARRAY_NATIVE_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-

#if BOOST_VMD_VARIADICS && BOOST_VMD_ASSERT_DATA && !BOOST_VMD_MSVC
@@ -22,44 +13,6 @@

-/** \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 \

==============================================================================
@@ -1,15 +1,6 @@
#if !defined(VMD_ASSERT_IS_ARRAY_PPLIB_HPP)
#define VMD_ASSERT_IS_ARRAY_PPLIB_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-

#if BOOST_VMD_VARIADICS && BOOST_VMD_ASSERT_DATA && !BOOST_VMD_MSVC
@@ -22,44 +13,6 @@

-/** \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 \

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

+/*

+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_ASSERT_IS_LIST(list)
+
+ \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.
+
+*/
+
+#if !BOOST_VMD_ASSERT_DATA
+
+#define BOOST_VMD_ASSERT_IS_LIST(list)
+
+#else
+
+#include <boost/preprocessor/control/while.hpp>
+
+#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, \
+ list \
+ ) \
+ ) \
+/**/
+
+#endif /* BOOST_VMD_ASSERT_DATA */
#endif /* VMD_ASSERT_IS_LIST_HPP */

==============================================================================
+++ (empty file)
@@ -1,81 +0,0 @@
-#if !defined(VMD_ASSERT_IS_LIST_COMMON_HPP)
-#define VMD_ASSERT_IS_LIST_COMMON_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-/** \def BOOST_VMD_ASSERT_IS_LIST(list)
-
- \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.
-
-*/
-
-
-
-#if !BOOST_VMD_ASSERT_DATA
-
-#define BOOST_VMD_ASSERT_IS_LIST(list)
-
-#else
-
-#include <boost/preprocessor/control/while.hpp>
-
-#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, \
- list \
- ) \
- ) \
-/**/
-
-#endif /* BOOST_VMD_ASSERT_DATA */
-#endif /* VMD_ASSERT_IS_LIST_COMMON_HPP */

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

+/*

+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_ASSERT_IS_SEQ(seq)
+
+ \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.
+
+*/
+
+#if !BOOST_VMD_ASSERT_DATA
+
+#define BOOST_VMD_ASSERT_IS_SEQ(seq)
+
+#else
+
+#include <boost/preprocessor/control/while.hpp>
+
+#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, \
+ seq \
+ ) \
+ ) \
+/**/
+
+#endif /* BOOST_VMD_ASSERT_DATA */
#endif /* VMD_ASSERT_IS_SEQ_HPP */

==============================================================================
+++ (empty file)
@@ -1,81 +0,0 @@
-#if !defined(VMD_ASSERT_IS_SEQ_COMMON_HPP)
-#define VMD_ASSERT_IS_SEQ_COMMON_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-/** \def BOOST_VMD_ASSERT_IS_SEQ(seq)
-
- \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.
-
-*/
-
-
-
-#if !BOOST_VMD_ASSERT_DATA
-
-#define BOOST_VMD_ASSERT_IS_SEQ(seq)
-
-#else
-
-#include <boost/preprocessor/control/while.hpp>
-
-#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, \
- seq \
- ) \
- ) \
-/**/
-
-#endif /* BOOST_VMD_ASSERT_DATA */
-#endif /* VMD_ASSERT_IS_SEQ_COMMON_HPP */

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

+/*

+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_ASSERT_IS_TUPLE(tuple)
+
+ \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.
+
+*/
+
+#if !BOOST_VMD_ASSERT_DATA
+
+#define BOOST_VMD_ASSERT_IS_TUPLE(tuple)
+
+#else
+
+#include <boost/preprocessor/control/iif.hpp>
+
+#if !BOOST_VMD_MSVC
+
+#include <boost/preprocessor/debug/assert.hpp>
+
+#endif
+
+
+#if BOOST_VMD_MSVC
+
+#include <boost/preprocessor/facilities/empty.hpp>
+
+#define BOOST_VMD_ASSERT_IS_TUPLE(tuple) \
+ VMD_DETAIL_ASSERT_IS_TUPLE_VC_CHECK_RETURN_FAILURE \
+ ( \
+ BOOST_PP_IIF \
+ ( \
+ BOOST_VMD_IS_BEGIN_PARENS(tuple), \
+ VMD_DETAIL_ASSERT_IS_TUPLE_IS_NOT_AFTER, \
+ VMD_DETAIL_ASSERT_IS_TUPLE_GEN_ZERO \
+ ) \
+ (tuple) \
+ ) \
+/**/
+
+#else
+
+#define BOOST_VMD_ASSERT_IS_TUPLE(tuple) \
+ BOOST_PP_ASSERT \
+ ( \
+ BOOST_PP_IIF \
+ ( \
+ BOOST_VMD_IS_BEGIN_PARENS(tuple), \
+ VMD_DETAIL_ASSERT_IS_TUPLE_IS_NOT_AFTER, \
+ VMD_DETAIL_GEN_ZERO \
+ ) \
+ (tuple) \
+ ) \
+/**/
+
+#endif /* BOOST_VMD_MSVC */
+#endif /* BOOST_VMD_ASSERT_DATA */
#endif /* VMD_ASSERT_IS_TUPLE_HPP */

==============================================================================
+++ (empty file)
@@ -1,111 +0,0 @@
-#if !defined(VMD_ASSERT_IS_TUPLE_COMMON_HPP)
-#define VMD_ASSERT_IS_TUPLE_COMMON_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-/** \def BOOST_VMD_ASSERT_IS_TUPLE(tuple)
-
- \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.
-
-*/
-
-
-
-#if !BOOST_VMD_ASSERT_DATA
-
-#define BOOST_VMD_ASSERT_IS_TUPLE(tuple)
-
-#else
-
-#include <boost/preprocessor/control/iif.hpp>
-
-#if !BOOST_VMD_MSVC
-
-#include <boost/preprocessor/debug/assert.hpp>
-
-#endif
-
-
-#if BOOST_VMD_MSVC
-
-#include <boost/preprocessor/facilities/empty.hpp>
-
-#define BOOST_VMD_ASSERT_IS_TUPLE(tuple) \
- VMD_DETAIL_ASSERT_IS_TUPLE_VC_CHECK_RETURN_FAILURE \
- ( \
- BOOST_PP_IIF \
- ( \
- BOOST_VMD_IS_BEGIN_PARENS(tuple), \
- VMD_DETAIL_ASSERT_IS_TUPLE_IS_NOT_AFTER, \
- VMD_DETAIL_ASSERT_IS_TUPLE_GEN_ZERO \
- ) \
- (tuple) \
- ) \
-/**/
-
-#else
-
-#define BOOST_VMD_ASSERT_IS_TUPLE(tuple) \
- BOOST_PP_ASSERT \
- ( \
- BOOST_PP_IIF \
- ( \
- BOOST_VMD_IS_BEGIN_PARENS(tuple), \
- VMD_DETAIL_ASSERT_IS_TUPLE_IS_NOT_AFTER, \
- VMD_DETAIL_GEN_ZERO \
- ) \
- (tuple) \
- ) \
-/**/
-
-#endif /* BOOST_VMD_MSVC */
-#endif /* BOOST_VMD_ASSERT_DATA */
-#endif /* VMD_ASSERT_IS_TUPLE_COMMON_HPP */

==============================================================================
@@ -5,6 +5,101 @@

+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_DATA_SIZE(...)
+
+ \brief Expands to the number of comma-separated variadic macro data arguments.
+
+ ... = variadic macro data.
+
+ returns = the number of comma-separated variadic macro data
+ arguments being passed to it.
+
+ The value returned can be between 1 and 64.
+
+*/
+
+/** \def BOOST_VMD_DATA_ELEM(n,...)
+
+ \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
+ variadic macro data arguments - 1. The maximum
+ number for n is 63.
+
+ ... = variadic macro data.
+
+ returns = the particular macro data argument as specified
+ by n. The argument returned can be any valid
+ preprocessing token.
+
+*/
+
+/** \def BOOST_VMD_DATA_TO_PP_TUPLE(...)
+
+ \brief Expand to a Boost PP tuple data type.
+
+ ... = variadic macro data.
+
+ returns = a Boost PP library tuple data type.
+
+ You can use the result of this macro whenever
+ you need to pass a Boost PP library tuple as
+ data to a Boost PP library macro.
+
+*/
+
+/** \def BOOST_VMD_DATA_TO_PP_ARRAY(...)
+
+ \brief Expand to a Boost PP array data type.
+
+ ... = variadic macro data.
+
+ returns = a Boost PP library array data type.
+
+ You can use the result of this macro whenever
+ you need to pass a Boost PP library array as
+ data to a Boost PP library macro.
+
+*/
+
+/** \def BOOST_VMD_DATA_TO_PP_LIST(...)
+
+ \brief Expand to a Boost PP list data type.
+
+ ... = variadic macro data.
+
+ returns = a Boost PP library list data type.
+
+ You can use the result of this macro whenever
+ you need to pass a Boost PP library list as
+ data to a Boost PP library macro.
+
+*/
+
+/** \def BOOST_VMD_DATA_TO_PP_SEQ(...)
+
+ \brief Expand to a Boost PP sequence data type.
+
+ ... = variadic macro data.
+
+ returns = a Boost PP library sequence data type.
+
+ You can use the result of this macro whenever
+ you need to pass a Boost PP library sequence as
+ data to a Boost PP library macro.
+
+*/
+
#if BOOST_VMD_PPLIB
#else

==============================================================================
@@ -1,113 +1,35 @@
#if !defined(VMD_DATA_NATIVE_HPP)
#define VMD_DATA_NATIVE_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-

-/** \brief Expands to the number of comma-separated variadic macro data arguments.
-
- ... = variadic macro data.
-
- returns = the number of comma-separated variadic macro data
- arguments being passed to it.
-
- The value returned can be between 1 and 64.
-
-*/
#define BOOST_VMD_DATA_SIZE(...) \
VMD_DETAIL_DATA_SIZE(__VA_ARGS__) \
/**/

-/** \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
- variadic macro data arguments - 1. The maximum
- number for n is 63.
-
- ... = variadic macro data.
-
- returns = the particular macro data argument as specified
- by n. The argument returned can be any valid
- preprocessing token.
-
-*/
#define BOOST_VMD_DATA_ELEM(n,...) \
VMD_DETAIL_DATA_ELEM(n,__VA_ARGS__) \
/**/

-/** \brief Expand to a Boost PP tuple data type.
-
- ... = variadic macro data.
-
- returns = a Boost PP library tuple data type.
-
- You can use the result of this macro whenever
- you need to pass a Boost PP library tuple as
- data to a Boost PP library macro.
-
-*/
#define BOOST_VMD_DATA_TO_PP_TUPLE(...) \
VMD_DETAIL_DATA_TO_PP_TUPLE(__VA_ARGS__) \
/**/

-/** \brief Expand to a Boost PP array data type.
-
- ... = variadic macro data.
-
- returns = a Boost PP library array data type.
-
- You can use the result of this macro whenever
- you need to pass a Boost PP library array as
- data to a Boost PP library macro.
-
-*/
#define BOOST_VMD_DATA_TO_PP_ARRAY(...) \
VMD_DETAIL_DATA_TO_PP_ARRAY(__VA_ARGS__) \
/**/

-/** \brief Expand to a Boost PP list data type.
-
- ... = variadic macro data.
-
- returns = a Boost PP library list data type.
-
- You can use the result of this macro whenever
- you need to pass a Boost PP library list as
- data to a Boost PP library macro.
-
-*/
#define BOOST_VMD_DATA_TO_PP_LIST(...) \
VMD_DETAIL_DATA_TO_PP_LIST(__VA_ARGS__) \
/**/

-/** \brief Expand to a Boost PP sequence data type.
-
- ... = variadic macro data.
-
- returns = a Boost PP library sequence data type.
-
- You can use the result of this macro whenever
- you need to pass a Boost PP library sequence as
- data to a Boost PP library macro.
-
-*/
#define BOOST_VMD_DATA_TO_PP_SEQ(...) \
VMD_DETAIL_DATA_TO_PP_SEQ(__VA_ARGS__) \
/**/

-
#endif /* VMD_DATA_NATIVE_HPP */

==============================================================================
@@ -1,15 +1,6 @@
#if !defined(VMD_DATA_PPLIB_HPP)
#define VMD_DATA_PPLIB_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-

@@ -21,94 +12,26 @@

-/** \brief Expands to the number of comma-separated variadic macro data arguments.
-
- ... = variadic macro data.
-
- returns = the number of comma-separated variadic macro data
- arguments being passed to it.
-
- The value returned can be between 1 and 64.
-
-*/
#define BOOST_VMD_DATA_SIZE(...) \
/**/

-/** \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
- variadic macro data arguments - 1. The maximum
- number for n is 63.
-
- ... = variadic macro data.
-
- returns = the particular macro data argument as specified
- by n. The argument returned can be any valid
- preprocessing token.
-
-*/
#define BOOST_VMD_DATA_ELEM(n,...) \
/**/

-/** \brief Expand to a Boost PP tuple data type.
-
- ... = variadic macro data.
-
- returns = a Boost PP library tuple data type.
-
- You can use the result of this macro whenever
- you need to pass a Boost PP library tuple as
- data to a Boost PP library macro.
-
-*/
#define BOOST_VMD_DATA_TO_PP_TUPLE(...) \
/**/

-/** \brief Expand to a Boost PP array data type.
-
- ... = variadic macro data.
-
- returns = a Boost PP library array data type.
-
- You can use the result of this macro whenever
- you need to pass a Boost PP library array as
- data to a Boost PP library macro.
-
-*/
#define BOOST_VMD_DATA_TO_PP_ARRAY(...) \
/**/

-/** \brief Expand to a Boost PP list data type.
-
- ... = variadic macro data.
-
- returns = a Boost PP library list data type.
-
- You can use the result of this macro whenever
- you need to pass a Boost PP library list as
- data to a Boost PP library macro.
-
-*/
#define BOOST_VMD_DATA_TO_PP_LIST(...) \
/**/

-/** \brief Expand to a Boost PP sequence data type.
-
- ... = variadic macro data.
-
- returns = a Boost PP library sequence data type.
-
- You can use the result of this macro whenever
- you need to pass a Boost PP library sequence as
- data to a Boost PP library macro.
-
-*/
#define BOOST_VMD_DATA_TO_PP_SEQ(...) \
/**/

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

+/*

+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_IS_BEGIN_PARENS(...)
+
+ \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.
+
+*/
+
+#if BOOST_VMD_MSVC
+
+
+#define BOOST_VMD_IS_BEGIN_PARENS(...) \
+ VMD_DETAIL_IS_BEGIN_PARENS_SPLIT \
+ ( \
+ 0, \
+ VMD_DETAIL_IS_BEGIN_PARENS_CAT \
+ ( \
+ ) \
+ ) \
+/**/
+
+#else
+
+
+#define BOOST_VMD_IS_BEGIN_PARENS(...) \
+ VMD_DETAIL_IS_EMPTY_SPLIT \
+ ( \
+ 0, \
+ VMD_DETAIL_IS_EMPTY_CAT \
+ ( \
+ ) \
+ ) \
+/**/
+
+#endif /* BOOST_VMD_MSVC */
+#endif /* BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC */
#endif /* VMD_IS_TUPLE_BEGIN_HPP */

==============================================================================
+++ (empty file)
@@ -1,77 +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
-*/
-
-
-
-#if BOOST_VMD_MSVC
-
-
-#define BOOST_VMD_IS_BEGIN_PARENS(...) \
- VMD_DETAIL_IS_BEGIN_PARENS_SPLIT \
- ( \
- 0, \
- VMD_DETAIL_IS_BEGIN_PARENS_CAT \
- ( \
- ) \
- ) \
-/**/
-
-#else
-
-
-/** \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, \
- VMD_DETAIL_IS_EMPTY_CAT \
- ( \
- ) \
- ) \
-/**/
-
-#endif /* BOOST_VMD_MSVC */
-#endif /* BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC */
-#endif /* VMD_IS_TUPLE_BEGIN_COMMON_HPP */

==============================================================================
@@ -5,13 +5,82 @@

-#if BOOST_VMD_PPLIB
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_IS_EMPTY(...)
+
+ \brief Tests whether its input is empty or not.
+
+ The macro checks to see if the input is empty or not.
+ It returns 1 if the input is empty, else returns 0.
+
+ The macro is a variadic macro taking any input and works through variadic macro support.
+
+ The macro is not perfect, and can not be so. The problem
+ area is if the input to be checked is a function-like
+ macro name, in which case either a compiler error can result
+ or a false result can occur.
+
+ 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 input is empty, 0 if it is not
+
+ It is recommended to append BOOST_PP_EMPTY() to whatever input
+ is being tested in order to avoid possible warning messages
+ from some compilers about no parameters being passed to the macro
+ when the input is truly empty.
+
+*/
+
+#if BOOST_VMD_MSVC
+
+#define BOOST_VMD_IS_EMPTY(...) \
+ VMD_DETAIL_IS_EMPTY_IIF \
+ ( \
+ BOOST_VMD_IS_BEGIN_PARENS(__VA_ARGS__) \
+ ) \
+ ( \
+ VMD_DETAIL_IS_EMPTY_GEN_ZERO, \
+ BOOST_VMD_IS_BEGIN_PARENS \
+ ) \
+ (VMD_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ ()) \
+/**/
+
#else
-#endif /* BOOST_VMD_PPLIB */

+#define BOOST_VMD_IS_EMPTY(...) \
+ VMD_DETAIL_IS_EMPTY_IIF \
+ ( \
+ BOOST_VMD_IS_BEGIN_PARENS \
+ ( \
+ __VA_ARGS__ \
+ ) \
+ ) \
+ ( \
+ 0, \
+ BOOST_VMD_IS_BEGIN_PARENS \
+ ( \
+ VMD_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ () \
+ ) \
+ ) \
+/**/

+#endif /* BOOST_VMD_MSVC */
+#endif /* BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC */
#endif /* VMD_IS_EMPTY_HPP */

==============================================================================
+++ (empty file)
@@ -1,61 +0,0 @@
-#if !defined(VMD_IS_EMPTY_NATIVE_HPP)
-#define VMD_IS_EMPTY_NATIVE_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-
-
-
-/** \brief Tests whether its input is empty or not.
-
- The macro checks to see if the input is empty or not.
- It returns 1 if the input is empty, else returns 0.
-
- The macro is a variadic macro taking any input and works through variadic macro support.
-
- The macro is not perfect, and can not be so. The problem
- area is if the input to be checked is a function-like
- macro name, in which case either a compiler error can result
- or a false result can occur.
-
- 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 input is empty, 0 if it is not
-
- It is recommended to append BOOST_PP_EMPTY() to whatever input
- is being tested in order to avoid possible warning messages
- from some compilers about no parameters being passed to the macro
- when the input is truly empty.
-
-*/
-#define BOOST_VMD_IS_EMPTY(...) \
- VMD_DETAIL_IS_EMPTY_IIF \
- ( \
- BOOST_VMD_IS_BEGIN_PARENS(__VA_ARGS__) \
- ) \
- ( \
- VMD_DETAIL_IS_EMPTY_GEN_ZERO, \
- BOOST_VMD_IS_BEGIN_PARENS \
- ) \
- (VMD_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ ()) \
-/**/
-
-#endif /* BOOST_VMD_VARIADICS && BOOST_VMD_MSVC */
-#endif /* VMD_IS_EMPTY_NATIVE_HPP */

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

+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/facilities/identity.hpp>
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \brief Removes the set of parens from the start of a parameter if it has any.
+
+ param = a macro parameter.
+
+ returns = the parameter with the beginning set of parens removed.
+ If the parameter has no beginning set of parameters, the
+ parameter is returned as is. If there are further sets of
+ parens after the beginning set of parameters, they are not
+ removed.
+
+*/
+# define BOOST_VMD_REMOVE_PARENS(param) \
+ BOOST_PP_IIF \
+ ( \
+ BOOST_VMD_IS_BEGIN_PARENS(param), \
+ VMD_DETAIL_REMOVE_PARENS, \
+ BOOST_PP_IDENTITY \
+ ) \
+ (param)() \
+/**/

+
#endif /* VMD_REMOVE_PARENS_HPP */

==============================================================================
+++ (empty file)
@@ -1,45 +0,0 @@
-#if !defined(VMD_REMOVE_PARENS_COMMON_HPP)
-#define VMD_REMOVE_PARENS_COMMON_HPP
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-
-
-#include <boost/preprocessor/control/iif.hpp>
-#include <boost/preprocessor/facilities/identity.hpp>
-
-/** \brief Removes the set of parens from the start of a parameter if it has any.
-
- param = a macro parameter.
-
- returns = the parameter with the beginning set of parens removed.
- If the parameter has no beginning set of parameters, the
- parameter is returned as is. If there are further sets of
- parens after the beginning set of parameters, they are not
- removed.
-
-*/
-# define BOOST_VMD_REMOVE_PARENS(param) \
- BOOST_PP_IIF \
- ( \
- BOOST_VMD_IS_BEGIN_PARENS(param), \
- VMD_DETAIL_REMOVE_PARENS, \
- BOOST_PP_IDENTITY \
- ) \
- (param)() \
-/**/
-
-
-#endif /* VMD_REMOVE_PARENS_COMMON_HPP */

==============================================================================
@@ -5,6 +5,79 @@

+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_PP_ARRAY_TO_DATA(array)
+
+ \brief Expands to variadic macro data whose arguments are the same as an array's elements.
+
+ array = a Boost PP library array data type.
+
+ returns = variadic macro data whose arguments are the same as the
+ elements of an array 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.
+
+*/
+
+/** \def BOOST_VMD_PP_LIST_TO_DATA(list)
+
+ \brief Expands to variadic macro data whose arguments are the same as a list's elements.
+
+ list = a Boost PP library list data type.
+
+ returns = variadic macro data whose arguments are the same as the
+ elements of a list 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.
+
+*/
+
+/** \def BOOST_VMD_PP_SEQ_TO_DATA(seq)
+
+ \brief Expands to variadic macro data whose arguments are the same as a sequence's elements.
+
+ seq = a Boost PP library sequence data type.
+
+ returns = variadic macro data whose arguments are the same as the
+ elements of a sequence 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.
+
+*/
+
+/** \def BOOST_VMD_PP_TUPLE_TO_DATA(tuple)
+
+ \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.
+
+*/
+
#if BOOST_VMD_PPLIB
#else

==============================================================================
@@ -1,15 +1,6 @@
#if !defined(VMD_TO_DATA_NATIVE_HPP)
#define VMD_TO_DATA_NATIVE_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-

@@ -19,70 +10,18 @@
#include <boost/preprocessor/seq/to_tuple.hpp>

-/** \brief Expands to variadic macro data whose arguments are the same as an array's elements.
-
- array = a Boost PP library array data type.
-
- returns = variadic macro data whose arguments are the same as the
- elements of an array 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_ARRAY_TO_DATA(array) \
BOOST_VMD_PP_TUPLE_TO_DATA(BOOST_PP_ARRAY_DATA(array)) \
/**/

-/** \brief Expands to variadic macro data whose arguments are the same as a list's elements.
-
- list = a Boost PP library list data type.
-
- returns = variadic macro data whose arguments are the same as the
- elements of a list 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_LIST_TO_DATA(list) \
BOOST_VMD_PP_TUPLE_TO_DATA(BOOST_PP_LIST_TO_TUPLE(list)) \
/**/

-/** \brief Expands to variadic macro data whose arguments are the same as a sequence's elements.
-
- seq = a Boost PP library sequence data type.
-
- returns = variadic macro data whose arguments are the same as the
- elements of a sequence 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_SEQ_TO_DATA(seq) \
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) \
/**/

==============================================================================
@@ -1,15 +1,6 @@
#if !defined(VMD_TO_DATA_PPLIB_HPP)
#define VMD_TO_DATA_PPLIB_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-

@@ -19,70 +10,18 @@
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/tuple/enum.hpp>

-/** \brief Expands to variadic macro data whose arguments are the same as an array's elements.
-
- array = a Boost PP library array data type.
-
- returns = variadic macro data whose arguments are the same as the
- elements of an array 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_ARRAY_TO_DATA(array) \
BOOST_PP_ARRAY_ENUM(array) \
/**/

-/** \brief Expands to variadic macro data whose arguments are the same as a list's elements.
-
- list = a Boost PP library list data type.
-
- returns = variadic macro data whose arguments are the same as the
- elements of a list 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_LIST_TO_DATA(list) \
BOOST_PP_LIST_ENUM(list) \
/**/

-/** \brief Expands to variadic macro data whose arguments are the same as a sequence's elements.
-
- seq = a Boost PP library sequence data type.
-
- returns = variadic macro data whose arguments are the same as the
- elements of a sequence 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_SEQ_TO_DATA(seq) \
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) \
/**/

==============================================================================
@@ -5,6 +5,139 @@

+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/** \def BOOST_VMD_PP_TUPLE_SIZE(tuple)
+
+ \brief Expands to the number of elements in a tuple.
+
+ tuple = a Boost PP library tuple data type.
+
+ returns = the number of elements in the tuple,
+ commonly referred to as the tuple size.
+
+ In the Boost PP library there is no way to calculate
+ the size of a tuple, so that the size must be known
+ in order to be used by Boost PP library tuple macros.
+ With variadic macros the size of a tuple can be
+ calculated from the tuple itself.
+
+*/
+
+/** \def BOOST_VMD_PP_TUPLE_ELEM(n,tuple)
+
+ \brief Expands to a particular tuple element.
+
+ n = number of the tuple element.
+ The number starts from 0 to the size of
+ the tuple - 1.
+
+ tuple = a Boost PP library tuple data type.
+
+ returns = the particular tuple element as specified
+ by n.
+
+ In the Boost PP library there is no way to calculate
+ the size of a tuple, so that the size must be known
+ in order to be used by Boost PP library tuple macros.
+ With variadic macros the size of a tuple can be
+ calculated from the tuple itself.
+
+ Therefore this macro is a replacement for the BOOST_PP_TUPLE_ELEM
+ macro without the necessity of having to pass a size.
+
+*/
+
+/** \def BOOST_VMD_PP_TUPLE_REM_CTOR(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.
+
+ returns = a series of comma-separated tokens equivalent to removing the parentheses from a tuple.
+
+ This result is actually equivalent to the form of variadic macro data
+ and can be used as an alternative to BOOST_VMD_PP_TUPLE_TO_DATA to convert
+ the tuple to variadic macro data.
+
+ In the Boost PP library there is no way to calculate
+ the size of a tuple, so that the size must be known
+ in order to be used by Boost PP library tuple macros.
+ With variadic macros the size of a tuple can be
+ calculated from the tuple itself.
+
+ Therefore this macro is a replacement for the BOOST_PP_TUPLE_REM_CTOR
+ macro without the necessity of having to pass a size.
+
+*/
+
+/** \def BOOST_VMD_PP_TUPLE_REVERSE(tuple)
+
+ \brief Expands to a tuple whose elements are in reversed order.
+
+ tuple = a Boost PP library tuple data type.
+
+ returns = a tuple whose elements are in reversed order
+ from the original tuple.
+
+ In the Boost PP library there is no way to calculate
+ the size of a tuple, so that the size must be known
+ in order to be used by Boost PP library tuple macros.
+ With variadic macros the size of a tuple can be
+ calculated from the tuple itself.
+
+ Therefore this macro is a replacement for the BOOST_PP_TUPLE_REVERSE
+ macro without the necessity of having to pass a size.
+
+*/
+
+/** \def BOOST_VMD_PP_TUPLE_TO_LIST(tuple)
+
+ \brief Expands to a list whose elements are the same as a tuple.
+
+ tuple = a Boost PP library tuple data type.
+
+ returns = a list whose elements are the same as the tuple
+ that is inputted.
+
+ In the Boost PP library there is no way to calculate
+ the size of a tuple, so that the size must be known
+ in order to be used by Boost PP library tuple macros.
+ With variadic macros the size of a tuple can be
+ calculated from the tuple itself.
+
+ Therefore this macro is a replacement for the BOOST_PP_TUPLE_TO_LIST
+ macro without the necessity of having to pass a size.
+
+*/
+
+/** \def BOOST_VMD_PP_TUPLE_TO_SEQ(tuple)
+
+ \brief Expands to a sequence whose elements are the same as a tuple.
+
+ tuple = a Boost PP library tuple data type.
+
+ returns = a sequence whose elements are the same as the tuple
+ that is inputted.
+
+ In the Boost PP library there is no way to calculate
+ the size of a tuple, so that the size must be known
+ in order to be used by Boost PP library tuple macros.
+ With variadic macros the size of a tuple can be
+ calculated from the tuple itself.
+
+ Therefore this macro is a replacement for the BOOST_PP_TUPLE_TO_SEQ
+ macro without the necessity of having to pass a size.
+
+*/
+
#if BOOST_VMD_PPLIB
#else

==============================================================================
@@ -1,15 +1,6 @@
#if !defined(VMD_TUPLE_NATIVE_HPP)
#define VMD_TUPLE_NATIVE_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-

@@ -22,178 +13,38 @@

#endif

-/** \brief Expands to the number of elements in a tuple.
-
- tuple = a Boost PP library tuple data type.
-
- returns = the number of elements in the tuple,
- commonly referred to as the tuple size.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
-*/
#define BOOST_VMD_PP_TUPLE_SIZE(tuple) \
VMD_DETAIL_PP_TUPLE_SIZE(tuple) \
/**/

-/** \brief Expands to a particular tuple element.
-
- n = number of the tuple element.
- The number starts from 0 to the size of
- the tuple - 1.
-
- tuple = a Boost PP library tuple data type.
-
- returns = the particular tuple element as specified
- by n.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_ELEM
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_ELEM(n,tuple) \
VMD_DETAIL_PP_TUPLE_ELEM(BOOST_VMD_PP_TUPLE_SIZE(tuple),n,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.
-
- returns = a series of comma-separated tokens equivalent to removing the parentheses from a tuple.
-
- This result is actually equivalent to the form of variadic macro data
- and can be used as an alternative to BOOST_VMD_PP_TUPLE_TO_DATA to convert
- the tuple to variadic macro data.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_REM_CTOR
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_REM_CTOR(tuple) \
VMD_DETAIL_PP_TUPLE_REM_CTOR(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

-/** \brief Expands to a tuple whose elements are in reversed order.
-
- tuple = a Boost PP library tuple data type.
-
- returns = a tuple whose elements are in reversed order
- from the original tuple.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_REVERSE
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_REVERSE(tuple) \
VMD_DETAIL_PP_TUPLE_REVERSE(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

#if BOOST_VMD_MSVC

-/** \brief Expands to a list whose elements are the same as a tuple.
-
- tuple = a Boost PP library tuple data type.
-
- returns = a list whose elements are the same as the tuple
- that is inputted.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_TO_LIST
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_TO_LIST(tuple) \
VMD_DETAIL_PP_TUPLE_VC_TO_LIST(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

-/** \brief Expands to a sequence whose elements are the same as a tuple.
-
- tuple = a Boost PP library tuple data type.
-
- returns = a sequence whose elements are the same as the tuple
- that is inputted.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_TO_SEQ
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_TO_SEQ(tuple) \
VMD_DETAIL_PP_TUPLE_VC_TO_SEQ(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

#else

-/** \brief Expands to a list whose elements are the same as a tuple.
-
- tuple = a Boost PP library tuple data type.
-
- returns = a list whose elements are the same as the tuple
- that is inputted.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_TO_LIST
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_TO_LIST(tuple) \
VMD_DETAIL_PP_TUPLE_TO_LIST(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

-/** \brief Expands to a sequence whose elements are the same as a tuple.
-
- tuple = a Boost PP library tuple data type.
-
- returns = a sequence whose elements are the same as the tuple
- that is inputted.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_TO_SEQ
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_TO_SEQ(tuple) \
VMD_DETAIL_PP_TUPLE_TO_SEQ(BOOST_VMD_PP_TUPLE_SIZE(tuple),tuple) \
/**/

==============================================================================
@@ -1,15 +1,6 @@
#if !defined(VMD_TUPLE_PPLIB_HPP)
#define VMD_TUPLE_PPLIB_HPP

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-

@@ -21,132 +12,26 @@
#include <boost/preprocessor/tuple/to_list.hpp>
#include <boost/preprocessor/tuple/to_seq.hpp>

-/** \brief Expands to the number of elements in a tuple.
-
- tuple = a Boost PP library tuple data type.
-
- returns = the number of elements in the tuple,
- commonly referred to as the tuple size.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
-*/
#define BOOST_VMD_PP_TUPLE_SIZE(tuple) \
BOOST_PP_TUPLE_SIZE(tuple) \
/**/

-/** \brief Expands to a particular tuple element.
-
- n = number of the tuple element.
- The number starts from 0 to the size of
- the tuple - 1.
-
- tuple = a Boost PP library tuple data type.
-
- returns = the particular tuple element as specified
- by n.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_ELEM
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_ELEM(n,tuple) \
BOOST_PP_TUPLE_ELEM(n,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.
-
- returns = a series of comma-separated tokens equivalent to removing the parentheses from a tuple.
-
- This result is actually equivalent to the form of variadic macro data
- and can be used as an alternative to BOOST_VMD_PP_TUPLE_TO_DATA to convert
- the tuple to variadic macro data.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_REM_CTOR
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_REM_CTOR(tuple) \
BOOST_PP_TUPLE_REM_CTOR(tuple) \
/**/

-/** \brief Expands to a tuple whose elements are in reversed order.
-
- tuple = a Boost PP library tuple data type.
-
- returns = a tuple whose elements are in reversed order
- from the original tuple.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_REVERSE
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_REVERSE(tuple) \
BOOST_PP_TUPLE_REVERSE(tuple) \
/**/

-/** \brief Expands to a list whose elements are the same as a tuple.
-
- tuple = a Boost PP library tuple data type.
-
- returns = a list whose elements are the same as the tuple
- that is inputted.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_TO_LIST
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_TO_LIST(tuple) \
BOOST_PP_TUPLE_TO_LIST(tuple) \
/**/

-/** \brief Expands to a sequence whose elements are the same as a tuple.
-
- tuple = a Boost PP library tuple data type.
-
- returns = a sequence whose elements are the same as the tuple
- that is inputted.
-
- In the Boost PP library there is no way to calculate
- the size of a tuple, so that the size must be known
- in order to be used by Boost PP library tuple macros.
- With variadic macros the size of a tuple can be
- calculated from the tuple itself.
-
- Therefore this macro is a replacement for the BOOST_PP_TUPLE_TO_SEQ
- macro without the necessity of having to pass a size.
-
-*/
#define BOOST_VMD_PP_TUPLE_TO_SEQ(tuple) \
BOOST_PP_TUPLE_TO_SEQ(tuple) \
/**/

==============================================================================
@@ -1,10 +1,10 @@

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

doxygen vmd_reference
:
- $(here)/../../../boost/variadic_macro_data/vmd_to_data_native.hpp -$(here)/../../../boost/variadic_macro_data/vmd_data_native.hpp
- $(here)/../../../boost/variadic_macro_data/vmd_tuple_native.hpp -$(here)/../../../boost/variadic_macro_data/vmd_is_empty_common.hpp
- $(here)/../../../boost/variadic_macro_data/vmd_is_begin_parens_common.hpp -$(here)/../../../boost/variadic_macro_data/vmd_remove_parens_common.hpp
- $(here)/../../../boost/variadic_macro_data/vmd_assert_is_array_common.hpp -$(here)/../../../boost/variadic_macro_data/vmd_assert_is_list_common.hpp
- $(here)/../../../boost/variadic_macro_data/vmd_assert_is_seq_common.hpp -$(here)/../../../boost/variadic_macro_data/vmd_assert_is_tuple_common.hpp
+ $(here)/../../../boost/variadic_macro_data/vmd_to_data.hpp +$(here)/../../../boost/variadic_macro_data/vmd_data.hpp
+ $(here)/../../../boost/variadic_macro_data/vmd_tuple.hpp +$(here)/../../../boost/variadic_macro_data/vmd_is_empty.hpp
+ $(here)/../../../boost/variadic_macro_data/vmd_is_begin_parens.hpp +$(here)/../../../boost/variadic_macro_data/vmd_remove_parens.hpp
+ $(here)/../../../boost/variadic_macro_data/vmd_assert_is_array.hpp +$(here)/../../../boost/variadic_macro_data/vmd_assert_is_list.hpp
+ $(here)/../../../boost/variadic_macro_data/vmd_assert_is_seq.hpp +$(here)/../../../boost/variadic_macro_data/vmd_assert_is_tuple.hpp
:
<doxygen:param>PROJECT_NAME="VMD"
<doxygen:param>PROJECT_NUMBER=1

==============================================================================
@@ -119,8 +119,8 @@
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
+for the VMD and developed my own slightly different code to work with the Visual C++
+compiler since Paul's code would not work as is because of deficiencies in the
Visual C++ preprocessor.

The macro is called [macroref BOOST_VMD_IS_EMPTY] and will return 1 if its input
@@ -143,15 +143,15 @@
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.
+of one or more single element tuples. Once again I have taken
+the implementation from code which Paul Mensonides posted and have
+changed it slightly for Visual C++.

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.
+returns 0. The macro is a variadic macro which make take
+any input.

There may be other tokens after the set of parameters that begins the
input, and the macro still returns 1.