Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r68905 - in sandbox/tti: boost/tti boost/tti/detail libs/tti/test
From: eldiener_at_[hidden]
Date: 2011-02-14 22:01:54

Next message: joel_at_[hidden]: "[Boost-commit] svn:boost r68906 - in trunk/libs/spirit/test: . qi"
Previous message: dnljms_at_[hidden]: "[Boost-commit] svn:boost r68902 - branches/doc-tools-docs/tools/quickbook/doc"

Author: eldiener
Date: 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
New Revision: 68905
URL: http://svn.boost.org/trac/boost/changeset/68905

Log:
Split library into individual header files for the different nested types.
Added:
   sandbox/tti/boost/tti/detail/dmember.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dmember_data.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dmember_function.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dmember_type.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dnotype.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dstatic_member.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dstatic_member_function.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dtemplate_params.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dtself.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dtype.hpp (contents, props changed)
   sandbox/tti/boost/tti/detail/dvm_template_params.hpp (contents, props changed)
   sandbox/tti/boost/tti/member.hpp (contents, props changed)
   sandbox/tti/boost/tti/member_data.hpp (contents, props changed)
   sandbox/tti/boost/tti/member_function.hpp (contents, props changed)
   sandbox/tti/boost/tti/member_type.hpp (contents, props changed)
   sandbox/tti/boost/tti/static_member.hpp (contents, props changed)
   sandbox/tti/boost/tti/static_member_function.hpp (contents, props changed)
   sandbox/tti/boost/tti/template.hpp (contents, props changed)
   sandbox/tti/boost/tti/template_params.hpp (contents, props changed)
   sandbox/tti/boost/tti/type.hpp (contents, props changed)
   sandbox/tti/boost/tti/vm_template_params.hpp (contents, props changed)
Removed:
   sandbox/tti/boost/tti/detail/dtti_vm.hpp
Text files modified:
   sandbox/tti/boost/tti/mf_template_params.hpp | 10
   sandbox/tti/boost/tti/tti.hpp | 1487 ---------------------------------------
   sandbox/tti/boost/tti/tti_vm.hpp | 146 ---
   sandbox/tti/libs/tti/test/test_has_member.hpp | 2
   sandbox/tti/libs/tti/test/test_has_member_data.hpp | 2
   sandbox/tti/libs/tti/test/test_has_member_function.hpp | 2
   sandbox/tti/libs/tti/test/test_has_static_member.hpp | 2
   sandbox/tti/libs/tti/test/test_has_static_member_function.hpp | 2
   sandbox/tti/libs/tti/test/test_has_template.hpp | 2
   sandbox/tti/libs/tti/test/test_has_template_check_params.hpp | 2
   sandbox/tti/libs/tti/test/test_has_type.hpp | 2
   sandbox/tti/libs/tti/test/test_has_type_check_typedef.hpp | 2
   sandbox/tti/libs/tti/test/test_member_type.hpp | 2
   sandbox/tti/libs/tti/test/test_mf_has_member_data.hpp | 3
   sandbox/tti/libs/tti/test/test_mf_has_member_function.hpp | 3
   sandbox/tti/libs/tti/test/test_mf_has_static_data.hpp | 2
   sandbox/tti/libs/tti/test/test_mf_has_static_function.hpp | 3
   sandbox/tti/libs/tti/test/test_mf_has_template.hpp | 3
   sandbox/tti/libs/tti/test/test_mf_has_template_check_params.hpp | 3
   sandbox/tti/libs/tti/test/test_mf_has_type.hpp | 3
   sandbox/tti/libs/tti/test/test_mf_has_type_check_typedef.hpp | 3
   sandbox/tti/libs/tti/test/test_mf_member_type.hpp | 2
   sandbox/tti/libs/tti/test/test_vm_has_template_check_params.hpp | 2
   sandbox/tti/libs/tti/test/test_vm_mf_has_template_check_params.hpp | 4
   24 files changed, 44 insertions(+), 1650 deletions(-)

Added: sandbox/tti/boost/tti/detail/dmember.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dmember.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,382 @@
+#if !defined(TTI_DETAIL_MEMBER_HPP)
+#define TTI_DETAIL_MEMBER_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/quote.hpp>
+#include <boost/function_types/is_member_object_pointer.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+
+#if defined(BOOST_MSVC)
+
+#if defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_MEMBER(trait,name) \
+ template<class T> \
+ struct trait \
+ { \
+ template<class> \
+ struct class_of; \
+ \
+ template<class R,class C> \
+ struct class_of<R C::*> \
+ { \
+ typedef C type; \
+ }; \
+ \
+ template<class> \
+ struct return_of; \
+ \
+ template<class R,class C> \
+ struct return_of<R C::*> \
+ { \
+ typedef R type; \
+ }; \
+ \
+ template<bool,typename U> \
+ struct menable_if; \
+ \
+ template<typename U> \
+ struct menable_if<true,U> \
+ { \
+ typedef U type; \
+ }; \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::yes_type check2(V U::*); \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::no_type check2(U); \
+ \
+ template<class F> \
+ struct class_type \
+ { \
+ typedef typename \
+ boost::remove_const \
+ < \
+ typename \
+ boost::mpl::at \
+ < \
+ typename \
+ boost::function_types::parameter_types \
+ < \
+ F, \
+ boost::mpl::quote1 \
+ < \
+ boost::mpl::identity \
+ > \
+ > \
+ ::type, \
+ boost::mpl::int_<0> \
+ >::type \
+ >::type \
+ type; \
+ }; \
+ \
+ template<T> \
+ struct helper; \
+ \
+ template<typename U,typename V> \
+ static typename \
+ menable_if \
+ < \
+ sizeof(check2<U,V>(&U::name))==sizeof(::boost::type_traits::yes_type), \
+ ::boost::type_traits::yes_type \
+ > \
+ ::type \
+ has_matching_member(int); \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::no_type has_matching_member(...); \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ template<class F> \
+ struct ttc_md \
+ { \
+ typedef boost::mpl::bool_<sizeof(has_matching_member<typename class_of<F>::type,typename return_of<F>::type>(0))==sizeof(::boost::type_traits::yes_type)> type; \
+ }; \
+ \
+ template<class F> \
+ struct ttc_mf \
+ { \
+ typedef boost::mpl::bool_<sizeof(check<typename class_type<F>::type>(0))==sizeof(::boost::type_traits::yes_type)> type; \
+ }; \
+ \
+ template<class F> \
+ struct type_to_check \
+ { \
+ typedef typename \
+ boost::mpl::eval_if \
+ < \
+ boost::function_types::is_member_object_pointer<F>, \
+ ttc_md<F>, \
+ ttc_mf<F> \
+ >::type \
+ type; \
+ }; \
+ \
+ typedef typename type_to_check<T>::type type; \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ \
+ }; \
+/**/
+
+#else // !defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_MEMBER(trait,name) \
+ template<class T> \
+ struct trait \
+ { \
+ template<class> \
+ struct class_of; \
+ \
+ template<class R,class C> \
+ struct class_of<R C::*> \
+ { \
+ typedef C type; \
+ }; \
+ \
+ template<class> \
+ struct return_of; \
+ \
+ template<class R,class C> \
+ struct return_of<R C::*> \
+ { \
+ typedef R type; \
+ }; \
+ \
+ template<bool,typename U> \
+ struct menable_if; \
+ \
+ template<typename U> \
+ struct menable_if<true,U> \
+ { \
+ typedef U type; \
+ }; \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::yes_type check2(V U::*); \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::no_type check2(U); \
+ \
+ template<class F> \
+ struct class_type \
+ { \
+ typedef typename \
+ boost::remove_const \
+ < \
+ typename \
+ boost::mpl::at \
+ < \
+ typename \
+ boost::function_types::parameter_types \
+ < \
+ F, \
+ boost::mpl::quote1 \
+ < \
+ boost::mpl::identity \
+ > \
+ > \
+ ::type, \
+ boost::mpl::int_<0> \
+ >::type \
+ >::type \
+ type; \
+ }; \
+ \
+ template<T> \
+ struct helper; \
+ \
+ template<typename U,typename V> \
+ static typename \
+ menable_if \
+ < \
+ sizeof(check2<U,V>(&U::name))==sizeof(::boost::type_traits::yes_type), \
+ ::boost::type_traits::yes_type \
+ > \
+ ::type \
+ has_matching_member(int); \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::no_type has_matching_member(...); \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ template<class F> \
+ struct ttc_md \
+ { \
+ typedef boost::mpl::bool_<sizeof(has_matching_member<typename class_of<F>::type,typename return_of<F>::type>(0))==sizeof(::boost::type_traits::yes_type)> type; \
+ }; \
+ \
+ template<class F> \
+ struct ttc_mf \
+ { \
+ typedef boost::mpl::bool_<sizeof(check<typename class_type<F>::type>(nullptr))==sizeof(::boost::type_traits::yes_type)> type; \
+ }; \
+ \
+ template<class F> \
+ struct type_to_check \
+ { \
+ typedef typename \
+ boost::mpl::eval_if \
+ < \
+ boost::function_types::is_member_object_pointer<F>, \
+ ttc_md<F>, \
+ ttc_mf<F> \
+ >::type \
+ type; \
+ }; \
+ \
+ typedef typename type_to_check<T>::type type; \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ \
+ }; \
+/**/
+
+#endif // defined(BOOST_NO_NULLPTR)
+
+#else // !defined(BOOST_MSVC)
+
+#if defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_MEMBER(trait,name) \
+ template<class T> \
+ struct trait \
+ { \
+ template<class> \
+ struct class_of; \
+ \
+ template<class R,class C> \
+ struct class_of<R C::*> \
+ { \
+ typedef C type; \
+ }; \
+ \
+ template<class F> \
+ struct class_type \
+ { \
+ typedef typename \
+ boost::mpl::eval_if \
+ < \
+ boost::function_types::is_member_object_pointer<F>, \
+ class_of<F>, \
+ boost::remove_const \
+ < \
+ typename \
+ boost::mpl::at \
+ < \
+ typename \
+ boost::function_types::parameter_types \
+ < \
+ F, \
+ boost::mpl::quote1 \
+ < \
+ boost::mpl::identity \
+ > \
+ > \
+ ::type, \
+ boost::mpl::int_<0> \
+ >::type \
+ > \
+ >::type \
+ type; \
+ }; \
+ \
+ template<T> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<typename class_type<T>::type>(0))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+/**/
+
+#else // !defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_MEMBER(trait,name) \
+ template<class T> \
+ struct trait \
+ { \
+ template<class> \
+ struct class_of; \
+ \
+ template<class R,class C> \
+ struct class_of<R C::*> \
+ { \
+ typedef C type; \
+ }; \
+ \
+ template<class F> \
+ struct class_type \
+ { \
+ typedef typename \
+ boost::mpl::eval_if \
+ < \
+ boost::function_types::is_member_object_pointer<F>, \
+ class_of<F>, \
+ boost::remove_const \
+ < \
+ typename \
+ boost::mpl::at \
+ < \
+ typename \
+ boost::function_types::parameter_types \
+ < \
+ F, \
+ boost::mpl::quote1 \
+ < \
+ boost::mpl::identity \
+ > \
+ > \
+ ::type, \
+ boost::mpl::int_<0> \
+ >::type \
+ > \
+ >::type \
+ type; \
+ }; \
+ \
+ template<T> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<typename class_type<T>::type>(nullptr))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+/**/
+
+#endif // defined(BOOST_NO_NULLPTR)
+
+#endif // defined(BOOST_MSVC)
+
+#endif // TTI_DETAIL_MEMBER_HPP

Added: sandbox/tti/boost/tti/detail/dmember_data.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dmember_data.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,94 @@
+#if !defined(TTI_DETAIL_MEMBER_DATA_HPP)
+#define TTI_DETAIL_MEMBER_DATA_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+#if !defined(BOOST_MSVC)
+#include "dmember_function.hpp"
+#endif
+
+#if defined(BOOST_MSVC)
+
+#define TTI_DETAIL_TRAIT_HAS_MEMBER_DATA(trait,name) \
+ template<class T,class C> \
+ struct trait \
+ { \
+ template<class> \
+ struct return_of; \
+ \
+ template<class R,class C> \
+ struct return_of<R C::*> \
+ { \
+ typedef R type; \
+ }; \
+ \
+ template<bool,typename U> \
+ struct menable_if; \
+ \
+ template<typename U> \
+ struct menable_if<true,U> \
+ { \
+ typedef U type; \
+ }; \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::yes_type check2(V U::*); \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::no_type check2(U); \
+ \
+ template<typename U,typename V> \
+ static typename \
+ menable_if \
+ < \
+ sizeof(check2<U,V>(&U::name))==sizeof(::boost::type_traits::yes_type), \
+ ::boost::type_traits::yes_type \
+ > \
+ ::type \
+ has_matching_member(int); \
+ \
+ template<typename U,typename V> \
+ static ::boost::type_traits::no_type has_matching_member(...); \
+ \
+ template<class U,class V> \
+ struct ttc_md \
+ { \
+ typedef boost::mpl::bool_<sizeof(has_matching_member<V,typename return_of::type>(0))==sizeof(::boost::type_traits::yes_type)> type; \
+ }; \
+ \
+ typedef typename ttc_md<T,C>::type type; \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ \
+ }; \
+/**/
+
+#else // !defined(BOOST_MSVC)
+
+#define TTI_DETAIL_TRAIT_HAS_MEMBER_DATA(trait,name) \
+ TTI_DETAIL_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
+/**/
+
+#endif // defined(BOOST_MSVC)
+
+namespace boost
+ {
+ namespace tti
+ {
+ namespace detail
+ {
+ template
+ <
+ class T,
+ class R
+ >
+ struct ptmd
+ {
+ typedef R T::* type;
+ };
+ }
+ }
+ }
+
+#endif // TTI_DETAIL_MEMBER_DATA_HPP

