[Boost-commit] svn:boost r73768 - in sandbox/variadic_macro_data: boost/variadic_macro_data libs/variadic_macro_data/doc

Subject: [Boost-commit] svn:boost r73768 - in sandbox/variadic_macro_data: boost/variadic_macro_data libs/variadic_macro_data/doc
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:
Simplify header files.
Removed:
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_Is_empty_common.hpp
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_Is_empty_pplib.hpp
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_list_common.hpp
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_seq_common.hpp
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_tuple_common.hpp
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_begin_parens_common.hpp
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_empty_native.hpp
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_remove_parens_common.hpp
Text files modified: 
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array.hpp        |    50 +++++++++++++                           
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_common.hpp |    50 -------------                           
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_native.hpp |    47 ------------                            
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_pplib.hpp  |    47 ------------                            
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_list.hpp         |    72 +++++++++++++++++++                     
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_seq.hpp          |    72 +++++++++++++++++++                     
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_tuple.hpp        |   102 +++++++++++++++++++++++++++             
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data.hpp                   |    95 +++++++++++++++++++++++++               
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data_native.hpp            |    78 --------------------                    
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data_pplib.hpp             |    77 --------------------                    
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_begin_parens.hpp        |    73 +++++++++++++++++++                     
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_empty.hpp               |    81 ++++++++++++++++++++-                   
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_remove_parens.hpp          |    36 +++++++++                               
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data.hpp                |    73 +++++++++++++++++++                     
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data_native.hpp         |    61 ----------------                        
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data_pplib.hpp          |    61 ----------------                        
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple.hpp                  |   133 +++++++++++++++++++++++++++++++++++     
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple_native.hpp           |   149 ----------------------------------------
   sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple_pplib.hpp            |   115 ------------------------------          
   sandbox/variadic_macro_data/libs/variadic_macro_data/doc/index.idx                   |    14 +-                                      
   sandbox/variadic_macro_data/libs/variadic_macro_data/doc/jamfile.v2                  |    20 ++--                                    
   sandbox/variadic_macro_data/libs/variadic_macro_data/doc/vmd_detail.qbk              |    14 +-                                      
   22 files changed, 799 insertions(+), 721 deletions(-)

