Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r67467 - in sandbox/tti: boost/tti libs/tti/doc
From: eldiener_at_[hidden]
Date: 2010-12-27 00:22:19

Author: eldiener
Date: 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
New Revision: 67467
URL: http://svn.boost.org/trac/boost/changeset/67467

Log:
Documentation, still incomplete
Added:
   sandbox/tti/libs/tti/doc/Jamfile.v2 (contents, props changed)
   sandbox/tti/libs/tti/doc/TTIAcknowledgements.qbk (contents, props changed)
   sandbox/tti/libs/tti/doc/TTIDetail.qbk (contents, props changed)
   sandbox/tti/libs/tti/doc/TTIFunctionality.qbk (contents, props changed)
   sandbox/tti/libs/tti/doc/TTIHistory.qbk (contents, props changed)
   sandbox/tti/libs/tti/doc/TTIIntroduction.qbk (contents, props changed)
   sandbox/tti/libs/tti/doc/TTIReference.qbk (contents, props changed)
   sandbox/tti/libs/tti/doc/TTITerminology.qbk (contents, props changed)
   sandbox/tti/libs/tti/doc/TypeTraitsIntrospection.qbk (contents, props changed)
Text files modified:
   sandbox/tti/boost/tti/TTIntrospection.hpp | 440 ++++++++++++++++++++++++++++++++++++++++
   sandbox/tti/boost/tti/TTIntrospectionVM.hpp | 76 ++++++
   2 files changed, 516 insertions(+), 0 deletions(-)

Modified: sandbox/tti/boost/tti/TTIntrospection.hpp
==============================================================================
--- sandbox/tti/boost/tti/TTIntrospection.hpp (original)
+++ sandbox/tti/boost/tti/TTIntrospection.hpp 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -22,6 +22,30 @@
#include <boost/type_traits/remove_const.hpp>
#include "detail/TTIntrospectionDetail.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.
+/**
+
+ trait = the name of the metafunction within the tti namespace. 
+ name = the name of the inner type.
+
+ returns = a metafunction called "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' type exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
#define TTI_TRAIT_HAS_TYPE(trait,name) \
namespace tti \
 { \
@@ -39,6 +63,20 @@
 } \
/**/

+/// Expands to a metafunction which tests whether an inner type with a particular name exists.
+/**
+
+ name = the name of the inner type.
+
+ returns = a metafunction called "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'. 
+ returns = 'value' is true if the 'name' type exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
#define TTI_HAS_TYPE(name) \
 TTI_TRAIT_HAS_TYPE \
 ( \
@@ -47,6 +85,26 @@
 ) \
/**/

+/// 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 "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 TTI_TRAIT_MEMBER_TYPE(trait,name) \
namespace tti \
 { \
@@ -70,6 +128,25 @@
 } \
/**/

+/// 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 "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 TTI_MEMBER_TYPE(name) \
 TTI_TRAIT_MEMBER_TYPE \
 ( \
@@ -78,6 +155,23 @@
 ) \
/**/

+/// Expands to a metafunction which tests whether an inner type with a particular name exists and 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 "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'. 
+ returns = 'value' is true if the 'name' type exists within the enclosing type
+ and the 'name' type is the same as the type U,
+ otherwise 'value' is false.
+
+*/
#define TTI_TRAIT_HAS_TYPE_CHECK_TYPEDEF(trait,name) \
namespace tti \
 { \
@@ -123,6 +217,22 @@
 } \
/**/

+/// Expands to a metafunction which tests whether an inner type with a particular name exists and is a particular type.
+/**
+
+ name = the name of the inner type.
+
+ returns = a metafunction called "tti::has_type_check_typedef_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'. 
+ returns = 'value' is true if the 'name' type exists within the enclosing type
+ and the 'name' type is the same as the type U,
+ otherwise 'value' is false.
+
+*/
#define TTI_HAS_TYPE_CHECK_TYPEDEF(name) \
 TTI_TRAIT_HAS_TYPE_CHECK_TYPEDEF \
 ( \
@@ -131,6 +241,23 @@
 ) \
