FM / typeof

/usr/include/boost/typeof

Name	Size	Mode	Actions
dmc/	-	0755	rm
msvc/	-	0755	rm
std/	-	0755	rm
constant.hpp	492	0644	edit dl rm
decltype.hpp	1047	0644	edit dl rm
encode_decode.hpp	1535	0644	edit dl rm
encode_decode_params.hpp	1342	0644	edit dl rm
incr_registration_group.hpp	528	0644	edit dl rm
integral_template_param.hpp	3693	0644	edit dl rm
int_encoding.hpp	3348	0644	edit dl rm
message.hpp	301	0644	edit dl rm
modifiers.hpp	4837	0644	edit dl rm
native.hpp	1413	0644	edit dl rm
pointers_data_members.hpp	1155	0644	edit dl rm
register_functions.hpp	2535	0644	edit dl rm
register_functions_iterate.hpp	4598	0644	edit dl rm
register_fundamental.hpp	2091	0644	edit dl rm
register_mem_functions.hpp	1131	0644	edit dl rm
template_encoding.hpp	6269	0644	edit dl rm
template_template_param.hpp	6299	0644	edit dl rm
typeof.hpp	6792	0644	edit dl rm
typeof_impl.hpp	7454	0644	edit dl rm
type_encoding.hpp	1459	0644	edit dl rm
type_template_param.hpp	1473	0644	edit dl rm
unsupported.hpp	815	0644	edit dl rm
vector.hpp	5479	0644	edit dl rm
vector50.hpp	216341	0644	edit dl rm
vector100.hpp	666911	0644	edit dl rm
vector150.hpp	1367011	0644	edit dl rm
vector200.hpp	2328744	0644	edit dl rm

Edit: /usr/include/boost/typeof/typeof_impl.hpp (7454B)

#ifndef BOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED
#define BOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED

#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/typeof/constant.hpp>
#include <boost/typeof/encode_decode.hpp>
#include <boost/typeof/vector.hpp>
#include <boost/type_traits/enable_if.hpp>
#include <boost/type_traits/is_function.hpp>
#include <cstddef> // for std::size_t

#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];

namespace boost { namespace type_of {
    template<class V>
    struct sizer
    {
        // char item0[V::item0::value];
        // char item1[V::item1::value];
        // ...

BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_sizer_item, ~)
    };
}}

#undef BOOST_TYPEOF_sizer_item

//
namespace boost { namespace type_of {
# ifdef BOOST_NO_SFINAE
    template<class V, class T>
    sizer<typename encode_type<V, T>::type> encode(const T&);
# else
    template<class V, class T>
    typename enable_if_<
        is_function<T>::value,
        sizer<typename encode_type<V, T>::type> >::type encode(T&);

template<class V, class T>
    typename enable_if_<
        !is_function<T>::value,
        sizer<typename encode_type<V, T>::type> >::type encode(const T&);
# endif
}}
//
namespace boost { namespace type_of {

template<class V>
    struct decode_begin
    {
        typedef typename decode_type<typename V::begin>::type type;
    };
}}

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

#define BOOST_TYPEOF_ENCODED_VECTOR(Expr)                                   \
    BOOST_TYPEOF_VECTOR(BOOST_TYPEOF_LIMIT_SIZE)<                           \
        BOOST_PP_ENUM(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_TYPEITEM, Expr) \
    >

#define BOOST_TYPEOF(Expr)\
    boost::type_of::decode_begin<BOOST_TYPEOF_ENCODED_VECTOR(Expr) >::type

#define BOOST_TYPEOF_TPL typename BOOST_TYPEOF

//offset_vector is used to delay the insertion of data into the vector in order to allow
//encoding to be done in many steps
namespace boost { namespace type_of {
    template<typename V,typename Offset>
    struct offset_vector {
    };

template<class V,class Offset,class T>
    struct push_back<boost::type_of::offset_vector<V,Offset>,T> {
        typedef offset_vector<V,typename Offset::prior> type;
    };

template<class V,class T>
    struct push_back<boost::type_of::offset_vector<V,constant<std::size_t,0> >,T> {
        typedef typename push_back<V,T>::type type;
    };
}}

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

#ifdef __DMC__
#define BOOST_TYPEOF_NESTED_TYPEITEM_2(z,n,expr)\
    typedef typename _typeof_encode_fraction<iteration>::BOOST_PP_CAT(item,n) BOOST_PP_CAT(item,n);

#define BOOST_TYPEOF_FRACTIONTYPE()\
    BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM_2,_)\
    typedef _typeof_fraction_iter<Pos> fraction_type;
#else
#define BOOST_TYPEOF_FRACTIONTYPE()\
    typedef _typeof_encode_fraction<self_t::iteration> fraction_type;
#endif

#ifdef __BORLANDC__
namespace boost { namespace type_of {
    template<typename Pos,typename Iter>
    struct generic_typeof_fraction_iter {
        typedef generic_typeof_fraction_iter<Pos,Iter> self_t;
        static const int pos=(Pos::value);
        static const int iteration=(pos/5);
        static const int where=pos%5;
        typedef typename Iter::template _apply_next<self_t::iteration>::type fraction_type;
        typedef generic_typeof_fraction_iter<typename Pos::next,Iter> next;
        typedef typename v_iter<fraction_type,constant<int, self_t::where> >::type type;
    };
}}
#define BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr) \
        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::type_of::constant<std::size_t,self_t::_typeof_encode_offset> > _typeof_start_vector;\
            BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM,expr)\
            template<int Next>\
            struct _apply_next {\
                typedef _typeof_encode_fraction<Next> type;\
            };\
        };\
        template<typename Pos>\
        struct _typeof_fraction_iter {\
            typedef boost::type_of::generic_typeof_fraction_iter<Pos,_typeof_encode_fraction<0> > self_t;\
            typedef typename self_t::next next;\
            typedef typename self_t::type type;\
        };