Deleted: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_Is_empty_common.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_Is_empty_common.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
+++ (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
-*/
-
-#include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
-
-#if BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC
-
-#include <boost/variadic_macro_data/vmd_is_begin_parens.hpp>
-#include <boost/variadic_macro_data/detail/vmd_detail_is_empty.hpp>
-
-/** \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++.
-    
-    .... = variadic input
-
-    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 */

Deleted: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_Is_empty_pplib.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_Is_empty_pplib.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
+++ (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
-*/
-
-#include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
-
-#if BOOST_VMD_VARIADICS && BOOST_VMD_MSVC
-
-#include <boost/variadic_macro_data/vmd_is_begin_parens.hpp>
-#include <boost/variadic_macro_data/detail/vmd_detail_is_empty.hpp>
-
-/** \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++.
-    
-    .... = variadic input
-
-    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 */

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,6 +5,56 @@
 
 #if BOOST_VMD_VARIADICS
 
+/*
+
+  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
 #include <boost/variadic_macro_data/vmd_assert_is_array_pplib.hpp>
 #else

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_common.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_common.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_common.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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.
-    
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_native.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_native.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_native.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS && BOOST_VMD_ASSERT_DATA && !BOOST_VMD_MSVC
@@ -22,44 +13,6 @@
 #include <boost/variadic_macro_data/detail/vmd_detail_assert_is_array.hpp>
 #include <boost/variadic_macro_data/detail/vmd_detail.hpp>
 
-/** \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 \

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_pplib.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_pplib.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_array_pplib.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS && BOOST_VMD_ASSERT_DATA && !BOOST_VMD_MSVC
@@ -22,44 +13,6 @@
 #include <boost/variadic_macro_data/detail/vmd_detail_assert_is_array.hpp>
 #include <boost/variadic_macro_data/detail/vmd_detail.hpp>
 
-/** \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 \

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_list.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_list.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_list.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,7 +5,77 @@
 
 #if BOOST_VMD_VARIADICS
 
-#include <boost/variadic_macro_data/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>
+#include <boost/variadic_macro_data/detail/vmd_detail_assert_is_list.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 /* BOOST_VMD_VARIADICS */
 #endif /* VMD_ASSERT_IS_LIST_HPP */

Deleted: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_list_common.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_list_common.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
+++ (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.
-    
-*/
-
-#include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
-
-#if BOOST_VMD_VARIADICS
-
-#if !BOOST_VMD_ASSERT_DATA
-
-#define BOOST_VMD_ASSERT_IS_LIST(list)
-
-#else
-
-#include <boost/preprocessor/control/while.hpp>
-#include <boost/variadic_macro_data/detail/vmd_detail_assert_is_list.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 /* BOOST_VMD_VARIADICS */
-#endif /* VMD_ASSERT_IS_LIST_COMMON_HPP */

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_seq.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_seq.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_seq.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,7 +5,77 @@
 
 #if BOOST_VMD_VARIADICS
 
-#include <boost/variadic_macro_data/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>
+#include <boost/variadic_macro_data/detail/vmd_detail_assert_is_seq.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 /* BOOST_VMD_VARIADICS */
 #endif /* VMD_ASSERT_IS_SEQ_HPP */

Deleted: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_seq_common.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_seq_common.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
+++ (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.
-    
-*/
-
-#include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
-
-#if BOOST_VMD_VARIADICS
-
-#if !BOOST_VMD_ASSERT_DATA
-
-#define BOOST_VMD_ASSERT_IS_SEQ(seq)
-
-#else
-
-#include <boost/preprocessor/control/while.hpp>
-#include <boost/variadic_macro_data/detail/vmd_detail_assert_is_seq.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 /* BOOST_VMD_VARIADICS */
-#endif /* VMD_ASSERT_IS_SEQ_COMMON_HPP */

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_tuple.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_tuple.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_tuple.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,7 +5,107 @@
 
 #if BOOST_VMD_VARIADICS
 
-#include <boost/variadic_macro_data/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>
+#include <boost/variadic_macro_data/detail/vmd_detail.hpp>
+
+#endif
+
+#include <boost/variadic_macro_data/vmd_is_begin_parens.hpp>
+#include <boost/variadic_macro_data/detail/vmd_detail_assert_is_tuple.hpp>
+
+#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 /* BOOST_VMD_VARIADICS */
 #endif /* VMD_ASSERT_IS_TUPLE_HPP */

Deleted: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_tuple_common.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_assert_is_tuple_common.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
+++ (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.
-    
-*/
-
-#include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
-
-#if BOOST_VMD_VARIADICS
-
-#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>
-#include <boost/variadic_macro_data/detail/vmd_detail.hpp>
-
-#endif
-
-#include <boost/variadic_macro_data/vmd_is_begin_parens.hpp>
-#include <boost/variadic_macro_data/detail/vmd_detail_assert_is_tuple.hpp>
-
-#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 /* BOOST_VMD_VARIADICS */
-#endif /* VMD_ASSERT_IS_TUPLE_COMMON_HPP */

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,6 +5,101 @@
 
 #if BOOST_VMD_VARIADICS
 
+/*
+
+  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
 #include <boost/variadic_macro_data/vmd_data_pplib.hpp>
 #else

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data_native.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data_native.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data_native.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS
 
 #include <boost/variadic_macro_data/detail/vmd_detail_data.hpp>
 
-/** \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 /* BOOST_VMD_VARIADICS */
 #endif /* VMD_DATA_NATIVE_HPP */

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data_pplib.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data_pplib.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_data_pplib.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS
@@ -21,94 +12,26 @@
 #include <boost/preprocessor/variadic/to_seq.hpp>
 #include <boost/preprocessor/variadic/to_tuple.hpp>
 
-/** \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(...) \
   BOOST_PP_VARIADIC_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,...) \
   BOOST_PP_VARIADIC_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(...) \
   BOOST_PP_VARIADIC_TO_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(...) \
   BOOST_PP_VARIADIC_TO_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(...) \
   BOOST_PP_VARIADIC_TO_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(...) \
   BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
 /**/

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_begin_parens.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_begin_parens.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_begin_parens.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,7 +5,76 @@
 
 #if BOOST_VMD_VARIADICS
 
-#include <boost/variadic_macro_data/vmd_is_begin_parens_common.hpp>
+/*
 
-#endif /* BOOST_VMD_VARIADICS */
+  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.
+    
+    .... = variadic param(s)
+
+    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
+
+#include <boost/variadic_macro_data/detail/vmd_detail_is_begin_parens.hpp>
+
+#define BOOST_VMD_IS_BEGIN_PARENS(...) \
+    VMD_DETAIL_IS_BEGIN_PARENS_SPLIT \
+      ( \
+      0, \
+      VMD_DETAIL_IS_BEGIN_PARENS_CAT \
+        ( \
+        VMD_DETAIL_IS_BEGIN_PARENS_IS_VARIADIC_R_, \
+        VMD_DETAIL_IS_BEGIN_PARENS_IS_VARIADIC_C __VA_ARGS__ \
+        ) \
+      ) \
+/**/
+
+#else
+
+#include <boost/variadic_macro_data/detail/vmd_detail_is_empty.hpp>
+
+#define BOOST_VMD_IS_BEGIN_PARENS(...) \
+    VMD_DETAIL_IS_EMPTY_SPLIT \
+      ( \
+      0, \
+      VMD_DETAIL_IS_EMPTY_CAT \
+        ( \
+        VMD_DETAIL_IS_EMPTY_IS_VARIADIC_R_, \
+        VMD_DETAIL_IS_EMPTY_IS_VARIADIC_C __VA_ARGS__ \
+        ) \
+      ) \
+/**/
+
+#endif /* BOOST_VMD_MSVC */
+#endif /* BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC */
 #endif /* VMD_IS_TUPLE_BEGIN_HPP */

Deleted: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_begin_parens_common.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_begin_parens_common.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
+++ (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
-*/
-
-#include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
-
-#if BOOST_VMD_VARIADICS
-
-#if BOOST_VMD_MSVC
-
-#include <boost/variadic_macro_data/detail/vmd_detail_is_begin_parens.hpp>
-
-#define BOOST_VMD_IS_BEGIN_PARENS(...) \
-    VMD_DETAIL_IS_BEGIN_PARENS_SPLIT \
-      ( \
-      0, \
-      VMD_DETAIL_IS_BEGIN_PARENS_CAT \
-        ( \
-        VMD_DETAIL_IS_BEGIN_PARENS_IS_VARIADIC_R_, \
-        VMD_DETAIL_IS_BEGIN_PARENS_IS_VARIADIC_C __VA_ARGS__ \
-        ) \
-      ) \
-/**/
-
-#else
-
-#include <boost/variadic_macro_data/detail/vmd_detail_is_empty.hpp>
-
-/** \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.
-    
-    .... = variadic param(s)
-
-    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 \
-        ( \
-        VMD_DETAIL_IS_EMPTY_IS_VARIADIC_R_, \
-        VMD_DETAIL_IS_EMPTY_IS_VARIADIC_C __VA_ARGS__ \
-        ) \
-      ) \
-/**/
-
-#endif /* BOOST_VMD_MSVC */
-#endif /* BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC */
-#endif /* VMD_IS_TUPLE_BEGIN_COMMON_HPP */

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_empty.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_empty.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_empty.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,13 +5,82 @@
 
 #if BOOST_VMD_VARIADICS
 
-#if BOOST_VMD_PPLIB
-#include <boost/variadic_macro_data/vmd_is_empty_pplib.hpp>
+#include <boost/variadic_macro_data/vmd_is_begin_parens.hpp>
+#include <boost/variadic_macro_data/detail/vmd_detail_is_empty.hpp>
+
+/*
+
+  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++.
+    
+    .... = variadic input
+
+    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
-#include <boost/variadic_macro_data/vmd_is_empty_native.hpp>
-#endif /* BOOST_VMD_PPLIB */
 
-#include <boost/variadic_macro_data/vmd_is_empty_common.hpp>
+#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 */
+#endif /* BOOST_VMD_MSVC */
+#endif /* BOOST_VMD_VARIADICS && !BOOST_VMD_MSVC */
 #endif /* VMD_IS_EMPTY_HPP */

Deleted: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_empty_native.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_is_empty_native.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
+++ (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
-*/
-
-#include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
-
-#if BOOST_VMD_VARIADICS && BOOST_VMD_MSVC
-
-#include <boost/variadic_macro_data/vmd_is_begin_parens.hpp>
-#include <boost/variadic_macro_data/detail/vmd_detail_is_empty.hpp>
-
-/** \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++.
-    
-    .... = variadic input
-
-    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 */

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_remove_parens.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_remove_parens.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_remove_parens.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,7 +5,41 @@
 
 #if BOOST_VMD_VARIADICS
 
-#include <boost/variadic_macro_data/vmd_remove_parens_common.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/facilities/identity.hpp>
+#include <boost/variadic_macro_data/vmd_is_begin_parens.hpp>
+#include <boost/variadic_macro_data/detail/vmd_detail_remove_parens.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 /* BOOST_VMD_VARIADICS */
+
 #endif /* VMD_REMOVE_PARENS_HPP */

Deleted: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_remove_parens_common.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_remove_parens_common.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
+++ (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/variadic_macro_data/detail/vmd_detail_setup.hpp>
-
-#if BOOST_VMD_VARIADICS
-
-#include <boost/preprocessor/control/iif.hpp>
-#include <boost/preprocessor/facilities/identity.hpp>
-#include <boost/variadic_macro_data/vmd_is_begin_parens.hpp>
-#include <boost/variadic_macro_data/detail/vmd_detail_remove_parens.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 /* BOOST_VMD_VARIADICS */
-
-#endif /* VMD_REMOVE_PARENS_COMMON_HPP */

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,6 +5,79 @@
 
 #if BOOST_VMD_VARIADICS
 
+/*
+
+  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
 #include <boost/variadic_macro_data/vmd_to_data_pplib.hpp>
 #else

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data_native.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data_native.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data_native.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS
@@ -19,70 +10,18 @@
 #include <boost/preprocessor/seq/to_tuple.hpp>
 #include <boost/variadic_macro_data/detail/vmd_detail_to_data.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) \
 /**/

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data_pplib.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data_pplib.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_to_data_pplib.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS
@@ -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) \
 /**/

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -5,6 +5,139 @@
 
 #if BOOST_VMD_VARIADICS
 
+/*
+
+  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
 #include <boost/variadic_macro_data/vmd_tuple_pplib.hpp>
 #else

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple_native.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple_native.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple_native.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS
@@ -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) \
 /**/

Modified: sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple_pplib.hpp
==============================================================================
--- sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple_pplib.hpp	(original)
+++ sandbox/variadic_macro_data/boost/variadic_macro_data/vmd_tuple_pplib.hpp	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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
-*/
-
 #include <boost/variadic_macro_data/detail/vmd_detail_setup.hpp>
 
 #if BOOST_VMD_VARIADICS
@@ -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) \
 /**/

Modified: sandbox/variadic_macro_data/libs/variadic_macro_data/doc/index.idx
==============================================================================
--- sandbox/variadic_macro_data/libs/variadic_macro_data/doc/index.idx	(original)
+++ sandbox/variadic_macro_data/libs/variadic_macro_data/doc/index.idx	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -1,10 +1,10 @@
 !scan boost/variadic_macro_data/vmd_to_data_native.hpp
 !scan boost/variadic_macro_data/vmd_data_native.hpp
 !scan boost/variadic_macro_data/vmd_tuple_native.hpp
-!scan boost/variadic_macro_data/vmd_is_empty_common.hpp
-!scan boost/variadic_macro_data/vmd_is_begin_parens_common.hpp
-!scan boost/variadic_macro_data/vmd_remove_parens_common.hpp
-!scan boost/variadic_macro_data/vmd_assert_is_array_common.hpp
-!scan boost/variadic_macro_data/vmd_assert_is_list_common.hpp
-!scan boost/variadic_macro_data/vmd_assert_is_seq_common.hpp
-!scan boost/variadic_macro_data/vmd_assert_is_tuple_common.hpp
+!scan boost/variadic_macro_data/vmd_is_empty.hpp
+!scan boost/variadic_macro_data/vmd_is_begin_parens.hpp
+!scan boost/variadic_macro_data/vmd_remove_parens.hpp
+!scan boost/variadic_macro_data/vmd_assert_is_array_native.hpp
+!scan boost/variadic_macro_data/vmd_assert_is_list.hpp
+!scan boost/variadic_macro_data/vmd_assert_is_seq.hpp
+!scan boost/variadic_macro_data/vmd_assert_is_tuple.hpp

Modified: sandbox/variadic_macro_data/libs/variadic_macro_data/doc/jamfile.v2
==============================================================================
--- sandbox/variadic_macro_data/libs/variadic_macro_data/doc/jamfile.v2	(original)
+++ sandbox/variadic_macro_data/libs/variadic_macro_data/doc/jamfile.v2	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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

Modified: sandbox/variadic_macro_data/libs/variadic_macro_data/doc/vmd_detail.qbk
==============================================================================
--- sandbox/variadic_macro_data/libs/variadic_macro_data/doc/vmd_detail.qbk	(original)
+++ sandbox/variadic_macro_data/libs/variadic_macro_data/doc/vmd_detail.qbk	2011-08-14 21:09:42 EDT (Sun, 14 Aug 2011)
@@ -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.