/**/

+/// 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 "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 TTI_TRAIT_HAS_TEMPLATE(trait,name) \
namespace tti \
 { \
@@ -148,6 +275,22 @@
 } \
/**/

+/// 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 "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 TTI_HAS_TEMPLATE(name) \
 TTI_TRAIT_HAS_TEMPLATE \
 ( \
@@ -159,6 +302,25 @@
#if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)

+/// 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 "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 TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
namespace tti \
 { \
@@ -171,6 +333,25 @@

#else // !!BOOST_WORKAROUND(BOOST_MSVC, <= 1400)

+/// 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 "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 TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
namespace tti \
 { \
@@ -184,12 +365,49 @@
#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
#else // !!defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)

+/// 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 "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 TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,tpSeq) \
TTI_DETAIL_SAME(trait,name) \
/**/

#endif // !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)

+/// 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 "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 TTI_HAS_TEMPLATE_CHECK_PARAMS(name,tpSeq) \
 TTI_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
 ( \
@@ -201,6 +419,22 @@

#if defined(BOOST_NO_NULLPTR)

+/// 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 "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 TTI_TRAIT_HAS_MEMBER(trait,name) \
namespace tti \
 { \
@@ -264,6 +498,22 @@

#else // !!defined(BOOST_NO_NULLPTR)

+/// 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 "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 TTI_TRAIT_HAS_MEMBER(trait,name) \
namespace tti \
 { \
@@ -327,6 +577,21 @@

#endif // defined(BOOST_NO_NULLPTR)

+/// 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 "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 TTI_HAS_MEMBER(name) \
 TTI_TRAIT_HAS_MEMBER \
 ( \
@@ -337,6 +602,25 @@

#if defined(BOOST_NO_NULLPTR)

+/// 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 "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 TTI_TRAIT_HAS_STATIC_MEMBER(trait,name) \
namespace tti \
 { \
@@ -361,6 +645,25 @@

#else // !defined(BOOST_NO_NULLPTR)

+/// 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 "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 TTI_TRAIT_HAS_STATIC_MEMBER(trait,name) \
namespace tti \
 { \
@@ -385,6 +688,24 @@

#endif // defined(BOOST_NO_NULLPTR)

+/// 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 "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 TTI_HAS_STATIC_MEMBER(name) \
 TTI_TRAIT_HAS_STATIC_MEMBER \
 ( \
@@ -396,6 +717,20 @@
namespace tti
 {

+/// A metafunction which checks whether a type exists within an enclosing type.
+/**
+
+ This metafunction takes all its types as metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasType = Template class generated from the TTI_HAS_TYPE ( or TTI_TRAIT_HAS_TYPE ) macro. 
+ T = The enclosing type as a metafunction.
+
+ returns = 'value' is true if the type exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
 template
 <
 template<class> class HasType,
@@ -412,6 +747,31 @@
 {
 };

+/// A metafunction whose typedef 'type' is either the internal type or an unspecified type.
+/**
+
+ This metafunction takes all its types as metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ MemberType = Template class generated from the TTI_MEMBER_TYPE ( or TTI_TRAIT_MEMBER_TYPE ) macro. 
+ T = The enclosing type as a 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.
+
+ 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
 <
 template<class> class MemberType,
@@ -422,6 +782,23 @@
 {
 };

+/// A metafunction which checks whether a member function exists within an enclosing type.
+/**
+
+ This metafunction takes all its types as metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasMember = Template class generated from the TTI_HAS_MEMBER ( or TTI_TRAIT_HAS_MEMBER ) macro. 
+ T = The enclosing type as a metafunction. 
+ R = The return type of the member function as a metafunction. 
+ P... = The parameter types of the member function, each as a metafunction. 
+ There can be up to TTI_MAX_PARAMETERS number of parameters. The default is 10.
+
+ returns = 'value' is true if the member function exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
 template
 <
 template<class> class HasMember,
@@ -448,6 +825,21 @@
 {
 };

+/// A metafunction which checks whether a member data exists within an enclosing type.
+/**
+
+ This metafunction takes all its types as metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasMember = Template class generated from the TTI_HAS_MEMBER ( or TTI_TRAIT_HAS_MEMBER ) macro. 
+ T = The enclosing type as a metafunction. 
+ R = The type of the member data as a metafunction.
+
+ returns = 'value' is true if the member data exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
 template
 <
 template<class> class HasMember,
@@ -472,6 +864,23 @@
 {
 };

+/// A metafunction which checks whether a static member function exists within an enclosing type.
+/**
+
+ This metafunction takes all its types as metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasStatic Member = Template class generated from the TTI_HAS_STATIC_MEMBER ( or TTI_TRAIT_HAS_STATIC_MEMBER ) macro. 
+ T = The enclosing type as a metafunction. 
+ R = The return type of the static member function as a metafunction. 
+ P... = The parameter types of the static member function, each as a metafunction. 
+ There can be up to TTI_MAX_PARAMETERS number of parameters. The default is 10.
+
+ returns = 'value' is true if the static member function exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
 template
 <
 template<class,class> class HasStaticMember,
@@ -498,6 +907,21 @@
 {
 };

+/// A metafunction which checks whether a static member data exists within an enclosing type.
+/**
+
+ This metafunction takes all its types as metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasStaticMember = Template class generated from the TTI_HAS_STATIC_MEMBER ( or TTI_TRAIT_HAS_STATIC_MEMBER ) macro. 
+ T = The enclosing type as a metafunction. 
+ R = The type of the static member data as a metafunction.
+
+ returns = 'value' is true if the member data exists within the enclosing type,
+ otherwise 'value' is false.
+
+*/
 template
 <
 template<class,class> class HasStaticMember,
@@ -516,6 +940,22 @@
 {
 };

+/// A metafunction which checks whether a type of a particular signature exists within an enclosing type.
+/**
+
+ This metafunction takes all its types as metafunctions whose typedef 'type' member is the actual type used.
+
+ The metafunction types and return:
+
+ HasTypeCheckTypedef = Template class generated from the TTI_HAS_TYPE_CHECK_TYPEDEF ( or TTI_TRAIT_HAS_TYPE_CHECK_TYPEDEF ) macro. 
+ T = The enclosing type as a metafunction. 
+ U = The type of the enclosed type as a metafunction.
+
+ returns = 'value' is true if the type exists within the enclosing type,
+ with the correct type signature,
+ otherwise 'value' is false.
+
+*/
 template
 <
 template<class,class> class HasTypeCheckTypedef,

Modified: sandbox/tti/boost/tti/TTIntrospectionVM.hpp
==============================================================================
--- sandbox/tti/boost/tti/TTIntrospectionVM.hpp (original)
+++ sandbox/tti/boost/tti/TTIntrospectionVM.hpp 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -8,10 +8,36 @@
#include <boost/variadic_macro_data/VariadicMacroData.hpp>
#include "detail/TTIntrospectionDetail.hpp"

+/*
+
+ The succeeding comments in this file are in doxygen format.
+
+*/
+
+/** \file
+*/
+
#if !defined(BOOST_NO_VARIADIC_MACROS)
#if !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)

+/// 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 "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 TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
namespace tti \
 { \
@@ -24,6 +50,23 @@

#else // !!BOOST_WORKAROUND(BOOST_MSVC, <= 1400)

+/// 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 "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 TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
namespace tti \
 { \
@@ -37,12 +80,45 @@
#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
#else // !!defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)

+/// 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 "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 TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS(trait,name,...) \
TTI_DETAIL_SAME(trait,name) \
/**/

#endif // !defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)

+/// 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 "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 TTI_VM_HAS_TEMPLATE_CHECK_PARAMS(name,...) \
 TTI_VM_TRAIT_HAS_TEMPLATE_CHECK_PARAMS \
 ( \

Added: sandbox/tti/libs/tti/doc/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/Jamfile.v2 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1,52 @@
+# TypeTraitsIntrospection documentation Jamfile
+#
+# Copyright (c) 2010
+# Edward Diener
+#
+
+project tti_doc ;
+
+using quickbook ;
+using doxygen ;
+
+path-constant here : . ; # convenient to refer to files in the same directory as this jamfile.v2
+
+doxygen TypeTraitsIntrospectionReference
+ :
+ $(here)/../../../boost/tti/TTIntrospection.hpp
+ $(here)/../../../boost/tti/TTIntrospectionVM.hpp
+ :
+ <doxygen:param>PROJECT_NAME="TTI"
+ <doxygen:param>PROJECT_NUMBER=1
+ <doxygen:param>SORT_MEMBER_DOCS=NO
+ <doxygen:param>SHOW_INCLUDE_FILES=NO
+ <doxygen:param>MAX_INITIALIZER_LINES=0
+ <doxygen:param>VERBATIM_HEADERS=NO
+ <reftitle>"TypeTraitsIntrospection Reference"
+;
+
+xml TypeTraitsIntrospection
+ :
+ TypeTraitsIntrospection.qbk
+ :
+ <dependency>TypeTraitsIntrospectionReference
+;
+
+boostbook standalone
+ :
+ TypeTraitsIntrospection
+ :
+ <xsl:param>boost.root="../../../.."
+ <xsl:param>chunk.section.depth=8 # How far down we chunk nested sections, basically all of them.
+ <xsl:param>toc.section.depth=8 # How far down sections get TOCs.
+ <xsl:param>toc.max.depth=4 # Max depth in each TOC.
+ <dependency>css
+ <dependency>images
+ ;
+
+install css : [ glob $(BOOST_ROOT)/doc/src/*.css ]
+ : <location>html ;
+install images : [ glob $(BOOST_ROOT)/doc/src/images/*.png ]
+ : <location>html/images ;
+explicit css ;
+explicit images ;

Added: sandbox/tti/libs/tti/doc/TTIAcknowledgements.qbk
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/TTIAcknowledgements.qbk 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1,24 @@
+[section:tti_acknowledgments Acknowledgments]
+
+The TTI library came out of my effort to take the
+type_traits_ext part of the unfinished Concept Traits
+Library and expand it. So my first thanks go to
+Terje Slettebo and Tobias Schwinger, the authors of
+the CTL. I have taken, and hopefully improved upon,
+the ideas and implementation in that library, and added
+some needed new functionality.
+
+I would also like to thank Joel Falcou for
+his help and his introspection work.
+
+Two of the introspection templates are taken from the MPL and
+lifted into my library under a different name for the sake
+of orthoganality, so I would like to thank Aleksey Gurtovoy,
+David Abrahams for that library, and Daniel Walker for work on
+those introspection macros.
+
+Finally thanks to Anthony Williams for supplying a workaround
+for a Visual C++ bug which is needed for introspecting member
+data where the type of the member data is a compound type.
+
+[endsect]

Added: sandbox/tti/libs/tti/doc/TTIDetail.qbk
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/TTIDetail.qbk 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1,3 @@
+[section:tti_detail Macros]
+
+[endsect]

Added: sandbox/tti/libs/tti/doc/TTIFunctionality.qbk
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/TTIFunctionality.qbk 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1,79 @@
+[section:tti_functionality General Functionality]
+
+The elements which a template metaprogrammer might be interested in finding
+out about at compile time about a type are:
+
+# Does it have a nested type with a particular name ?
+# Does it have a nested type with a particular name which is a typedef for a particular type ?
+# Does it have a nested class template with a particular name ?
+# Does it have a nested class template with a particular name and a particular signature ?
+# Does it have a function member with a particular name and a particular signature ?
+# Does it have a data member with a particular name and of a particular type ?
+# Does it have a static function member with a particular name and a particular signature ?
+# Does it have a static data member with a particular name and of a particular type ?
+
+These are the compile-time questions which the TTI library answers.
+
+All of the questions above attempt to find an answer about an inner element with
+a particular name. In order to do this using template metaprogramming, macros are used
+so that the name of the inner element can be passed to the macro. The macro will then
+generate an appropriate metafunction, which the template metaprogrammer can then use to
+query the information that is needed. The name itself is always passed to the macro as a
+macro parameter, but other macro parameters may be needed also in some cases.
+
+All of the macros start with the prefix TTI_, create their metafunctions in the top-level
+tti namespace, and come in two forms:
+
+# In the simplest form the 'name' is used directly to generate the name of the metafunction.
+ The 'name' is appended to the name of the macro, with the TTI_ prefix removed, a final
+ underscore added, and the macro part of the name in lower case. As an example, for the macro
+ TTI_HAS_TYPE(MyType) the name of the metafunction is 'tti::has_type_MyType' and it will look
+ for an inner type called 'MyType'.
+# In the slightly more complicated form the macro starts with TTI\_TRAIT\_ and a 'trait' name is
+ passed as the first parameter, with the 'name' as the second parameter. The 'trait' serves
+ only to completely name the metafunction in the tti namespace. As an example, for the macro
+ TTI_TRAIT_HAS_TYPE(MyTrait,MyType) the name of the metafunction is 'tti::MyTrait' and it will
+ look for an inner type called 'MyType'.
+
+It is imporant to realize two things. First that any given metafunction generated, when introspecting
+a particular inner element, can be reused for any combination of template parameters which involve the
+same type of inner element. Second that once a metafunction is generated, attempting to generate another
+metafunction of the same name will create ODR violations since two C++ constructs with the same name/type
+in the same namespace will have been created. This second possibility has much less chance of occurence
+if you use the simple form of each macro and just reuse the metafunction if you are querying for two
+entities of the same name in different enclosing types or possibly in the same enclosing type but with
+different signatures.
+
+[section:tti_reason Reason for Library]
+
+In the Boost Type Traits library there is compile time functionality for
+querying information about a C++ type. This information is very useful
+during template metaprogramming and forms the basis, along with the
+constructs of the Boost MPL library, and some other compile time
+libraries, for much of the template metaprogramming in Boost.
+
+One area which is mostly missing in the Type Traits library is the ability
+to determine what C++ inner elements are part of a type, where the inner
+element may be a nested type, function or data member, static function or
+static data member, or class template.
+
+There has been some of this functionality in Boost, both in already existing
+libraries and in libraries on which others have worked but which were
+never submitted for acceptance into Boost. An example with an existing Boost
+library is Boost MPL, where there is functionality, in the form of macros,
+to determine whether an enclosing type has a particular nested type or nested
+class template. An example with a library which was never submitted to Boost
+is the Concept Traits Library from which much of the functionality of this
+library, related to type traits, was taken and improved upon.
+
+It may also be possible that some other Boost libraries, highly dependent
+on advanced template metaprogramming techniques, also have internal
+functionality to query a type's elements at compile time. But to the best
+of my knowledge this sort of functionality has never been incorporated in
+a single Boost library. This library is an attempt to do so, and to bring
+a recognizable set of interfaces to compile-time type introspection to Boost
+so that other metaprogramming libraries can use them for their own needs.
+
+[endsect]
+
+[endsect]

Added: sandbox/tti/libs/tti/doc/TTIHistory.qbk
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/TTIHistory.qbk 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1,7 @@
+[section:tti_history History]
+
+Version 1.0
+
+Initial version of the libary.
+
+[endsect]

Added: sandbox/tti/libs/tti/doc/TTIIntroduction.qbk
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/TTIIntroduction.qbk 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1,59 @@
+[section:tti_intro Introduction]
+
+Welcome to the Type Traits Introspection library version 1.0 .
+
+The Type Traits Introspection library, or TTI for short, is a library
+of macros generating metafunctions, and a set of metafunctions themselves,
+which provide the ability to introspect by name the elements of a type at
+compile time.
+
+The name of the library is chosen because the library offers
+compile time functionality on a type, as does the Boost Type Traits library,
+and because the functionality the library offers is the ability to introspect,
+or query, a type about the existence of a specific element.
+
+I use the word "introspect" in a very broad sense here. Normally language
+introspection means asking for information to be initially returned by name.
+In the TTI library one must always supply the name, and use the functionality
+for the correct type of element to find out if the particular named entity exists.
+
+The functionality of the library may be summed up as:
+
+# Provide the means to introspect a type at compile time
+ using a set of macros. Each macro takes the name of the
+ type's element and generates a metafunction which can be
+ subsequently invoked to determine whether or not the
+ element exists within the type.
+# Provide corresponding metafunctions which can operate
+ on each of the metafunctions generated by the set of
+ macros. These secondary metafunctions provide
+ the same set of introspection as the primary ones but
+ allow nested types, which do not actually have to exist,
+ to be passed in template parameters without producing
+ a compiler error.
+
+The library is a header only library.
+
+There are two separate headers in the library,
+divided depending on whether or not the library
+functionality supporting variadic macros is to be used.
+
+# The main header, which does not require using the library
+support for variadic macros, is 'TTIntrospection.hpp'.
+# The secondary header, which uses a very small subset of the
+library functionality, providing an alternate use of a particular
+macro with variadic macro support, is 'TTIntrospectionVM.hpp'.
+
+The library is dependent on Boost PP, Boost MPL,
+Boost Type Traits, and Boost Function Types.
+
+If the secondary header is used the library is also dependent
+on the variadic_macro_data library currently in the sandbox.
+If the secondary header is not used there is no need to download
+the variadic_macro_data library and use it.
+
+Since the dependencies of the library are all header only
+libraries, there is no need to build anything in order to use
+the TTI library.
+
+[endsect]

Added: sandbox/tti/libs/tti/doc/TTIReference.qbk
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/TTIReference.qbk 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1 @@
+[xinclude TypeTraitsIntrospectionReference.xml]

Added: sandbox/tti/libs/tti/doc/TTITerminology.qbk
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/TTITerminology.qbk 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1,21 @@
+[section:tti_terminology Terminology]
+
+The term "enclosing type" refers to the type which is being introspected.
+This type is always a user-defined class, struct, or union.
+
+The term "inner xxx", where xxx is some element of the enclosing type,
+refers to either a type, template, function, or data within the enclosing
+type. The term "inner element" also refers to these entities.
+
+I use the term "nested type" to refer to a type within another type.
+I use the term "function member" or "data member" to refer to non-static
+functions or data that are part of the enclosing type.
+I use the term "static function" or "static data" to refer to static
+functions or data that are part of the enclosing type.
+I use the term "class template member" to refer to a class template
+nested within the enclosing type.
+
+Other terminology may be just as valid for the notion of C++ language
+elements within a type, but I have chosen these terms to be consistent.
+
+[endsect]

Added: sandbox/tti/libs/tti/doc/TypeTraitsIntrospection.qbk
==============================================================================
--- (empty file)
+++ sandbox/tti/libs/tti/doc/TypeTraitsIntrospection.qbk 2010-12-27 00:22:13 EST (Mon, 27 Dec 2010)
@@ -0,0 +1,19 @@
+[library The Type Traits Introspection Library
+ [quickbook 1.5]
+ [version 1.0]
+ [id tti]
+ [dirname tti]
+ [copyright 2010 Tropic Software East Inc]
+ [purpose Compile time introspection of a type]
+ [category generic]
+ [authors [Diener, Edward]]
+ [source-mode c++]
+]
+
+[include TTIIntroduction.qbk]
+[include TTITerminology.qbk]
+[include TTIFunctionality.qbk]
+[include TTIDetail.qbk]
+[include TTIReference.qbk]
+[include TTIHistory.qbk]
+[include TTIAcknowledgements.qbk]

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