Added: sandbox/tti/boost/tti/detail/dmember_function.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dmember_function.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,77 @@
+#if !defined(TTI_DETAIL_MEMBER_FUNCTION_HPP)
+#define TTI_DETAIL_MEMBER_FUNCTION_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/function_types/member_function_pointer.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+
+#if defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
+ template<class T,class C> \
+ struct trait \
+ { \
+ template<T> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<C>(0))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+/**/
+
+#else // !defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
+ template<class T,class C> \
+ struct trait \
+ { \
+ template<T> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<C>(nullptr))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+/**/
+
+#endif // defined(BOOST_NO_NULLPTR)
+
+namespace boost
+ {
+ namespace tti
+ {
+ namespace detail
+ {
+ template
+ <
+ class T,
+ class R,
+ class FS,
+ class TAG
+ >
+ struct ptmf_seq
+ {
+ typedef typename boost::mpl::push_front<FS,T>::type tfs1;
+ typedef typename boost::mpl::push_front<tfs1,R>::type tfs2;
+ typedef typename boost::function_types::member_function_pointer<tfs2,TAG>::type type;
+ };
+ }
+ }
+ }
+
+#endif // TTI_DETAIL_MEMBER_FUNCTION_HPP

Added: sandbox/tti/boost/tti/detail/dmember_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dmember_type.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,32 @@
+#if !defined(TTI_DETAIL_MEMBER_TYPE_HPP)
+#define TTI_DETAIL_MEMBER_TYPE_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/has_xxx.hpp>
+
+#define TTI_DETAIL_TRAIT_HAS_TYPE_MEMBER_TYPE(trait,name) \
+namespace mpl \
+ { \
+ BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, false) \
+ } \
+template<class T> \
+struct trait \
+ { \
+ typedef typename mpl::trait<T>::type type; \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ }; \
+/**/
+
+#define TTI_DETAIL_TRAIT_MEMBER_TYPE(trait,name) \
+namespace member_type \
+ { \
+ template<class T> \
+ struct trait \
+ { \
+ typedef typename T::name type; \
+ }; \
+ } \
+/**/
+
+#endif // TTI_DETAIL_MEMBER_TYPE_HPP

Added: sandbox/tti/boost/tti/detail/dnotype.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dnotype.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,17 @@
+#if !defined(TTI_DETAIL_NOTYPE_HPP)
+#define TTI_DETAIL_NOTYPE_HPP
+
+namespace boost
+ {
+ namespace tti
+ {
+ namespace detail
+ {
+ struct notype
+ {
+ };
+ }
+ }
+ }
+
+#endif // TTI_DETAIL_NOTYPE_HPP

Added: sandbox/tti/boost/tti/detail/dstatic_member.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dstatic_member.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,96 @@
+#if !defined(TTI_DETAIL_STATIC_MEMBER_HPP)
+#define TTI_DETAIL_STATIC_MEMBER_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+
+#if defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER(trait,name) \
+ template<class T,class Type> \
+ struct trait \
+ { \
+ template<Type *> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<T>(0))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+/**/
+
+#define TTI_DETAIL_MTFC_TRAIT_HAS_STATIC_MEMBER(trait,name) \
+ struct trait \
+ { \
+ template<class T,class Type> \
+ struct apply \
+ { \
+ template<Type *> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<T>(0))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+ }; \
+/**/
+
+#else // !defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER(trait,name) \
+ template<class T,class Type> \
+ struct trait \
+ { \
+ template<Type *> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<T>(nullptr))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+/**/
+
+#define TTI_DETAIL_MTFC_TRAIT_HAS_STATIC_MEMBER(trait,name) \
+ struct trait \
+ { \
+ template<class T,class Type> \
+ struct apply \
+ { \
+ template<Type *> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<T>(nullptr))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+ }; \
+/**/
+
+#endif // defined(BOOST_NO_NULLPTR)
+
+#endif // TTI_DETAIL_STATIC_MEMBER_HPP

Added: sandbox/tti/boost/tti/detail/dstatic_member_function.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dstatic_member_function.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,75 @@
+#if !defined(TTI_DETAIL_STATIC_MEMBER_FUNCTION_HPP)
+#define TTI_DETAIL_STATIC_MEMBER_FUNCTION_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/function_types/function_type.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+
+#if defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
+ template<class T,class Type> \
+ struct trait \
+ { \
+ template<Type *> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<T>(0))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+/**/
+
+#else // !defined(BOOST_NO_NULLPTR)
+
+#define TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
+ template<class T,class Type> \
+ struct trait \
+ { \
+ template<Type *> \
+ struct helper; \
+ \
+ template<class U> \
+ static ::boost::type_traits::yes_type check(helper<&U::name> *); \
+ \
+ template<class U> \
+ static ::boost::type_traits::no_type check(...); \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=sizeof(check<T>(nullptr))==sizeof(::boost::type_traits::yes_type)); \
+ \
+ typedef boost::mpl::bool_<value> type; \
+ }; \
+/**/
+
+#endif // defined(BOOST_NO_NULLPTR)
+
+namespace boost
+ {
+ namespace tti
+ {
+ namespace detail
+ {
+ template
+ <
+ class R,
+ class FS,
+ class TAG
+ >
+ struct tfunction_seq
+ {
+ typedef typename boost::mpl::push_front<FS,R>::type ftseq;
+ typedef typename boost::function_types::function_type<ftseq,TAG>::type type;
+ };
+ }
+ }
+ }
+
+#endif // TTI_DETAIL_STATIC_MEMBER_FUNCTION_HPP

Added: sandbox/tti/boost/tti/detail/dtemplate_params.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dtemplate_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,265 @@
+#if !defined(TTI_DETAIL_TEMPLATE_PARAMS_HPP)
+#define TTI_DETAIL_TEMPLATE_PARAMS_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/array/elem.hpp>
+#include <boost/preprocessor/array/size.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+
+#define TTI_DETAIL_TEMPLATE_PARAMETERS(z,n,args) \
+BOOST_PP_ARRAY_ELEM(BOOST_PP_ADD(4,n),args) \
+/**/
+
+#define TTI_DETAIL_HAS_MEMBER_IMPLEMENTATION(args,introspect_macro) \
+ template \
+ < \
+ typename T, \
+ typename fallback_ \
+ = boost::mpl::bool_< BOOST_PP_ARRAY_ELEM(3, args) > \
+ > \
+ class BOOST_PP_ARRAY_ELEM(0, args) \
+ { \
+ introspect_macro(args) \
+ public: \
+ static const bool value \
+ = BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::value; \
+ typedef typename BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \
+ < \
+ T \
+ >::type type; \
+ }; \
+/**/
+
+#define TTI_DETAIL_MTFC_HAS_MEMBER_IMPLEMENTATION(args,introspect_macro) \
+ struct BOOST_PP_ARRAY_ELEM(0, args) \
+ { \
+ template \
+ < \
+ typename T, \
+ typename fallback_ \
+ = boost::mpl::bool_< BOOST_PP_ARRAY_ELEM(3, args) > \
+ > \
+ class apply \
+ { \
+ introspect_macro(args) \
+ public: \
+ static const bool value \
+ = BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::value; \
+ typedef typename BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \
+ < \
+ T \
+ >::type type; \
+ }; \
+ }; \
+/**/
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+
+#define TTI_DETAIL_HAS_MEMBER_MULTI_SUBSTITUTE(z,n,args) \
+ template \
+ < \
+ template \
+ < \
+ BOOST_PP_ENUM_ ## z \
+ ( \
+ BOOST_PP_SUB \
+ ( \
+ BOOST_PP_ARRAY_SIZE(args), \
+ 4 \
+ ), \
+ TTI_DETAIL_TEMPLATE_PARAMETERS, \
+ args \
+ ) \
+ > \
+ class V \
+ > \
+ struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) \
+ { \
+ }; \
+/**/
+
+#define TTI_DETAIL_HAS_MEMBER_SUBSTITUTE(args) \
+ BOOST_PP_REPEAT \
+ ( \
+ BOOST_PP_ARRAY_ELEM(2, args), \
+ TTI_DETAIL_HAS_MEMBER_MULTI_SUBSTITUTE, \
+ args \
+ ) \
+/**/
+
+#define TTI_DETAIL_HAS_MEMBER_INTROSPECT(args) \
+ template< typename U > \
+ struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \
+ { \
+ TTI_DETAIL_HAS_MEMBER_SUBSTITUTE(args) \
+ BOOST_MPL_HAS_MEMBER_REJECT(args, BOOST_PP_NIL) \
+ BOOST_MPL_HAS_MEMBER_ACCEPT(args, BOOST_PP_NIL) \
+ BOOST_STATIC_CONSTANT \
+ ( \
+ bool, value = BOOST_MPL_HAS_MEMBER_TEST(args) \
+ ); \
+ typedef boost::mpl::bool_< value > type; \
+ }; \
+/**/
+
+#define TTI_DETAIL_HAS_MEMBER_WITH_FUNCTION_SFINAE(args) \
+ TTI_DETAIL_HAS_MEMBER_IMPLEMENTATION \
+ ( \
+ args, \
+ TTI_DETAIL_HAS_MEMBER_INTROSPECT \
+ ) \
+/**/
+
+#else // !!BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+
+#define TTI_DETAIL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE(z,n,args) \
+ template \
+ < \
+ template \
+ < \
+ BOOST_PP_ENUM_ ## z \
+ ( \
+ BOOST_PP_SUB \
+ ( \
+ BOOST_PP_ARRAY_SIZE(args), \
+ 4 \
+ ), \
+ TTI_DETAIL_TEMPLATE_PARAMETERS, \
+ args \
+ ) \
+ > \
+ class U \
+ > \
+ struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE \
+ ( \
+ args, \
+ n \
+ ) \
+ { \
+ typedef \
+ BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args) \
+ type; \
+ }; \
+/**/
+
+#define TTI_DETAIL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE(args) \
+ typedef void \
+ BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_TAG_NAME(args); \
+ BOOST_PP_REPEAT \
+ ( \
+ BOOST_PP_ARRAY_ELEM(2, args), \
+ TTI_DETAIL_HAS_MEMBER_MULTI_SUBSTITUTE_WITH_TEMPLATE_SFINAE, \
+ args \
+ ) \
+/**/
+
+#define TTI_DETAIL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE(args) \
+ BOOST_MPL_HAS_MEMBER_REJECT_WITH_TEMPLATE_SFINAE(args,BOOST_PP_NIL) \
+ BOOST_MPL_HAS_MEMBER_ACCEPT_WITH_TEMPLATE_SFINAE(args,BOOST_PP_NIL) \
+ template< typename U > \
+ struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) \
+ : BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) { \
+ }; \
+/**/
+
+#define TTI_DETAIL_HAS_MEMBER_WITH_TEMPLATE_SFINAE(args) \
+ TTI_DETAIL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE \
+ ( \
+ args \
+ ) \
+ TTI_DETAIL_HAS_MEMBER_IMPLEMENTATION \
+ ( \
+ args, \
+ TTI_DETAIL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE \
+ ) \
+/**/
+
+#define TTI_DETAIL_MTFC_HAS_MEMBER_WITH_TEMPLATE_SFINAE(args) \
+ TTI_DETAIL_HAS_MEMBER_SUBSTITUTE_WITH_TEMPLATE_SFINAE \
+ ( \
+ args \
+ ) \
+ TTI_DETAIL_MTFC_HAS_MEMBER_IMPLEMENTATION \
+ ( \
+ args, \
+ TTI_DETAIL_HAS_MEMBER_INTROSPECT_WITH_TEMPLATE_SFINAE \
+ ) \
+/**/
+
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+#else // !!defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+
+#define TTI_DETAIL_SAME(trait,name) \
+ BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF \
+ ( \
+ trait, \
+ name, \
+ false \
+ ) \
+/**/
+
+#endif // !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+
+#if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+
+#define TTI_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+ TTI_DETAIL_HAS_MEMBER_WITH_FUNCTION_SFINAE \
+ ( \
+ ( BOOST_PP_ADD(BOOST_PP_SEQ_SIZE(tpSeq),4), ( trait, name, 1, false, BOOST_PP_SEQ_ENUM(tpSeq) ) ) \
+ ) \
+/**/
+
+#define TTI_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+ struct trait \
+ { \
+ TTI_DETAIL_HAS_MEMBER_WITH_FUNCTION_SFINAE \
+ ( \
+ ( BOOST_PP_ADD(BOOST_PP_SEQ_SIZE(tpSeq),4), ( apply, name, 1, false, BOOST_PP_SEQ_ENUM(tpSeq) ) ) \
+ ) \
+ }; \
+/**/
+
+#else // !!BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+
+#define TTI_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+ TTI_DETAIL_HAS_MEMBER_WITH_TEMPLATE_SFINAE \
+ ( \
+ ( BOOST_PP_ADD(BOOST_PP_SEQ_SIZE(tpSeq),4), ( trait, name, 1, false, BOOST_PP_SEQ_ENUM(tpSeq) ) ) \
+ ) \
+/**/
+
+#define TTI_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+ TTI_DETAIL_MTFC_HAS_MEMBER_WITH_TEMPLATE_SFINAE \
+ ( \
+ ( BOOST_PP_ADD(BOOST_PP_SEQ_SIZE(tpSeq),4), ( trait, name, 1, false, BOOST_PP_SEQ_ENUM(tpSeq) ) ) \
+ ) \
+/**/
+
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+#else // !!defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+
+#define TTI_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+ TTI_DETAIL_SAME(trait,name) \
+/**/
+
+#define TTI_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+ struct trait \
+ { \
+ TTI_DETAIL_SAME(apply,name) \
+ }; \
+/**/
+
+#endif // !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+
+#endif // TTI_DETAIL_TEMPLATE_PARAMS_HPP