#else
#define BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr) \
        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::type_of::constant<std::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::type_of::constant<int,self_t::where> >::type type;\
            typedef _typeof_fraction_iter<typename Pos::next> next;\
        };
#endif
#ifdef __MWERKS__

# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
template<typename T>\
struct BOOST_PP_CAT(_typeof_template_,name) {\
    BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
    typedef typename boost::type_of::decode_type<_typeof_fraction_iter<boost::type_of::constant<std::size_t,0> > >::type type;\
};\
typedef BOOST_PP_CAT(_typeof_template_,name)<int> name;

# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) BOOST_TYPEOF_NESTED_TYPEDEF(name,expr)

#else
# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
    struct name {\
        BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
        typedef typename boost::type_of::decode_type<_typeof_fraction_iter<boost::type_of::constant<std::size_t,0> > >::type type;\
    };

# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
    struct name {\
        BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\
        typedef boost::type_of::decode_type<_typeof_fraction_iter<boost::type_of::constant<std::size_t,0> > >::type type;\
    };
#endif

#endif//BOOST_TYPEOF_COMPLIANT_TYPEOF_IMPL_HPP_INCLUDED

// Copyright (C) 2004, 2005 Arkadiy Vertleyb // Copyright (C) 2005 Peder Holt // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED #define BOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED #include #include #include #include #include #include #include // for std::size_t #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]; namespace boost { namespace type_of { template struct sizer { // char item0[V::item0::value]; // char item1[V::item1::value]; // ... BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_sizer_item, ~) }; }} #undef BOOST_TYPEOF_sizer_item // namespace boost { namespace type_of { # ifdef BOOST_NO_SFINAE template sizer::type> encode(const T&); # else template typename enable_if_< is_function::value, sizer::type> >::type encode(T&); template typename enable_if_< !is_function::value, sizer::type> >::type encode(const T&); # endif }} // namespace boost { namespace type_of { template struct decode_begin { typedef typename decode_type::type type; }; }} #define BOOST_TYPEOF_TYPEITEM(z, n, expr)\ boost::type_of::constant >(expr).item ## n)> #define BOOST_TYPEOF_ENCODED_VECTOR(Expr) \ BOOST_TYPEOF_VECTOR(BOOST_TYPEOF_LIMIT_SIZE)< \ BOOST_PP_ENUM(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_TYPEITEM, Expr) \ > #define BOOST_TYPEOF(Expr)\ boost::type_of::decode_begin::type #define BOOST_TYPEOF_TPL typename BOOST_TYPEOF //offset_vector is used to delay the insertion of data into the vector in order to allow //encoding to be done in many steps namespace boost { namespace type_of { template struct offset_vector { }; template struct push_back,T> { typedef offset_vector type; }; template struct push_back >,T> { typedef typename push_back::type type; }; }} #define BOOST_TYPEOF_NESTED_TYPEITEM(z, n, expr)\ BOOST_STATIC_CONSTANT(int,BOOST_PP_CAT(value,n) = sizeof(boost::type_of::encode<_typeof_start_vector>(expr).item ## n));\ typedef boost::type_of::constant BOOST_PP_CAT(item,n); #ifdef __DMC__ #define BOOST_TYPEOF_NESTED_TYPEITEM_2(z,n,expr)\ typedef typename _typeof_encode_fraction::BOOST_PP_CAT(item,n) BOOST_PP_CAT(item,n); #define BOOST_TYPEOF_FRACTIONTYPE()\ BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM_2,_)\ typedef _typeof_fraction_iter fraction_type; #else #define BOOST_TYPEOF_FRACTIONTYPE()\ typedef _typeof_encode_fraction fraction_type; #endif #ifdef __BORLANDC__ namespace boost { namespace type_of { template struct generic_typeof_fraction_iter { typedef generic_typeof_fraction_iter self_t; static const int pos=(Pos::value); static const int iteration=(pos/5); static const int where=pos%5; typedef typename Iter::template _apply_next::type fraction_type; typedef generic_typeof_fraction_iter next; typedef typename v_iter >::type type; }; }} #define BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr) \ template\ 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::type_of::constant > _typeof_start_vector;\ BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM,expr)\ template\ struct _apply_next {\ typedef _typeof_encode_fraction type;\ };\ };\ template\ struct _typeof_fraction_iter {\ typedef boost::type_of::generic_typeof_fraction_iter > self_t;\ typedef typename self_t::next next;\ typedef typename self_t::type type;\ }; #else #define BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr) \ template\ 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::type_of::constant > _typeof_start_vector;\ BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE,BOOST_TYPEOF_NESTED_TYPEITEM,expr)\ };\ template\ struct _typeof_fraction_iter {\ typedef _typeof_fraction_iter 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 >::type type;\ typedef _typeof_fraction_iter next;\ }; #endif #ifdef __MWERKS__ # define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \ template\ struct BOOST_PP_CAT(_typeof_template_,name) {\ BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\ typedef typename boost::type_of::decode_type<_typeof_fraction_iter > >::type type;\ };\ typedef BOOST_PP_CAT(_typeof_template_,name) name; # define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) #else # define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \ struct name {\ BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\ typedef typename boost::type_of::decode_type<_typeof_fraction_iter > >::type type;\ }; # define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \ struct name {\ BOOST_TYPEOF_NESTED_TYPEDEF_IMPL(expr)\ typedef boost::type_of::decode_type<_typeof_fraction_iter > >::type type;\ }; #endif #endif//BOOST_TYPEOF_COMPLIANT_TYPEOF_IMPL_HPP_INCLUDED