typeof_impl.hpp File Reference

#include <boost/mpl/size_t.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/typeof/encode_decode.hpp>
#include <boost/typeof/vector.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/utility/enable_if.hpp>

Include dependency graph for typeof_impl.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	boost::type_of::sizer< T >
struct	boost::type_of::decode_begin< V >
struct	boost::type_of::offset_vector< V, Offset >
struct	boost::type_of::push_back< boost::type_of::offset_vector< V, Offset >, T >
struct	boost::type_of::push_back< boost::type_of::offset_vector< V, mpl::size_t< 0 > >, T >

Namespaces
	boost
	Duration formatting facet for input.
	boost::type_of

Macros
#define	BOOST_TYPEOF_VECTOR(n)   BOOST_PP_CAT(boost::type_of::vector, n)
#define	BOOST_TYPEOF_sizer_item(z, n, _)   char item ## n[V::item ## n ::value];
#define	BOOST_TYPEOF_TYPEITEM(z, n, expr)   boost::mpl::size_t<sizeof(boost::type_of::encode<BOOST_TYPEOF_VECTOR(0)<> >(expr).item ## n)>
#define	BOOST_TYPEOF_ENCODED_VECTOR(Expr)
#define	BOOST_TYPEOF(Expr)   boost::type_of::decode_begin<BOOST_TYPEOF_ENCODED_VECTOR(Expr) >::type
#define	BOOST_TYPEOF_TPL   typename BOOST_TYPEOF
#define	BOOST_TYPEOF_NESTED_TYPEITEM(z, n, expr)
#define	BOOST_TYPEOF_FRACTIONTYPE()   typedef _typeof_encode_fraction<self_t::iteration> fraction_type;
#define	BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)
#define	BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name, expr)
#define	BOOST_TYPEOF_NESTED_TYPEDEF(name, expr)

Functions
template<class V , class T >
enable_if< typename is_function< T >::type, sizer < typename encode_type< V, T > ::type > >::type	boost::type_of::encode (T &)
template<class V , class T >
disable_if< typename is_function< T >::type, sizer < typename encode_type< V, T > ::type > >::type	boost::type_of::encode (const T &)

Macro Definition Documentation

#define BOOST_TYPEOF

(

Expr

)

boost::type_of::decode_begin<BOOST_TYPEOF_ENCODED_VECTOR(Expr) >::type

#define BOOST_TYPEOF_ENCODED_VECTOR

(

Expr

)

Value:

BOOST_TYPEOF_VECTOR(BOOST_TYPEOF_LIMIT_SIZE)<                           \
        BOOST_PP_ENUM(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_TYPEITEM, Expr) \
    >

#define BOOST_TYPEOF_FRACTIONTYPE

(

)

typedef _typeof_encode_fraction<self_t::iteration> fraction_type;

#define BOOST_TYPEOF_NESTED_TYPEDEF	(		name,
			expr
	)

Value:

struct name {\
        BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
        typedef boost::type_of::decode_type<_typeof_fraction_iter<boost::mpl::size_t<0> > >::type type;\
    };

#define BOOST_TYPEOF_NESTED_TYPEDEF_IMPL

(

expr

)

Value:

template<int _Typeof_Iteration>\
        struct _typeof_encode_fraction {\
            typedef _typeof_encode_fraction<_Typeof_Iteration> self_t;\
            BOOST_STATIC_CONSTANT(int,_typeof_encode_offset = (_Typeof_Iteration*BOOST_TYPEOF_LIMIT_SIZE));\
            typedef boost::type_of::offset_vector<BOOST_TYPEOF_VECTOR(0)<>,boost::mpl::size_t<self_t::_typeof_encode_offset> > _typeof_start_vector;\
            BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM,expr)\
        };\
        template<typename Pos>\
        struct _typeof_fraction_iter {\
            typedef _typeof_fraction_iter<Pos> self_t;\
            BOOST_STATIC_CONSTANT(int,pos=(Pos::value));\
            BOOST_STATIC_CONSTANT(int,iteration=(pos/BOOST_TYPEOF_LIMIT_SIZE));\
            BOOST_STATIC_CONSTANT(int,where=pos%BOOST_TYPEOF_LIMIT_SIZE);\
            BOOST_TYPEOF_FRACTIONTYPE()\
            typedef typename boost::type_of::v_iter<fraction_type,boost::mpl::int_<self_t::where> >::type type;\
            typedef _typeof_fraction_iter<typename Pos::next> next;\
        };

#define BOOST_TYPEOF_NESTED_TYPEDEF_TPL	(		name,
			expr
	)

Value:

struct name {\
        BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
        typedef typename boost::type_of::decode_type<_typeof_fraction_iter<boost::mpl::size_t<0> > >::type type;\
    };

#define BOOST_TYPEOF_NESTED_TYPEITEM	(		z,
			n,
			expr
	)

Value:

BOOST_STATIC_CONSTANT(int,BOOST_PP_CAT(value,n) = sizeof(boost::type_of::encode<_typeof_start_vector>(expr).item ## n));\
    typedef boost::mpl::size_t<BOOST_PP_CAT(self_t::value,n)> BOOST_PP_CAT(item,n);

#define BOOST_TYPEOF_sizer_item	(		z,
			n,
			_
	)		char item ## n[V::item ## n ::value];

#define BOOST_TYPEOF_TPL   typename BOOST_TYPEOF

#define BOOST_TYPEOF_TYPEITEM	(		z,
			n,
			expr
	)		boost::mpl::size_t<sizeof(boost::type_of::encode<BOOST_TYPEOF_VECTOR(0)<> >(expr).item ## n)>

#define BOOST_TYPEOF_VECTOR

(

n

)

BOOST_PP_CAT(boost::type_of::vector, n)