Added: sandbox/tti/boost/tti/detail/dtself.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dtself.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,18 @@
+#if !defined(TTI_DETAIL_TSELF_HPP)
+#define TTI_DETAIL_TSELF_HPP
+
+namespace boost
+ {
+ namespace tti
+ {
+ namespace detail
+ {
+ template <class T>
+ struct tself : T
+ {
+ };
+ }
+ }
+ }
+
+#endif // TTI_DETAIL_TSELF_HPP

Deleted: sandbox/tti/boost/tti/detail/dtti_vm.hpp
==============================================================================
--- sandbox/tti/boost/tti/detail/dtti_vm.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-#if !defined(TT_INTROSPECTION_VM_DETAIL_HPP)
-#define TT_INTROSPECTION_VM_DETAIL_HPP
-
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_VARIADIC_MACROS)
-
-#include <boost/mpl/has_xxx.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/variadic_macro_data/vmd.hpp>
-#include "dtti.hpp"
-
-#if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
-#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
-
-#define TTI_VM_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
- TTI_DETAIL_HAS_MEMBER_WITH_FUNCTION_SFINAE \
- ( \
- ( BOOST_PP_ADD(BOOST_VMD_DATA_SIZE(__VA_ARGS__),4), ( trait, name, 1, false, __VA_ARGS__ ) ) \
- ) \
-/**/
-
-#define TTI_VM_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
- struct trait \
- { \
- TTI_DETAIL_HAS_MEMBER_WITH_FUNCTION_SFINAE \
- ( \
- ( BOOST_PP_ADD(BOOST_VMD_DATA_SIZE(__VA_ARGS__),4), ( apply, name, 1, false, __VA_ARGS__ ) ) \
- ) \
- }; \
-/**/
-
-#else // !!BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
-
-#define TTI_VM_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
- TTI_DETAIL_HAS_MEMBER_WITH_TEMPLATE_SFINAE \
- ( \
- ( BOOST_PP_ADD(BOOST_VMD_DATA_SIZE(__VA_ARGS__),4), ( trait, name, 1, false, __VA_ARGS__ ) ) \
- ) \
-/**/
-
-#define TTI_VM_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
- TTI_DETAIL_MTFC_HAS_MEMBER_WITH_TEMPLATE_SFINAE \
- ( \
- ( BOOST_PP_ADD(BOOST_VMD_DATA_SIZE(__VA_ARGS__),4), ( trait, name, 1, false, __VA_ARGS__ ) ) \
- ) \
-/**/
-
-#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
-#else // !!defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
-
-#define TTI_VM_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
- TTI_DETAIL_SAME(trait,name) \
-/**/
-
-#define TTI_VM_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
- struct trait \
- { \
- TTI_DETAIL_SAME(apply,name) \
- }; \
-/**/
-
-#endif // !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
-#endif // !defined(BOOST_NO_VARIADIC_MACROS)
-#endif // TT_INTROSPECTION_VM_DETAIL_HPP

Added: sandbox/tti/boost/tti/detail/dtype.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dtype.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,45 @@
+#if !defined(TTI_DETAIL_TYPE_HPP)
+#define TTI_DETAIL_TYPE_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include "dnotype.hpp"
+
+#define TTI_DETAIL_TRAIT_HAS_TYPE(trait,name) \
+namespace mpl \
+ { \
+ BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, false) \
+ } \
+template<class T,class U,class B> \
+struct trait \
+ { \
+ typedef typename \
+ boost::mpl::eval_if \
+ < \
+ boost::is_same<typename T::name,U>, \
+ boost::mpl::true_, \
+ boost::mpl::false_ \
+ >::type \
+ type; \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ }; \
+\
+template<class T,class U> \
+struct trait<T,U,boost::mpl::false_::type> \
+ { \
+ typedef boost::mpl::false_::type type; \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ }; \
+\
+template<class T> \
+struct trait<T,notype,boost::mpl::true_::type> \
+ { \
+ typedef boost::mpl::true_::type type; \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ }; \
+/**/
+
+#endif // TTI_DETAIL_TYPE_HPP

Added: sandbox/tti/boost/tti/detail/dvm_template_params.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/detail/dvm_template_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,67 @@
+#if !defined(TTI_VM_DETAIL_TEMPLATE_PARAMS_HPP)
+#define TTI_VM_DETAIL_TEMPLATE_PARAMS_HPP
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_VARIADIC_MACROS)
+
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/variadic_macro_data/vmd.hpp>
+#include "dtemplate_params.hpp"
+
+#if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+
+#define TTI_VM_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
+ TTI_DETAIL_HAS_MEMBER_WITH_FUNCTION_SFINAE \
+ ( \
+ ( BOOST_PP_ADD(BOOST_VMD_DATA_SIZE(__VA_ARGS__),4), ( trait, name, 1, false, __VA_ARGS__ ) ) \
+ ) \
+/**/
+
+#define TTI_VM_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
+ struct trait \
+ { \
+ TTI_DETAIL_HAS_MEMBER_WITH_FUNCTION_SFINAE \
+ ( \
+ ( BOOST_PP_ADD(BOOST_VMD_DATA_SIZE(__VA_ARGS__),4), ( apply, name, 1, false, __VA_ARGS__ ) ) \
+ ) \
+ }; \
+/**/
+
+#else // !!BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+
+#define TTI_VM_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
+ TTI_DETAIL_HAS_MEMBER_WITH_TEMPLATE_SFINAE \
+ ( \
+ ( BOOST_PP_ADD(BOOST_VMD_DATA_SIZE(__VA_ARGS__),4), ( trait, name, 1, false, __VA_ARGS__ ) ) \
+ ) \
+/**/
+
+#define TTI_VM_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
+ TTI_DETAIL_MTFC_HAS_MEMBER_WITH_TEMPLATE_SFINAE \
+ ( \
+ ( BOOST_PP_ADD(BOOST_VMD_DATA_SIZE(__VA_ARGS__),4), ( trait, name, 1, false, __VA_ARGS__ ) ) \
+ ) \
+/**/
+
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
+#else // !!defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+
+#define TTI_VM_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
+ TTI_DETAIL_SAME(trait,name) \
+/**/
+
+#define TTI_VM_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
+ struct trait \
+ { \
+ TTI_DETAIL_SAME(apply,name) \
+ }; \
+/**/
+
+#endif // !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+#endif // !defined(BOOST_NO_VARIADIC_MACROS)
+#endif // TTI_VM_DETAIL_TEMPLATE_PARAMS_HPP

Added: sandbox/tti/boost/tti/member.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/member.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,136 @@
+#if !defined(TTI_MEMBER_HPP)
+#define TTI_MEMBER_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include "detail/dmember.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether a member data or member function with a particular name and type exists.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction types and return:
+
+ T = the type, in the form of a member data pointer or member function pointer,
+ in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_TRAIT_HAS_MEMBER(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_MEMBER(trait,name) \
+ } \
+ template<class T> \
+ struct trait : \
+ detail::trait<T> \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether a member data or member function with a particular name and type exists.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the type, in the form of a member data pointer or member function pointer,
+ in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_HAS_MEMBER(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_MEMBER(trait,name) \
+ } \
+ struct trait \
+ { \
+ template<class T> \
+ struct apply : \
+ detail::trait<T> \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction which tests whether a member data or member function with a particular name and type exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::has_member_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the type, in the form of a member data pointer or member function pointer,
+ in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_HAS_MEMBER(name) \
+ BOOST_TTI_TRAIT_HAS_MEMBER \
+ ( \
+ BOOST_PP_CAT(has_member_,name), \
+ name \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether a member data or member function with a particular name and type exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_member_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the type, in the form of a member data pointer or member function pointer,
+ in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_HAS_MEMBER(name) \
+ BOOST_TTI_MTFC_TRAIT_HAS_MEMBER \
+ ( \
+ BOOST_PP_CAT(mtfc_has_member_,name), \
+ name \
+ ) \
+/**/
+
+#endif // TTI_MEMBER_HPP

Added: sandbox/tti/boost/tti/member_data.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/member_data.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,178 @@
+#if !defined(TTI_MEMBER_DATA_HPP)
+#define TTI_MEMBER_DATA_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include "detail/dmember_data.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether a member data with a particular name and type exists.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the type of the member data. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_TRAIT_HAS_MEMBER_DATA(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_MEMBER_DATA(trait,name) \
+ } \
+ template<class T,class R> \
+ struct trait : \
+ detail::trait<typename detail::ptmd<T,R>::type,typename boost::remove_const<T>::type> \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether a member data with a particular name and type exists.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the type of the member data. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_HAS_MEMBER_DATA(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_MEMBER_DATA(trait,name) \
+ } \
+ struct trait \
+ { \
+ template<class T,class R> \
+ struct apply : \
+ detail::trait<typename detail::ptmd<T,R>::type,typename boost::remove_const<T>::type> \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction which tests whether a member data with a particular name and type exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::has_member_data_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the type of the member data. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_HAS_MEMBER_DATA(name) \
+ BOOST_TTI_TRAIT_HAS_MEMBER_DATA \
+ ( \
+ BOOST_PP_CAT(has_member_data_,name), \
+ name \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether a member data with a particular name and type exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_member_data_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the type of the member data. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_HAS_MEMBER_DATA(name) \
+ BOOST_TTI_MTFC_TRAIT_HAS_MEMBER_DATA \
+ ( \
+ BOOST_PP_CAT(mtfc_has_member_data_,name), \
+ name \
+ ) \
+/**/
+
+namespace boost
+ {
+ namespace tti
+ {
+
+ /// A metafunction which checks whether a member data exists within an enclosing type.
+ /**
+
+ This metafunction takes its specific types as nullary metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasMemberData = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_MEMBER_DATA ( or TTI_TRAIT_HAS_MEMBER_DATA ) macro. 
+ The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_,_\>'.
+ You can also use the metafunction class generated by the TTI_MTFC_HAS_MEMBER_DATA ( or TTI_MTFC_TRAIT_HAS_MEMBER_DATA ) macro. 
+ T = the enclosing type as a nullary metafunction. 
+ R = the type of the member data as a nullary metafunction.
+
+ returns = 'value' is true if the member data exists within the enclosing type,
+ otherwise 'value' is false.
+
+ */
+ template
+ <
+ class HasMemberData,
+ class T,
+ class R
+ >
+ struct mf_has_member_data :
+ boost::mpl::apply
+ <
+ HasMemberData,
+ typename T::type,
+ typename R::type
+ >::type
+ {
+ };
+ }
+ }
+
+#endif // TTI_MEMBER_DATA_HPP

Added: sandbox/tti/boost/tti/member_function.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/member_function.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,198 @@
+#if !defined(TTI_MEMBER_FUNCTION_HPP)
+#define TTI_MEMBER_FUNCTION_HPP
+
+#include <boost/config.hpp>
+#include <boost/function_types/property_tags.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include "detail/dmember_function.hpp"
+#include "detail/dtself.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether a member function with a particular name and signature exists.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the return type of the member function. 
+ FS = an optional parameter which are the parameters of the member function as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
+ } \
+ template<class T,class R,class FS = boost::mpl::vector<>,class TAG = boost::function_types::null_tag> \
+ struct trait : \
+ detail::trait<typename detail::ptmf_seq<T,R,FS,TAG>::type,typename boost::remove_const<T>::type> \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether a member function with a particular name and signature exists.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the return type of the member function. 
+ FS = an optional parameter which are the parameters of the member function as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
+ } \
+ struct trait \
+ { \
+ template<class T,class R,class FS = boost::mpl::vector<>,class TAG = boost::function_types::null_tag> \
+ struct apply : \
+ detail::trait<typename detail::ptmf_seq<T,R,FS,TAG>::type,typename boost::remove_const<T>::type> \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction which tests whether a member function with a particular name and signature exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::has_member_function_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the return type of the member function. 
+ FS = an optional parameter which are the parameters of the member function as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_HAS_MEMBER_FUNCTION(name) \
+ BOOST_TTI_TRAIT_HAS_MEMBER_FUNCTION \
+ ( \
+ BOOST_PP_CAT(has_member_function_,name), \
+ name \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether a member function with a particular name and signature exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_member_function_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the return type of the member function. 
+ FS = an optional parameter which are the parameters of the member function as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_HAS_MEMBER_FUNCTION(name) \
+ BOOST_TTI_MTFC_TRAIT_HAS_MEMBER_FUNCTION \
+ ( \
+ BOOST_PP_CAT(mtfc_has_member_function_,name), \
+ name \
+ ) \
+/**/
+
+namespace boost
+ {
+ namespace tti
+ {
+
+ /// A metafunction which checks whether a member function exists within an enclosing type.
+ /**
+
+ This metafunction takes its specific types, except for the optional parameters, as nullary metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasMemberFunction = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_MEMBER_FUNCTION ( or TTI_TRAIT_HAS_MEMBER_FUNCTION ) macro. 
+ The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_,_\> ( or optionally 'metafunction\<_,_,_\> or ' 'metafunction\<_,_,_,_\> )'.
+ You can also use the metafunction class generated by the TTI_MTFC_HAS_MEMBER_FUNCTION ( or TTI_MTFC_TRAIT_HAS_MEMBER_FUNCTION ) macro. 
+ T = the enclosing type as a nullary metafunction. 
+ R = the return type of the member function as a nullary metafunction. 
+ FS = an optional parameter which is the parameters of the member function, each as a nullary metafunction, as a boost::mpl forward sequence. 
+ This parameter defaults to boost::mpl::vector<>. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
+ This parameter defaults to boost::function_types::null_tag.
+
+ returns = 'value' is true if the member function exists within the enclosing type,
+ otherwise 'value' is false.
+
+ */
+ template
+ <
+ class HasMemberFunction,
+ class T,
+ class R,
+ class FS = boost::mpl::vector<>,
+ class TAG = boost::function_types::null_tag
+ >
+ struct mf_has_member_function :
+ boost::mpl::apply
+ <
+ HasMemberFunction,
+ typename T::type,
+ typename R::type,
+ typename boost::mpl::transform<FS,detail::tself<boost::mpl::_1> >::type,
+ TAG
+ >::type
+ {
+ };
+ }
+ }
+
+#endif // TTI_MEMBER_FUNCTION_HPP

Added: sandbox/tti/boost/tti/member_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/member_type.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,272 @@
+#if !defined(TTI_MEMBER_TYPE_HPP)
+#define TTI_MEMBER_TYPE_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include "detail/dmember_type.hpp"
+#include "detail/dnotype.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction whose typedef 'type' is either the named type or an unspecified type.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner type.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type. 
+ returns = 'type' is the inner type of 'name' if the inner type exists
+ within the enclosing type, else 'type' is an unspecified type. 
+
+ The purpose of this macro is to encapsulate the 'name' type as the typedef 'type'
+ of a metafunction, but only if it exists within the enclosing type. This allows for
+ a lazy evaluation of inner type existence which can be used by other metafunctions
+ in this library.
+
+*/
+#define BOOST_TTI_TRAIT_MEMBER_TYPE(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_TYPE_MEMBER_TYPE(trait,name) \
+ TTI_DETAIL_TRAIT_MEMBER_TYPE(trait,name) \
+ } \
+ template<class T> \
+ struct trait : \
+ boost::mpl::eval_if \
+ < \
+ detail::trait<T>, \
+ detail::member_type::trait<T>, \
+ boost::mpl::identity<detail::notype> \
+ > \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class whose typedef 'type' is either the named type or an unspecified type.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner type.
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type. 
+ returns = 'type' is the inner type of 'name' if the inner type exists
+ within the enclosing type, else 'type' is an unspecified type. 
+
+ The purpose of this macro is to encapsulate the 'name' type as the typedef 'type'
+ of a metafunction class, but only if it exists within the enclosing type. This allows for
+ a lazy evaluation of inner type existence which can be used by other metafunctions
+ in this library.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_MEMBER_TYPE(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_TYPE_MEMBER_TYPE(trait,name) \
+ TTI_DETAIL_TRAIT_MEMBER_TYPE(trait,name) \
+ } \
+ struct trait \
+ { \
+ template<class T> \
+ struct apply : \
+ boost::mpl::eval_if \
+ < \
+ detail::trait<T>, \
+ detail::member_type::trait<T>, \
+ boost::mpl::identity<detail::notype> \
+ > \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction whose typedef 'type' is either the named type or an unspecified type.
+/**
+
+ name = the name of the inner type.
+
+ returns = a metafunction called "boost::tti::member_type_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type. 
+ returns = 'type' is the inner type of 'name' if the inner type exists
+ within the enclosing type, else 'type' is an unspecified type. 
+
+ The purpose of this macro is to encapsulate the 'name' type as the typedef 'type'
+ of a metafunction, but only if it exists within the enclosing type. This allows for
+ a lazy evaluation of inner type existence which can be used by other metafunctions
+ in this library.
+
+*/
+#define BOOST_TTI_MEMBER_TYPE(name) \
+ BOOST_TTI_TRAIT_MEMBER_TYPE \
+ ( \
+ BOOST_PP_CAT(member_type_,name), \
+ name \
+ ) \
+/**/
+
+/// Expands to a metafunction class whose typedef 'type' is either the named type or an unspecified type.
+/**
+
+ name = the name of the inner type.
+
+ returns = a metafunction class called "boost::tti::mtfc_member_type_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type. 
+ returns = 'type' is the inner type of 'name' if the inner type exists
+ within the enclosing type, else 'type' is an unspecified type. 
+
+ The purpose of this macro is to encapsulate the 'name' type as the typedef 'type'
+ of a metafunction class, but only if it exists within the enclosing type. This allows for
+ a lazy evaluation of inner type existence which can be used by other metafunctions
+ in this library.
+
+*/
+#define BOOST_TTI_MTFC_MEMBER_TYPE(name) \
+ BOOST_TTI_MTFC_TRAIT_MEMBER_TYPE \
+ ( \
+ BOOST_PP_CAT(mtfc_member_type_,name), \
+ name \
+ ) \
+/**/
+
+namespace boost
+ {
+ namespace tti
+ {
+
+ /// A metafunction which checks whether the member 'type' returned from invoking the macro metafunction generated by TTI_MEMBER_TYPE ( TTI_TRAIT_MEMBER_TYPE ) or from invoking boost::tti::mf_member_type is a valid type.
+ /**
+
+ The metafunction types and return:
+
+ T = returned inner 'type' from invoking the macro metafunction generated by TTI_MEMBER_TYPE ( TTI_TRAIT_MEMBER_TYPE ) or from invoking boost::tti::mf_member_type.
+
+ returns = 'value' is true if the type is valid, otherwise 'value' is false.
+
+ */
+ template
+ <
+ class T
+ >
+ struct valid_member_type :
+ boost::mpl::not_
+ <
+ boost::is_same
+ <
+ T,
+ detail::notype
+ >
+ >
+ {
+ };
+
+ /// A metafunction which checks whether the member 'type' returned from invoking the macro metafunction generated by TTI_MEMBER_TYPE ( TTI_TRAIT_MEMBER_TYPE ) or from invoking boost::tti::mf_member_type is a valid type.
+ /**
+
+ The metafunction types and return:
+
+ T = the nullary metafunction from invoking the macro metafunction generated by TTI_MEMBER_TYPE ( TTI_TRAIT_MEMBER_TYPE ) or from invoking boost::tti::mf_member_type.
+
+ returns = 'value' is true if the type is valid, otherwise 'value' is false.
+
+ */
+ template
+ <
+ class T
+ >
+ struct mf_valid_member_type :
+ boost::mpl::not_
+ <
+ boost::is_same
+ <
+ typename T::type,
+ detail::notype
+ >
+ >
+ {
+ };
+
+ /// A metafunction whose typedef 'type' is either the internal type or an unspecified type.
+ /**
+
+ This metafunction takes its enclosing type as nullary metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ MemberType = a Boost MPL lambda expression using the metafunction generated from the TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE ) macro. 
+ The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_\>'.
+ You can also use the metafunction class generated by the TTI_MTFC_MEMBER_TYPE ( or TTI_MTFC_TRAIT_MEMBER_TYPE ) macro. 
+ T = the enclosing type as a nullary metafunction.
+
+ returns = 'type' is the inner type of the 'name' in TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE )
+ if the inner type exists within the enclosing type,
+ else 'type' is an unspecified type. 
+ 'valid' is true if the inner type of 'name' exists
+ within the enclosing type, else 'valid' is false.
+
+ The purpose of this metafunction is to encapsulate the 'name' type
+ in TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE ) as the typedef 'type'
+ of a metafunction, but only if it exists within the enclosing type. This allows for
+ a lazy evaluation of inner type existence which can be used by other metafunctions
+ in this library.
+
+ Furthermore this metafunction allows the enclosing type to be return type from either the
+ metafunction generated from TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE ) or from this
+ metafunction itself.
+
+ */
+ template
+ <
+ class MemberType,
+ class T
+ >
+ struct mf_member_type :
+ boost::mpl::apply
+ <
+ MemberType,
+ typename T::type
+ >
+ {
+ };
+
+ }
+ }
+
+#endif // TTI_MEMBER_TYPE_HPP

Modified: sandbox/tti/boost/tti/mf_template_params.hpp
==============================================================================
--- sandbox/tti/boost/tti/mf_template_params.hpp (original)
+++ sandbox/tti/boost/tti/mf_template_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -1,10 +1,10 @@
-#if !defined(TT_INTROSPECTION_TEMPLATE_HPP)
-#define TT_INTROSPECTION_TEMPLATE_HPP
+#if !defined(TTI_MF_TEMPLATE_PARAMS_HPP)
+#define TTI_MF_TEMPLATE_PARAMS_HPP

#include <boost/config.hpp>
-#include <boost/mpl/identity.hpp>
#include <boost/mpl/apply.hpp>
-#include "detail/dtti.hpp"
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>

/*

@@ -53,4 +53,4 @@
 }
 }

-#endif // TT_INTROSPECTION_TEMPLATE_HPP
+#endif // TTI_MF_TEMPLATE_PARAMS_HPP

Added: sandbox/tti/boost/tti/static_member.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/static_member.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,191 @@
+#if !defined(TTI_STATIC_MEMBER_HPP)
+#define TTI_STATIC_MEMBER_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include "detail/dstatic_member.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether a static member data or a static member function with a particular name and type exists.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction types and return:
+
+ T = the enclosing type. 
+ Type = the static member data or static member function type,
+ in the form of a data or function type,
+ in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' exists within the enclosing type,
+ with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_TRAIT_HAS_STATIC_MEMBER(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER(trait,name) \
+ } \
+ template<class T,class Type> \
+ struct trait : \
+ detail::trait<T,Type> \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether a static member data or a static member function with a particular name and type exists.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type. 
+ Type = the static member data or static member function type,
+ in the form of a data or function type,
+ in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' exists within the enclosing type,
+ with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_HAS_STATIC_MEMBER(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_MTFC_TRAIT_HAS_STATIC_MEMBER(trait,name) \
+ } \
+ struct trait \
+ { \
+ template<class T,class Type> \
+ struct apply : \
+ detail::trait::apply<T,Type> \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+
+/// Expands to a metafunction which tests whether a static member data or a static member function with a particular name and type exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::has_static_member_name" where 'name' is the macro parameter. 
+
+ The metafunction types and return:
+
+ T = the enclosing type. 
+ Type = the static member data or static member function type,
+ in the form of a data or function type,
+ in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' exists within the enclosing type,
+ with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_HAS_STATIC_MEMBER(name) \
+ BOOST_TTI_TRAIT_HAS_STATIC_MEMBER \
+ ( \
+ BOOST_PP_CAT(has_static_member_,name), \
+ name \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether a static member data or a static member function with a particular name and type exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_static_member_name" where 'name' is the macro parameter. 
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type. 
+ Type = the static member data or static member function type,
+ in the form of a data or function type,
+ in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' exists within the enclosing type,
+ with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_HAS_STATIC_MEMBER(name) \
+ BOOST_TTI_MTFC_TRAIT_HAS_STATIC_MEMBER \
+ ( \
+ BOOST_PP_CAT(mtfc_has_static_member_,name), \
+ name \
+ ) \
+/**/
+
+namespace boost
+ {
+ namespace tti
+ {
+
+
+ /// A metafunction which checks whether a static member data exists within an enclosing type.
+ /**
+
+ This metafunction takes its specific types as nullary metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasStaticMember = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_STATIC_MEMBER ( or TTI_TRAIT_HAS_STATIC_MEMBER ) macro. 
+ The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_,_\>'.
+ You can also use the metafunction class generated by the TTI_MTFC_HAS_STATIC_MEMBER ( or TTI_MTFC_TRAIT_HAS_STATIC_MEMBER ) macro. 
+ T = the enclosing type as a nullary metafunction. 
+ R = the type of the static member data as a nullary metafunction.
+
+ returns = 'value' is true if the member data exists within the enclosing type,
+ otherwise 'value' is false.
+
+ */
+ template
+ <
+ class HasStaticMember,
+ class T,
+ class R
+ >
+ struct mf_has_static_data :
+ boost::mpl::apply
+ <
+ HasStaticMember,
+ typename T::type,
+ typename R::type
+ >::type
+ {
+ };
+ }
+ }
+
+#endif // TTI_STATIC_MEMBER_HPP

Added: sandbox/tti/boost/tti/static_member_function.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/static_member_function.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,195 @@
+#if !defined(TTI_STATIC_MEMBER_FUNCTION_HPP)
+#define TTI_STATIC_MEMBER_FUNCTION_HPP
+
+#include <boost/config.hpp>
+#include <boost/function_types/property_tags.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include "detail/dstatic_member_function.hpp"
+#include "detail/dtself.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether a static member function with a particular name and signature exists.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the return type of the static member function. 
+ FS = an optional parameter which are the parameters of the static member function as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the static member function. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
+ } \
+ template<class T,class R,class FS = boost::mpl::vector<>,class TAG = boost::function_types::null_tag> \
+ struct trait : \
+ detail::trait<T,typename detail::tfunction_seq<R,FS,TAG>::type> \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether a static member function with a particular name and signature exists.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the return type of the static member function. 
+ FS = an optional parameter which are the parameters of the static member function as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the static member function. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
+ } \
+ struct trait \
+ { \
+ template<class T,class R,class FS = boost::mpl::vector<>,class TAG = boost::function_types::null_tag> \
+ struct apply : \
+ detail::trait<T,typename detail::tfunction_seq<R,FS,TAG>::type> \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction which tests whether a static member function with a particular name and signature exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction called "boost::tti::has_static_member_function_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the return type of the static member function. 
+ FS = an optional parameter which are the parameters of the static member function as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the static member function. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_HAS_STATIC_MEMBER_FUNCTION(name) \
+ BOOST_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION \
+ ( \
+ BOOST_PP_CAT(has_static_member_function_,name), \
+ name \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether a static member function with a particular name and signature exists.
+/**
+
+ name = the name of the inner member.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_static_member_function_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ R = the return type of the static member function. 
+ FS = an optional parameter which are the parameters of the static member function as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the static member function. 
+ returns = 'value' is true if the 'name' exists, with the appropriate type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_HAS_STATIC_MEMBER_FUNCTION(name) \
+ BOOST_TTI_MTFC_TRAIT_HAS_STATIC_MEMBER_FUNCTION \
+ ( \
+ BOOST_PP_CAT(mtfc_has_static_member_function_,name), \
+ name \
+ ) \
+/**/
+
+namespace boost
+ {
+ namespace tti
+ {
+
+ /// A metafunction which checks whether a static member function exists within an enclosing type.
+ /**
+
+ This metafunction takes its specific types, except for the optional parameters, as nullary metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasStaticMemberFunction = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_STATIC_MEMBER_FUNCTION ( or TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION ) macro. 
+ The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_,_\> ( or optionally 'metafunction\<_,_,_\> or ' 'metafunction\<_,_,_,_\> )'.
+ You can also use the metafunction class generated by the TTI_MTFC_HAS_STATIC_MEMBER_FUNCTION ( or TTI_MTFC_TRAIT_HAS_STATIC_MEMBER_FUNCTION ) macro. 
+ T = the enclosing type as a nullary metafunction. 
+ R = the return type of the static member function as a nullary metafunction. 
+ FS = an optional parameter which is the parameters of the static member function, each as a nullary metafunction, as a boost::mpl forward sequence. 
+ TAG = an optional parameter which is a boost::function_types tag to apply to the static member function.
+
+ returns = 'value' is true if the member function exists within the enclosing type,
+ otherwise 'value' is false.
+
+ */
+ template
+ <
+ class HasStaticMemberFunction,
+ class T,
+ class R,
+ class FS = boost::mpl::vector<>,
+ class TAG = boost::function_types::null_tag
+ >
+ struct mf_has_static_member_function :
+ boost::mpl::apply
+ <
+ HasStaticMemberFunction,
+ typename T::type,
+ typename R::type,
+ typename boost::mpl::transform<FS,detail::tself<boost::mpl::_1> >::type,
+ TAG
+ >::type
+ {
+ };
+ }
+ }
+
+#endif // TTI_STATIC_MEMBER_FUNCTION_HPP

Added: sandbox/tti/boost/tti/template.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/template.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,178 @@
+#if !defined(TTI_TEMPLATE_HPP)
+#define TTI_TEMPLATE_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether an inner class template with a particular name exists.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner template.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' template exists within the enclosing type,
+ otherwise 'value' is false.
+
+ The template must have all 'class' ( or 'typename' ) parameters types.
+
+*/
+#define BOOST_TTI_TRAIT_HAS_TEMPLATE(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, false) \
+ } \
+ template<class T> \
+ struct trait : \
+ detail::trait<T> \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether an inner class template with a particular name exists.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner template.
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' template exists within the enclosing type,
+ otherwise 'value' is false.
+
+ The template must have all 'class' ( or 'typename' ) parameters types.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_HAS_TEMPLATE(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, false) \
+ } \
+ struct trait \
+ { \
+ template<class T> \
+ struct apply : \
+ detail::trait<T> \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction which tests whether an inner class template with a particular name exists.
+/**
+
+ name = the name of the inner template.
+
+ returns = a metafunction called "boost::tti::has_template_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' template exists within the enclosing type,
+ otherwise 'value' is false.
+
+ The template must have all 'class' ( or 'typename' ) parameters types.
+
+*/
+#define BOOST_TTI_HAS_TEMPLATE(name) \
+ BOOST_TTI_TRAIT_HAS_TEMPLATE \
+ ( \
+ BOOST_PP_CAT(has_template_,name), \
+ name \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether an inner class template with a particular name exists.
+/**
+
+ name = the name of the inner template.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_template_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' template exists within the enclosing type,
+ otherwise 'value' is false.
+
+ The template must have all 'class' ( or 'typename' ) parameters types.
+
+*/
+#define BOOST_TTI_MTFC_HAS_TEMPLATE(name) \
+ BOOST_TTI_MTFC_TRAIT_HAS_TEMPLATE \
+ ( \
+ BOOST_PP_CAT(mtfc_has_template_,name), \
+ name \
+ ) \
+/**/
+
+namespace boost
+ {
+ namespace tti
+ {
+
+ /// A metafunction which checks whether a class template exists within an enclosing type.
+ /**
+
+ This metafunction takes its enclosing type as nullary metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasTemplate = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_TEMPLATE ( TTI_TRAIT_HAS_TEMPLATE ) macro. 
+ The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_\>'.
+ You can also use the metafunction class generated by the TTI_MTFC_HAS_TEMPLATE ( TTI_MTFC_TRAIT_HAS_TEMPLATE ) macro. 
+ T = the enclosing type as a nullary metafunction.
+
+ returns = 'value' is true if the template exists within the enclosing type,
+ otherwise 'value' is false.
+
+ */
+ template
+ <
+ class HasTemplate,
+ class T
+ >
+ struct mf_has_template :
+ boost::mpl::apply
+ <
+ HasTemplate,
+ typename T::type
+ >::type
+ {
+ };
+ }
+ }
+
+#endif // TTI_TEMPLATE_HPP

Added: sandbox/tti/boost/tti/template_params.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/template_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,151 @@
+#if !defined(TTI_TEMPLATE_PARAMS_HPP)
+#define TTI_TEMPLATE_PARAMS_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include "mf_template_params.hpp"
+#include "detail/dtemplate_params.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether an inner class template with a particular name and signature exists.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner class template. 
+ tpSeq = a Boost PP sequence which has the class template parameters.
+ Each part of the template parameters separated by a comma ( , )
+ is put in a separate sequence element. 
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' class template with the signature
+ as defined by the 'tpSeq' exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+ } \
+ template<class T> \
+ struct trait : \
+ detail::trait<T> \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether an inner class template with a particular name and signature exists.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner class template. 
+ tpSeq = a Boost PP sequence which has the class template parameters.
+ Each part of the template parameters separated by a comma ( , )
+ is put in a separate sequence element. 
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' class template with the signature
+ as defined by the 'tpSeq' exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
+ } \
+ struct trait \
+ { \
+ template<class T> \
+ struct apply : \
+ detail::trait::apply<T> \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction which tests whether an inner class template with a particular name and signature exists.
+/**
+
+ name = the name of the inner class template. 
+ tpSeq = a Boost PP sequence which has the class template parameters.
+ Each part of the template parameters separated by a comma ( , )
+ is put in a separate sequence element.
+
+ returns = a metafunction called "boost::tti::has_template_check_params_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' class template with the signature
+ as defined by the 'tpSeq' exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_HAS_TEMPLATE_CHECK_PARAMS(name,tpSeq) \
+ BOOST_TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
+ ( \
+ BOOST_PP_CAT(has_template_check_params_,name), \
+ name, \
+ tpSeq \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether an inner class template with a particular name and signature exists.
+/**
+
+ name = the name of the inner class template. 
+ tpSeq = a Boost PP sequence which has the class template parameters.
+ Each part of the template parameters separated by a comma ( , )
+ is put in a separate sequence element.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_template_check_params_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' class template with the signature
+ as defined by the 'tpSeq' exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_HAS_TEMPLATE_CHECK_PARAMS(name,tpSeq) \
+ BOOST_TTI_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
+ ( \
+ BOOST_PP_CAT(mtfc_has_template_check_params_,name), \
+ name, \
+ tpSeq \
+ ) \
+/**/
+
+#endif // TTI_TEMPLATE_PARAMS_HPP

Modified: sandbox/tti/boost/tti/tti.hpp
==============================================================================
--- sandbox/tti/boost/tti/tti.hpp (original)
+++ sandbox/tti/boost/tti/tti.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -1,1483 +1,14 @@
#if !defined(TT_INTROSPECTION_HPP)
#define TT_INTROSPECTION_HPP

-#include <boost/config.hpp>
-#include <boost/function_types/property_tags.hpp>
-#include <boost/mpl/has_xxx.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/transform.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include "mf_template_params.hpp"
-#include "detail/dtti.hpp"
+#include "type.hpp"
+#include "member_type.hpp"
+#include "template.hpp"
+#include "template_params.hpp"
+#include "member.hpp"
+#include "member_function.hpp"
+#include "member_data.hpp"
+#include "static_member.hpp"
+#include "static_member_function.hpp"

-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-/// Expands to a metafunction which tests whether an inner type with a particular name exists and optionally is a particular type.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner type.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- U = the type of the inner type named 'name' as an optional parameter. 
- returns = 'value' is true if the 'name' type exists within the enclosing type
- and, if type U is specified, the 'name' type is the same as the type U,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_TRAIT_HAS_TYPE(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_TYPE(trait,name) \
- } \
- template<class T,class U = detail::notype> \
- struct trait : \
- detail::trait \
- < \
- T, \
- U, \
- typename detail::mpl::trait<T>::type \
- > \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether an inner type with a particular name exists and optionally is a particular type.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner type.
-
- returns = a metfunction class called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- U = the type of the inner type named 'name' as an optional parameter. 
- returns = 'value' is true if the 'name' type exists within the enclosing type
- and, if type U is specified, the 'name' type is the same as the type U,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_HAS_TYPE(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_TYPE(trait,name) \
- } \
- struct trait \
- { \
- template<class T,class U = detail::notype> \
- struct apply : \
- detail::trait \
- < \
- T, \
- U, \
- typename detail::mpl::trait<T>::type \
- > \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction which tests whether an inner type with a particular name exists and optionally is a particular type.
-/**
-
- name = the name of the inner type.
-
- returns = a metafunction called "boost::tti::has_type_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- U = the type of the inner type named 'name' as an optional parameter. 
- returns = 'value' is true if the 'name' type exists within the enclosing type
- and, if type U is specified, the 'name' type is the same as the type U,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_HAS_TYPE(name) \
- BOOST_TTI_TRAIT_HAS_TYPE \
- ( \
- BOOST_PP_CAT(has_type_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether an inner type with a particular name exists and optionally is a particular type.
-/**
-
- name = the name of the inner type.
-
- returns = a metafunction class called "boost::tti::mtfc_has_type_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- U = the type of the inner type named 'name' as an optional parameter. 
- returns = 'value' is true if the 'name' type exists within the enclosing type
- and, if type U is specified, the 'name' type is the same as the type U,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_HAS_TYPE(name) \
- BOOST_TTI_MTFC_TRAIT_HAS_TYPE \
- ( \
- BOOST_PP_CAT(mtfc_has_type_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction whose typedef 'type' is either the named type or an unspecified type.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner type.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type. 
- returns = 'type' is the inner type of 'name' if the inner type exists
- within the enclosing type, else 'type' is an unspecified type. 
-
- The purpose of this macro is to encapsulate the 'name' type as the typedef 'type'
- of a metafunction, but only if it exists within the enclosing type. This allows for
- a lazy evaluation of inner type existence which can be used by other metafunctions
- in this library.
-
-*/
-#define BOOST_TTI_TRAIT_MEMBER_TYPE(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_TYPE_MEMBER_TYPE(trait,name) \
- TTI_DETAIL_TRAIT_MEMBER_TYPE(trait,name) \
- } \
- template<class T> \
- struct trait : \
- boost::mpl::eval_if \
- < \
- detail::trait<T>, \
- detail::member_type::trait<T>, \
- boost::mpl::identity<detail::notype> \
- > \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class whose typedef 'type' is either the named type or an unspecified type.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner type.
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type. 
- returns = 'type' is the inner type of 'name' if the inner type exists
- within the enclosing type, else 'type' is an unspecified type. 
-
- The purpose of this macro is to encapsulate the 'name' type as the typedef 'type'
- of a metafunction class, but only if it exists within the enclosing type. This allows for
- a lazy evaluation of inner type existence which can be used by other metafunctions
- in this library.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_MEMBER_TYPE(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_TYPE_MEMBER_TYPE(trait,name) \
- TTI_DETAIL_TRAIT_MEMBER_TYPE(trait,name) \
- } \
- struct trait \
- { \
- template<class T> \
- struct apply : \
- boost::mpl::eval_if \
- < \
- detail::trait<T>, \
- detail::member_type::trait<T>, \
- boost::mpl::identity<detail::notype> \
- > \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction whose typedef 'type' is either the named type or an unspecified type.
-/**
-
- name = the name of the inner type.
-
- returns = a metafunction called "boost::tti::member_type_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type. 
- returns = 'type' is the inner type of 'name' if the inner type exists
- within the enclosing type, else 'type' is an unspecified type. 
-
- The purpose of this macro is to encapsulate the 'name' type as the typedef 'type'
- of a metafunction, but only if it exists within the enclosing type. This allows for
- a lazy evaluation of inner type existence which can be used by other metafunctions
- in this library.
-
-*/
-#define BOOST_TTI_MEMBER_TYPE(name) \
- BOOST_TTI_TRAIT_MEMBER_TYPE \
- ( \
- BOOST_PP_CAT(member_type_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction class whose typedef 'type' is either the named type or an unspecified type.
-/**
-
- name = the name of the inner type.
-
- returns = a metafunction class called "boost::tti::mtfc_member_type_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type. 
- returns = 'type' is the inner type of 'name' if the inner type exists
- within the enclosing type, else 'type' is an unspecified type. 
-
- The purpose of this macro is to encapsulate the 'name' type as the typedef 'type'
- of a metafunction class, but only if it exists within the enclosing type. This allows for
- a lazy evaluation of inner type existence which can be used by other metafunctions
- in this library.
-
-*/
-#define BOOST_TTI_MTFC_MEMBER_TYPE(name) \
- BOOST_TTI_MTFC_TRAIT_MEMBER_TYPE \
- ( \
- BOOST_PP_CAT(mtfc_member_type_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction which tests whether an inner class template with a particular name exists.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner template.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' template exists within the enclosing type,
- otherwise 'value' is false.
-
- The template must have all 'class' ( or 'typename' ) parameters types.
-
-*/
-#define BOOST_TTI_TRAIT_HAS_TEMPLATE(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, false) \
- } \
- template<class T> \
- struct trait : \
- detail::trait<T> \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether an inner class template with a particular name exists.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner template.
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' template exists within the enclosing type,
- otherwise 'value' is false.
-
- The template must have all 'class' ( or 'typename' ) parameters types.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_HAS_TEMPLATE(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait, name, false) \
- } \
- struct trait \
- { \
- template<class T> \
- struct apply : \
- detail::trait<T> \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction which tests whether an inner class template with a particular name exists.
-/**
-
- name = the name of the inner template.
-
- returns = a metafunction called "boost::tti::has_template_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' template exists within the enclosing type,
- otherwise 'value' is false.
-
- The template must have all 'class' ( or 'typename' ) parameters types.
-
-*/
-#define BOOST_TTI_HAS_TEMPLATE(name) \
- BOOST_TTI_TRAIT_HAS_TEMPLATE \
- ( \
- BOOST_PP_CAT(has_template_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether an inner class template with a particular name exists.
-/**
-
- name = the name of the inner template.
-
- returns = a metafunction class called "boost::tti::mtfc_has_template_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' template exists within the enclosing type,
- otherwise 'value' is false.
-
- The template must have all 'class' ( or 'typename' ) parameters types.
-
-*/
-#define BOOST_TTI_MTFC_HAS_TEMPLATE(name) \
- BOOST_TTI_MTFC_TRAIT_HAS_TEMPLATE \
- ( \
- BOOST_PP_CAT(mtfc_has_template_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction which tests whether an inner class template with a particular name and signature exists.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner class template. 
- tpSeq = a Boost PP sequence which has the class template parameters.
- Each part of the template parameters separated by a comma ( , )
- is put in a separate sequence element. 
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' class template with the signature
- as defined by the 'tpSeq' exists within the enclosing type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
- } \
- template<class T> \
- struct trait : \
- detail::trait<T> \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether an inner class template with a particular name and signature exists.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner class template. 
- tpSeq = a Boost PP sequence which has the class template parameters.
- Each part of the template parameters separated by a comma ( , )
- is put in a separate sequence element. 
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' class template with the signature
- as defined by the 'tpSeq' exists within the enclosing type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
- } \
- struct trait \
- { \
- template<class T> \
- struct apply : \
- detail::trait::apply<T> \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction which tests whether an inner class template with a particular name and signature exists.
-/**
-
- name = the name of the inner class template. 
- tpSeq = a Boost PP sequence which has the class template parameters.
- Each part of the template parameters separated by a comma ( , )
- is put in a separate sequence element.
-
- returns = a metafunction called "boost::tti::has_template_check_params_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' class template with the signature
- as defined by the 'tpSeq' exists within the enclosing type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_HAS_TEMPLATE_CHECK_PARAMS(name,tpSeq) \
- BOOST_TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
- ( \
- BOOST_PP_CAT(has_template_check_params_,name), \
- name, \
- tpSeq \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether an inner class template with a particular name and signature exists.
-/**
-
- name = the name of the inner class template. 
- tpSeq = a Boost PP sequence which has the class template parameters.
- Each part of the template parameters separated by a comma ( , )
- is put in a separate sequence element.
-
- returns = a metafunction class called "boost::tti::mtfc_has_template_check_params_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' class template with the signature
- as defined by the 'tpSeq' exists within the enclosing type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_HAS_TEMPLATE_CHECK_PARAMS(name,tpSeq) \
- BOOST_TTI_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
- ( \
- BOOST_PP_CAT(mtfc_has_template_check_params_,name), \
- name, \
- tpSeq \
- ) \
-/**/
-
-/// Expands to a metafunction which tests whether a member data or member function with a particular name and type exists.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction types and return:
-
- T = the type, in the form of a member data pointer or member function pointer,
- in which to look for our 'name'. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_TRAIT_HAS_MEMBER(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_MEMBER(trait,name) \
- } \
- template<class T> \
- struct trait : \
- detail::trait<T> \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether a member data or member function with a particular name and type exists.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the type, in the form of a member data pointer or member function pointer,
- in which to look for our 'name'. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_HAS_MEMBER(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_MEMBER(trait,name) \
- } \
- struct trait \
- { \
- template<class T> \
- struct apply : \
- detail::trait<T> \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction which tests whether a member data or member function with a particular name and type exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::has_member_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the type, in the form of a member data pointer or member function pointer,
- in which to look for our 'name'. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_HAS_MEMBER(name) \
- BOOST_TTI_TRAIT_HAS_MEMBER \
- ( \
- BOOST_PP_CAT(has_member_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether a member data or member function with a particular name and type exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::mtfc_has_member_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the type, in the form of a member data pointer or member function pointer,
- in which to look for our 'name'. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_HAS_MEMBER(name) \
- BOOST_TTI_MTFC_TRAIT_HAS_MEMBER \
- ( \
- BOOST_PP_CAT(mtfc_has_member_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction which tests whether a member function with a particular name and signature exists.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the return type of the member function. 
- FS = an optional parameter which are the parameters of the member function as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
- } \
- template<class T,class R,class FS = boost::mpl::vector<>,class TAG = boost::function_types::null_tag> \
- struct trait : \
- detail::trait<typename detail::ptmf_seq<T,R,FS,TAG>::type,typename boost::remove_const<T>::type> \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether a member function with a particular name and signature exists.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the return type of the member function. 
- FS = an optional parameter which are the parameters of the member function as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_MEMBER_FUNCTION(trait,name) \
- } \
- struct trait \
- { \
- template<class T,class R,class FS = boost::mpl::vector<>,class TAG = boost::function_types::null_tag> \
- struct apply : \
- detail::trait<typename detail::ptmf_seq<T,R,FS,TAG>::type,typename boost::remove_const<T>::type> \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction which tests whether a member function with a particular name and signature exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::has_member_function_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the return type of the member function. 
- FS = an optional parameter which are the parameters of the member function as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_HAS_MEMBER_FUNCTION(name) \
- BOOST_TTI_TRAIT_HAS_MEMBER_FUNCTION \
- ( \
- BOOST_PP_CAT(has_member_function_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether a member function with a particular name and signature exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::mtfc_has_member_function_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the return type of the member function. 
- FS = an optional parameter which are the parameters of the member function as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_HAS_MEMBER_FUNCTION(name) \
- BOOST_TTI_MTFC_TRAIT_HAS_MEMBER_FUNCTION \
- ( \
- BOOST_PP_CAT(mtfc_has_member_function_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction which tests whether a member data with a particular name and type exists.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the type of the member data. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_TRAIT_HAS_MEMBER_DATA(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_MEMBER_DATA(trait,name) \
- } \
- template<class T,class R> \
- struct trait : \
- detail::trait<typename detail::ptmd<T,R>::type,typename boost::remove_const<T>::type> \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether a member data with a particular name and type exists.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the type of the member data. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_HAS_MEMBER_DATA(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_MEMBER_DATA(trait,name) \
- } \
- struct trait \
- { \
- template<class T,class R> \
- struct apply : \
- detail::trait<typename detail::ptmd<T,R>::type,typename boost::remove_const<T>::type> \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction which tests whether a member data with a particular name and type exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::has_member_data_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the type of the member data. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_HAS_MEMBER_DATA(name) \
- BOOST_TTI_TRAIT_HAS_MEMBER_DATA \
- ( \
- BOOST_PP_CAT(has_member_data_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether a member data with a particular name and type exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::mtfc_has_member_data_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the type of the member data. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_HAS_MEMBER_DATA(name) \
- BOOST_TTI_MTFC_TRAIT_HAS_MEMBER_DATA \
- ( \
- BOOST_PP_CAT(mtfc_has_member_data_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction which tests whether a static member data or a static member function with a particular name and type exists.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction types and return:
-
- T = the enclosing type. 
- Type = the static member data or static member function type,
- in the form of a data or function type,
- in which to look for our 'name'. 
- returns = 'value' is true if the 'name' exists within the enclosing type,
- with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_TRAIT_HAS_STATIC_MEMBER(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER(trait,name) \
- } \
- template<class T,class Type> \
- struct trait : \
- detail::trait<T,Type> \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether a static member data or a static member function with a particular name and type exists.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type. 
- Type = the static member data or static member function type,
- in the form of a data or function type,
- in which to look for our 'name'. 
- returns = 'value' is true if the 'name' exists within the enclosing type,
- with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_HAS_STATIC_MEMBER(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_MTFC_TRAIT_HAS_STATIC_MEMBER(trait,name) \
- } \
- struct trait \
- { \
- template<class T,class Type> \
- struct apply : \
- detail::trait::apply<T,Type> \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-
-/// Expands to a metafunction which tests whether a static member data or a static member function with a particular name and type exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::has_static_member_name" where 'name' is the macro parameter. 
-
- The metafunction types and return:
-
- T = the enclosing type. 
- Type = the static member data or static member function type,
- in the form of a data or function type,
- in which to look for our 'name'. 
- returns = 'value' is true if the 'name' exists within the enclosing type,
- with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_HAS_STATIC_MEMBER(name) \
- BOOST_TTI_TRAIT_HAS_STATIC_MEMBER \
- ( \
- BOOST_PP_CAT(has_static_member_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether a static member data or a static member function with a particular name and type exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::mtfc_has_static_member_name" where 'name' is the macro parameter. 
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type. 
- Type = the static member data or static member function type,
- in the form of a data or function type,
- in which to look for our 'name'. 
- returns = 'value' is true if the 'name' exists within the enclosing type,
- with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_HAS_STATIC_MEMBER(name) \
- BOOST_TTI_MTFC_TRAIT_HAS_STATIC_MEMBER \
- ( \
- BOOST_PP_CAT(mtfc_has_static_member_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction which tests whether a static member function with a particular name and signature exists.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the return type of the static member function. 
- FS = an optional parameter which are the parameters of the static member function as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the static member function. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
- } \
- template<class T,class R,class FS = boost::mpl::vector<>,class TAG = boost::function_types::null_tag> \
- struct trait : \
- detail::trait<T,typename detail::tfunction_seq<R,FS,TAG>::type> \
- { \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether a static member function with a particular name and signature exists.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter. 
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the return type of the static member function. 
- FS = an optional parameter which are the parameters of the static member function as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the static member function. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_DETAIL_TRAIT_HAS_STATIC_MEMBER_FUNCTION(trait,name) \
- } \
- struct trait \
- { \
- template<class T,class R,class FS = boost::mpl::vector<>,class TAG = boost::function_types::null_tag> \
- struct apply : \
- detail::trait<T,typename detail::tfunction_seq<R,FS,TAG>::type> \
- { \
- }; \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction which tests whether a static member function with a particular name and signature exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction called "boost::tti::has_static_member_function_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the return type of the static member function. 
- FS = an optional parameter which are the parameters of the static member function as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the static member function. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_HAS_STATIC_MEMBER_FUNCTION(name) \
- BOOST_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION \
- ( \
- BOOST_PP_CAT(has_static_member_function_,name), \
- name \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether a static member function with a particular name and signature exists.
-/**
-
- name = the name of the inner member.
-
- returns = a metafunction class called "boost::tti::mtfc_has_static_member_function_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- R = the return type of the static member function. 
- FS = an optional parameter which are the parameters of the static member function as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the static member function. 
- returns = 'value' is true if the 'name' exists, with the appropriate type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_MTFC_HAS_STATIC_MEMBER_FUNCTION(name) \
- BOOST_TTI_MTFC_TRAIT_HAS_STATIC_MEMBER_FUNCTION \
- ( \
- BOOST_PP_CAT(mtfc_has_static_member_function_,name), \
- name \
- ) \
-/**/
-
-namespace boost
- {
- namespace tti
- {
-
- /// A metafunction which checks whether the member 'type' returned from invoking the macro metafunction generated by TTI_MEMBER_TYPE ( TTI_TRAIT_MEMBER_TYPE ) or from invoking boost::tti::mf_member_type is a valid type.
- /**
-
- The metafunction types and return:
-
- T = returned inner 'type' from invoking the macro metafunction generated by TTI_MEMBER_TYPE ( TTI_TRAIT_MEMBER_TYPE ) or from invoking boost::tti::mf_member_type.
-
- returns = 'value' is true if the type is valid, otherwise 'value' is false.
-
- */
- template
- <
- class T
- >
- struct valid_member_type :
- boost::mpl::not_
- <
- boost::is_same
- <
- T,
- detail::notype
- >
- >
- {
- };
-
- /// A metafunction which checks whether the member 'type' returned from invoking the macro metafunction generated by TTI_MEMBER_TYPE ( TTI_TRAIT_MEMBER_TYPE ) or from invoking boost::tti::mf_member_type is a valid type.
- /**
-
- The metafunction types and return:
-
- T = the nullary metafunction from invoking the macro metafunction generated by TTI_MEMBER_TYPE ( TTI_TRAIT_MEMBER_TYPE ) or from invoking boost::tti::mf_member_type.
-
- returns = 'value' is true if the type is valid, otherwise 'value' is false.
-
- */
- template
- <
- class T
- >
- struct mf_valid_member_type :
- boost::mpl::not_
- <
- boost::is_same
- <
- typename T::type,
- detail::notype
- >
- >
- {
- };
-
- /// A metafunction which checks whether a type exists within an enclosing type and optionally is a particular type.
- /**
-
- This metafunction takes its specific types as nullary metafunctions whose typedef 'type' member is the actual type used.
-
- The metafunction types and return:
-
- HasType = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_TYPE ( or TTI_TRAIT_HAS_TYPE ) macro. 
- The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_\>' ( or optionally 'metafunction\<_,_\>' ).
- You can also use the metafunction class generated by the TTI_MTFC_HAS_TYPE ( or TTI_MTFC_TRAIT_HAS_TYPE ) macro. 
- T = the enclosing type as a nullary metafunction. 
- U = the type of the inner type as a nullary metafunction, as an optional parameter.
-
- returns = 'value' is true if the type exists within the enclosing type
- and, if type U is specified, the type is the same as the type U,
- otherwise 'value' is false.
-
- */
- template
- <
- class HasType,
- class T,
- class U = boost::mpl::identity<detail::notype>
- >
- struct mf_has_type :
- boost::mpl::apply
- <
- HasType,
- typename T::type,
- typename U::type
- >::type
- {
- };
-
- /// A metafunction whose typedef 'type' is either the internal type or an unspecified type.
- /**
-
- This metafunction takes its enclosing type as nullary metafunctions whose typedef 'type' member is the actual type used.
-
- The metafunction types and return:
-
- MemberType = a Boost MPL lambda expression using the metafunction generated from the TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE ) macro. 
- The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_\>'.
- You can also use the metafunction class generated by the TTI_MTFC_MEMBER_TYPE ( or TTI_MTFC_TRAIT_MEMBER_TYPE ) macro. 
- T = the enclosing type as a nullary metafunction.
-
- returns = 'type' is the inner type of the 'name' in TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE )
- if the inner type exists within the enclosing type,
- else 'type' is an unspecified type. 
- 'valid' is true if the inner type of 'name' exists
- within the enclosing type, else 'valid' is false.
-
- The purpose of this metafunction is to encapsulate the 'name' type
- in TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE ) as the typedef 'type'
- of a metafunction, but only if it exists within the enclosing type. This allows for
- a lazy evaluation of inner type existence which can be used by other metafunctions
- in this library.
-
- Furthermore this metafunction allows the enclosing type to be return type from either the
- metafunction generated from TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE ) or from this
- metafunction itself.
-
- */
- template
- <
- class MemberType,
- class T
- >
- struct mf_member_type :
- boost::mpl::apply
- <
- MemberType,
- typename T::type
- >
- {
- };
-
- /// A metafunction which checks whether a class template exists within an enclosing type.
- /**
-
- This metafunction takes its enclosing type as nullary metafunctions whose typedef 'type' member is the actual type used.
-
- The metafunction types and return:
-
- HasTemplate = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_TEMPLATE ( TTI_TRAIT_HAS_TEMPLATE ) macro. 
- The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_\>'.
- You can also use the metafunction class generated by the TTI_MTFC_HAS_TEMPLATE ( TTI_MTFC_TRAIT_HAS_TEMPLATE ) macro. 
- T = the enclosing type as a nullary metafunction.
-
- returns = 'value' is true if the template exists within the enclosing type,
- otherwise 'value' is false.
-
- */
- template
- <
- class HasTemplate,
- class T
- >
- struct mf_has_template :
- boost::mpl::apply
- <
- HasTemplate,
- typename T::type
- >::type
- {
- };
-
- /// A metafunction which checks whether a member function exists within an enclosing type.
- /**
-
- This metafunction takes its specific types, except for the optional parameters, as nullary metafunctions whose typedef 'type' member is the actual type used.
-
- The metafunction types and return:
-
- HasMemberFunction = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_MEMBER_FUNCTION ( or TTI_TRAIT_HAS_MEMBER_FUNCTION ) macro. 
- The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_,_\> ( or optionally 'metafunction\<_,_,_\> or ' 'metafunction\<_,_,_,_\> )'.
- You can also use the metafunction class generated by the TTI_MTFC_HAS_MEMBER_FUNCTION ( or TTI_MTFC_TRAIT_HAS_MEMBER_FUNCTION ) macro. 
- T = the enclosing type as a nullary metafunction. 
- R = the return type of the member function as a nullary metafunction. 
- FS = an optional parameter which is the parameters of the member function, each as a nullary metafunction, as a boost::mpl forward sequence. 
- This parameter defaults to boost::mpl::vector<>. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the member function. 
- This parameter defaults to boost::function_types::null_tag.
-
- returns = 'value' is true if the member function exists within the enclosing type,
- otherwise 'value' is false.
-
- */
- template
- <
- class HasMemberFunction,
- class T,
- class R,
- class FS = boost::mpl::vector<>,
- class TAG = boost::function_types::null_tag
- >
- struct mf_has_member_function :
- boost::mpl::apply
- <
- HasMemberFunction,
- typename T::type,
- typename R::type,
- typename boost::mpl::transform<FS,detail::tself<boost::mpl::_1> >::type,
- TAG
- >::type
- {
- };
-
- /// A metafunction which checks whether a member data exists within an enclosing type.
- /**
-
- This metafunction takes its specific types as nullary metafunctions whose typedef 'type' member is the actual type used.
-
- The metafunction types and return:
-
- HasMemberData = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_MEMBER_DATA ( or TTI_TRAIT_HAS_MEMBER_DATA ) macro. 
- The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_,_\>'.
- You can also use the metafunction class generated by the TTI_MTFC_HAS_MEMBER_DATA ( or TTI_MTFC_TRAIT_HAS_MEMBER_DATA ) macro. 
- T = the enclosing type as a nullary metafunction. 
- R = the type of the member data as a nullary metafunction.
-
- returns = 'value' is true if the member data exists within the enclosing type,
- otherwise 'value' is false.
-
- */
- template
- <
- class HasMemberData,
- class T,
- class R
- >
- struct mf_has_member_data :
- boost::mpl::apply
- <
- HasMemberData,
- typename T::type,
- typename R::type
- >::type
- {
- };
-
- /// A metafunction which checks whether a static member function exists within an enclosing type.
- /**
-
- This metafunction takes its specific types, except for the optional parameters, as nullary metafunctions whose typedef 'type' member is the actual type used.
-
- The metafunction types and return:
-
- HasStaticMemberFunction = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_STATIC_MEMBER_FUNCTION ( or TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION ) macro. 
- The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_,_\> ( or optionally 'metafunction\<_,_,_\> or ' 'metafunction\<_,_,_,_\> )'.
- You can also use the metafunction class generated by the TTI_MTFC_HAS_STATIC_MEMBER_FUNCTION ( or TTI_MTFC_TRAIT_HAS_STATIC_MEMBER_FUNCTION ) macro. 
- T = the enclosing type as a nullary metafunction. 
- R = the return type of the static member function as a nullary metafunction. 
- FS = an optional parameter which is the parameters of the static member function, each as a nullary metafunction, as a boost::mpl forward sequence. 
- TAG = an optional parameter which is a boost::function_types tag to apply to the static member function.
-
- returns = 'value' is true if the member function exists within the enclosing type,
- otherwise 'value' is false.
-
- */
- template
- <
- class HasStaticMemberFunction,
- class T,
- class R,
- class FS = boost::mpl::vector<>,
- class TAG = boost::function_types::null_tag
- >
- struct mf_has_static_member_function :
- boost::mpl::apply
- <
- HasStaticMemberFunction,
- typename T::type,
- typename R::type,
- typename boost::mpl::transform<FS,detail::tself<boost::mpl::_1> >::type,
- TAG
- >::type
- {
- };
-
- /// A metafunction which checks whether a static member data exists within an enclosing type.
- /**
-
- This metafunction takes its specific types as nullary metafunctions whose typedef 'type' member is the actual type used.
-
- The metafunction types and return:
-
- HasStaticMember = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_STATIC_MEMBER ( or TTI_TRAIT_HAS_STATIC_MEMBER ) macro. 
- The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_,_\>'.
- You can also use the metafunction class generated by the TTI_MTFC_HAS_STATIC_MEMBER ( or TTI_MTFC_TRAIT_HAS_STATIC_MEMBER ) macro. 
- T = the enclosing type as a nullary metafunction. 
- R = the type of the static member data as a nullary metafunction.
-
- returns = 'value' is true if the member data exists within the enclosing type,
- otherwise 'value' is false.
-
- */
- template
- <
- class HasStaticMember,
- class T,
- class R
- >
- struct mf_has_static_data :
- boost::mpl::apply
- <
- HasStaticMember,
- typename T::type,
- typename R::type
- >::type
- {
- };
- }
- }
-
#endif // TT_INTROSPECTION_HPP

Modified: sandbox/tti/boost/tti/tti_vm.hpp
==============================================================================
--- sandbox/tti/boost/tti/tti_vm.hpp (original)
+++ sandbox/tti/boost/tti/tti_vm.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -1,150 +1,6 @@
#if !defined(TT_INTROSPECTION_VM_HPP)
#define TT_INTROSPECTION_VM_HPP

-#include <boost/config.hpp>
-#include "mf_template_params.hpp"
+#include "vm_template_params.hpp"

-#if !defined(BOOST_NO_VARIADIC_MACROS)
-
-#include <boost/preprocessor/cat.hpp>
-#include "detail/dtti_vm.hpp"
-
-/*
-
- The succeeding comments in this file are in doxygen format.
-
-*/
-
-/** \file
-*/
-
-/// Expands to a metafunction which tests whether an inner class template with a particular name and signature exists.
-/**
-
- trait = the name of the metafunction within the tti namespace. 
- name = the name of the inner class template. 
- ... = variadic macro data which has the class template parameters.
-
- returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' class template, with the signature
- as defined by the '...' variadic macro data, exists within the enclosing type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_VM_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,__VA_ARGS__) \
- } \
- template<class T> \
- struct trait \
- { \
- typedef typename detail::trait<T>::type type; \
- \
- BOOST_STATIC_CONSTANT(bool,value=type::value); \
- }; \
- } \
- } \
-/**/
-
-/// Expands to a metafunction class which tests whether an inner class template with a particular name and signature exists.
-/**
-
- trait = the name of the metafunction class within the tti namespace. 
- name = the name of the inner class template. 
- ... = variadic macro data which has the class template parameters.
-
- returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' class template, with the signature
- as defined by the '...' variadic macro data, exists within the enclosing type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_VM_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
-namespace boost \
- { \
- namespace tti \
- { \
- namespace detail \
- { \
- TTI_VM_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,__VA_ARGS__) \
- } \
- struct trait \
- { \
- template<class T> \
- struct apply \
- { \
- typedef typename detail::trait::apply<T>::type type; \
- \
- BOOST_STATIC_CONSTANT(bool,value=type::value); \
- }; \
- }; \
- } \
- } \
-/**/
-
-
-/// Expands to a metafunction which tests whether an inner class template with a particular name and signature exists.
-/**
-
- name = the name of the inner class template. 
- ... = variadic macro data which has the class template parameters.
-
- returns = a metafunction called "boost::tti::has_template_check_params_name" where 'name' is the macro parameter.
-
- The metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' class template, with the signature
- as defined by the '...' variadic macro data, exists within the enclosing type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_VM_HAS_TEMPLATE_CHECK_PARAMS(name,...) \
- BOOST_TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
- ( \
- BOOST_PP_CAT(has_template_check_params_,name), \
- name, \
- __VA_ARGS__ \
- ) \
-/**/
-
-/// Expands to a metafunction class which tests whether an inner class template with a particular name and signature exists.
-/**
-
- name = the name of the inner class template. 
- ... = variadic macro data which has the class template parameters.
-
- returns = a metafunction class called "boost::tti::mtfc_has_template_check_params_name" where 'name' is the macro parameter.
-
- The metafunction class's 'apply' metafunction types and return:
-
- T = the enclosing type in which to look for our 'name'. 
- returns = 'value' is true if the 'name' class template, with the signature
- as defined by the '...' variadic macro data, exists within the enclosing type,
- otherwise 'value' is false.
-
-*/
-#define BOOST_TTI_VM_MTFC_HAS_TEMPLATE_CHECK_PARAMS(name,...) \
- BOOST_TTI_VM_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
- ( \
- BOOST_PP_CAT(mtfc_has_template_check_params_,name), \
- name, \
- __VA_ARGS__ \
- ) \
-/**/
-
-#endif // !defined(BOOST_NO_VARIADIC_MACROS)
#endif // TT_INTROSPECTION_VM_HPP

Added: sandbox/tti/boost/tti/type.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/type.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,193 @@
+#if !defined(TTI_TYPE_HPP)
+#define TTI_TYPE_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include "detail/dtype.hpp"
+#include "detail/dnotype.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether an inner type with a particular name exists and optionally is a particular type.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner type.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ U = the type of the inner type named 'name' as an optional parameter. 
+ returns = 'value' is true if the 'name' type exists within the enclosing type
+ and, if type U is specified, the 'name' type is the same as the type U,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_TRAIT_HAS_TYPE(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_TYPE(trait,name) \
+ } \
+ template<class T,class U = detail::notype> \
+ struct trait : \
+ detail::trait \
+ < \
+ T, \
+ U, \
+ typename detail::mpl::trait<T>::type \
+ > \
+ { \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether an inner type with a particular name exists and optionally is a particular type.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner type.
+
+ returns = a metfunction class called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ U = the type of the inner type named 'name' as an optional parameter. 
+ returns = 'value' is true if the 'name' type exists within the enclosing type
+ and, if type U is specified, the 'name' type is the same as the type U,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_TRAIT_HAS_TYPE(trait,name) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_DETAIL_TRAIT_HAS_TYPE(trait,name) \
+ } \
+ struct trait \
+ { \
+ template<class T,class U = detail::notype> \
+ struct apply : \
+ detail::trait \
+ < \
+ T, \
+ U, \
+ typename detail::mpl::trait<T>::type \
+ > \
+ { \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction which tests whether an inner type with a particular name exists and optionally is a particular type.
+/**
+
+ name = the name of the inner type.
+
+ returns = a metafunction called "boost::tti::has_type_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ U = the type of the inner type named 'name' as an optional parameter. 
+ returns = 'value' is true if the 'name' type exists within the enclosing type
+ and, if type U is specified, the 'name' type is the same as the type U,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_HAS_TYPE(name) \
+ BOOST_TTI_TRAIT_HAS_TYPE \
+ ( \
+ BOOST_PP_CAT(has_type_,name), \
+ name \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether an inner type with a particular name exists and optionally is a particular type.
+/**
+
+ name = the name of the inner type.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_type_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ U = the type of the inner type named 'name' as an optional parameter. 
+ returns = 'value' is true if the 'name' type exists within the enclosing type
+ and, if type U is specified, the 'name' type is the same as the type U,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_MTFC_HAS_TYPE(name) \
+ BOOST_TTI_MTFC_TRAIT_HAS_TYPE \
+ ( \
+ BOOST_PP_CAT(mtfc_has_type_,name), \
+ name \
+ ) \
+/**/
+
+namespace boost
+ {
+ namespace tti
+ {
+
+ /// A metafunction which checks whether a type exists within an enclosing type and optionally is a particular type.
+ /**
+
+ This metafunction takes its specific types as nullary metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasType = a Boost MPL lambda expression using the metafunction generated from the TTI_HAS_TYPE ( or TTI_TRAIT_HAS_TYPE ) macro. 
+ The easiest way to generate the lambda expression is to use a Boost MPL placeholder expression of the form 'metafunction\<_\>' ( or optionally 'metafunction\<_,_\>' ).
+ You can also use the metafunction class generated by the TTI_MTFC_HAS_TYPE ( or TTI_MTFC_TRAIT_HAS_TYPE ) macro. 
+ T = the enclosing type as a nullary metafunction. 
+ U = the type of the inner type as a nullary metafunction, as an optional parameter.
+
+ returns = 'value' is true if the type exists within the enclosing type
+ and, if type U is specified, the type is the same as the type U,
+ otherwise 'value' is false.
+
+ */
+ template
+ <
+ class HasType,
+ class T,
+ class U = boost::mpl::identity<detail::notype>
+ >
+ struct mf_has_type :
+ boost::mpl::apply
+ <
+ HasType,
+ typename T::type,
+ typename U::type
+ >::type
+ {
+ };
+ }
+ }
+
+#endif // TTI_TYPE_HPP

Added: sandbox/tti/boost/tti/vm_template_params.hpp
==============================================================================
--- (empty file)
+++ sandbox/tti/boost/tti/vm_template_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -0,0 +1,152 @@
+#if !defined(TTI_VM_TEMPLATE_PARAMS_HPP)
+#define TTI_VM_TEMPLATE_PARAMS_HPP
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_VARIADIC_MACROS)
+
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include "mf_template_params.hpp"
+#include "detail/dvm_template_params.hpp"
+
+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
+/// Expands to a metafunction which tests whether an inner class template with a particular name and signature exists.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner class template. 
+ ... = variadic macro data which has the class template parameters.
+
+ returns = a metafunction called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' class template, with the signature
+ as defined by the '...' variadic macro data, exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_VM_DETAIL_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,__VA_ARGS__) \
+ } \
+ template<class T> \
+ struct trait \
+ { \
+ typedef typename detail::trait<T>::type type; \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ }; \
+ } \
+ } \
+/**/
+
+/// Expands to a metafunction class which tests whether an inner class template with a particular name and signature exists.
+/**
+
+ trait = the name of the metafunction class within the tti namespace. 
+ name = the name of the inner class template. 
+ ... = variadic macro data which has the class template parameters.
+
+ returns = a metafunction class called "boost::tti::trait" where 'trait' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' class template, with the signature
+ as defined by the '...' variadic macro data, exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_VM_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
+namespace boost \
+ { \
+ namespace tti \
+ { \
+ namespace detail \
+ { \
+ TTI_VM_DETAIL_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,__VA_ARGS__) \
+ } \
+ struct trait \
+ { \
+ template<class T> \
+ struct apply \
+ { \
+ typedef typename detail::trait::apply<T>::type type; \
+ \
+ BOOST_STATIC_CONSTANT(bool,value=type::value); \
+ }; \
+ }; \
+ } \
+ } \
+/**/
+
+
+/// Expands to a metafunction which tests whether an inner class template with a particular name and signature exists.
+/**
+
+ name = the name of the inner class template. 
+ ... = variadic macro data which has the class template parameters.
+
+ returns = a metafunction called "boost::tti::has_template_check_params_name" where 'name' is the macro parameter.
+
+ The metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' class template, with the signature
+ as defined by the '...' variadic macro data, exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_VM_HAS_TEMPLATE_CHECK_PARAMS(name,...) \
+ BOOST_TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
+ ( \
+ BOOST_PP_CAT(has_template_check_params_,name), \
+ name, \
+ __VA_ARGS__ \
+ ) \
+/**/
+
+/// Expands to a metafunction class which tests whether an inner class template with a particular name and signature exists.
+/**
+
+ name = the name of the inner class template. 
+ ... = variadic macro data which has the class template parameters.
+
+ returns = a metafunction class called "boost::tti::mtfc_has_template_check_params_name" where 'name' is the macro parameter.
+
+ The metafunction class's 'apply' metafunction types and return:
+
+ T = the enclosing type in which to look for our 'name'. 
+ returns = 'value' is true if the 'name' class template, with the signature
+ as defined by the '...' variadic macro data, exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
+#define BOOST_TTI_VM_MTFC_HAS_TEMPLATE_CHECK_PARAMS(name,...) \
+ BOOST_TTI_VM_MTFC_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
+ ( \
+ BOOST_PP_CAT(mtfc_has_template_check_params_,name), \
+ name, \
+ __VA_ARGS__ \
+ ) \
+/**/
+
+#endif // !defined(BOOST_NO_VARIADIC_MACROS)
+#endif // TTI_VM_TEMPLATE_PARAMS_HPP

Modified: sandbox/tti/libs/tti/test/test_has_member.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_member.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_member.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_MEMBER_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/member.hpp>

BOOST_TTI_HAS_MEMBER(AnInt)
BOOST_TTI_HAS_MEMBER(VoidFunction)

Modified: sandbox/tti/libs/tti/test/test_has_member_data.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_member_data.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_member_data.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_MEMBER_DATA_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/member_data.hpp>

BOOST_TTI_HAS_MEMBER_DATA(AnInt)
BOOST_TTI_HAS_MEMBER_DATA(aMember)

Modified: sandbox/tti/libs/tti/test/test_has_member_function.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_member_function.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_member_function.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_MEMBER_FUNCTION_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/member_function.hpp>

BOOST_TTI_HAS_MEMBER_FUNCTION(VoidFunction)
BOOST_TTI_TRAIT_HAS_MEMBER_FUNCTION(FunctionReturningInt,IntFunction)

Modified: sandbox/tti/libs/tti/test/test_has_static_member.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_static_member.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_static_member.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_STATIC_MEMBER_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/static_member.hpp>

BOOST_TTI_HAS_STATIC_MEMBER(DSMember)
BOOST_TTI_TRAIT_HAS_STATIC_MEMBER(HaveTheSIntFunction,SIntFunction)

Modified: sandbox/tti/libs/tti/test/test_has_static_member_function.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_static_member_function.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_static_member_function.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_STATIC_MEMBER_FUNCTION_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/static_member_function.hpp>

BOOST_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION(HaveTheSIntFunction,SIntFunction)
BOOST_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION(TheTIntFunction,TIntFunction)

Modified: sandbox/tti/libs/tti/test/test_has_template.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_template.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_template.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_TEMPLATE_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/template.hpp>

BOOST_TTI_HAS_TEMPLATE(ATPMemberTemplate)
BOOST_TTI_TRAIT_HAS_TEMPLATE(HaveCL,CLMemberTemplate)

Modified: sandbox/tti/libs/tti/test/test_has_template_check_params.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_template_check_params.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_template_check_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_TEMPLATE_CHECK_PARAMS_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/template_params.hpp>

BOOST_TTI_HAS_TEMPLATE_CHECK_PARAMS(ATPMemberTemplate,(class))
BOOST_TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(HaveCL,CLMemberTemplate,(class)(class))

Modified: sandbox/tti/libs/tti/test/test_has_type.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_type.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_type.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_TYPE_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/type.hpp>

BOOST_TTI_HAS_TYPE(AnIntType)
BOOST_TTI_TRAIT_HAS_TYPE(NameStruct,AStructType)

Modified: sandbox/tti/libs/tti/test/test_has_type_check_typedef.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_has_type_check_typedef.hpp (original)
+++ sandbox/tti/libs/tti/test/test_has_type_check_typedef.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_HAS_TYPE_CHECK_TYPEDEF_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/type.hpp>

BOOST_TTI_HAS_TYPE(AnIntType)
BOOST_TTI_TRAIT_HAS_TYPE(NameStruct,AStructType)

Modified: sandbox/tti/libs/tti/test/test_member_type.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_member_type.hpp (original)
+++ sandbox/tti/libs/tti/test/test_member_type.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_MEMBER_TYPE_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_MEMBER_TYPE(AnIntType)
BOOST_TTI_TRAIT_MEMBER_TYPE(NameStruct,AStructType)

Modified: sandbox/tti/libs/tti/test/test_mf_has_member_data.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_has_member_data.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_has_member_data.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,8 @@
#define TEST_MF_HAS_MEMBER_DATA_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/member_data.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_HAS_MEMBER_DATA(AnInt)
BOOST_TTI_HAS_MEMBER_DATA(aMember)

Modified: sandbox/tti/libs/tti/test/test_mf_has_member_function.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_has_member_function.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_has_member_function.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,8 @@
#define TEST_MF_HAS_MEMBER_FUNCTION_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/member_function.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_HAS_MEMBER_FUNCTION(VoidFunction)
BOOST_TTI_TRAIT_HAS_MEMBER_FUNCTION(FunctionReturningInt,IntFunction)

Modified: sandbox/tti/libs/tti/test/test_mf_has_static_data.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_has_static_data.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_has_static_data.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_MF_HAS_STATIC_DATA_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/static_member.hpp>

BOOST_TTI_HAS_STATIC_MEMBER(DSMember)
BOOST_TTI_HAS_STATIC_MEMBER(SomeStaticData)

Modified: sandbox/tti/libs/tti/test/test_mf_has_static_function.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_has_static_function.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_has_static_function.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,8 @@
#define TEST_MF_HAS_STATIC_FUNCTION_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/static_member_function.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION(HaveTheSIntFunction,SIntFunction)
BOOST_TTI_TRAIT_HAS_STATIC_MEMBER_FUNCTION(TheTIntFunction,TIntFunction)

Modified: sandbox/tti/libs/tti/test/test_mf_has_template.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_has_template.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_has_template.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,8 @@
#define TEST_MF_HAS_TEMPLATE_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/template.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_TRAIT_HAS_TEMPLATE(HaveMStr,MStrMemberTemplate)
BOOST_TTI_HAS_TEMPLATE(TemplateNotExist)

Modified: sandbox/tti/libs/tti/test/test_mf_has_template_check_params.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_has_template_check_params.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_has_template_check_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,8 @@
#define TEST_MF_HAS_TEMPLATE_CHECK_PARAMS_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/template_params.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(HT_Str,MStrMemberTemplate,(class))
BOOST_TTI_HAS_TEMPLATE_CHECK_PARAMS(AnotherMemberTemplate,(int)(int))

Modified: sandbox/tti/libs/tti/test/test_mf_has_type.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_has_type.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_has_type.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,8 @@
#define TEST_MF_HAS_TYPE_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/type.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_HAS_TYPE(AnIntType)
BOOST_TTI_TRAIT_HAS_TYPE(NameStruct,AStructType)

Modified: sandbox/tti/libs/tti/test/test_mf_has_type_check_typedef.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_has_type_check_typedef.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_has_type_check_typedef.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,8 @@
#define TEST_MF_HAS_TYPE_CHECK_TYPEDEF_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/type.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_HAS_TYPE(AnIntType)
BOOST_TTI_TRAIT_HAS_TYPE(NameStruct,AStructType)

Modified: sandbox/tti/libs/tti/test/test_mf_member_type.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_mf_member_type.hpp (original)
+++ sandbox/tti/libs/tti/test/test_mf_member_type.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -2,7 +2,7 @@
#define TEST_MF_MEMBER_TYPE_HPP

#include "test_structs.hpp"
-#include <boost/tti/tti.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_MEMBER_TYPE(AnIntType)
BOOST_TTI_TRAIT_MEMBER_TYPE(NameStruct,AStructType)

Modified: sandbox/tti/libs/tti/test/test_vm_has_template_check_params.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_vm_has_template_check_params.hpp (original)
+++ sandbox/tti/libs/tti/test/test_vm_has_template_check_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -4,7 +4,7 @@
#if !defined(BOOST_NO_VARIADIC_MACROS)

#include "test_structs.hpp"
-#include <boost/tti/tti_vm.hpp>
+#include <boost/tti/vm_template_params.hpp>

BOOST_TTI_VM_HAS_TEMPLATE_CHECK_PARAMS(ATPMemberTemplate,class)
BOOST_TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(HaveCL,CLMemberTemplate,class,class)

Modified: sandbox/tti/libs/tti/test/test_vm_mf_has_template_check_params.hpp
==============================================================================
--- sandbox/tti/libs/tti/test/test_vm_mf_has_template_check_params.hpp (original)
+++ sandbox/tti/libs/tti/test/test_vm_mf_has_template_check_params.hpp 2011-02-14 22:01:28 EST (Mon, 14 Feb 2011)
@@ -4,8 +4,8 @@
#if !defined(BOOST_NO_VARIADIC_MACROS)

#include "test_structs.hpp"
-#include <boost/tti/tti_vm.hpp>
-#include <boost/tti/tti.hpp>
+#include <boost/tti/vm_template_params.hpp>
+#include <boost/tti/member_type.hpp>

BOOST_TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(HT_Str,MStrMemberTemplate,class)
BOOST_TTI_VM_HAS_TEMPLATE_CHECK_PARAMS(AnotherMemberTemplate,int,int)

Next message: joel_at_[hidden]: "[Boost-commit] svn:boost r68906 - in trunk/libs/spirit/test: . qi"
Previous message: dnljms_at_[hidden]: "[Boost-commit] svn:boost r68902 - branches/doc-tools-docs/tools/quickbook/doc"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk