--- /dev/null
+// 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 <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>
+
+#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<
+ typename is_function<T>::type,
+ sizer<typename encode_type<V, T>::type> >::type encode(T&);
+
+ template<class V, class T>
+ typename disable_if<
+ typename is_function<T>::type,
+ 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::mpl::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,mpl::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::mpl::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,mpl::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::mpl::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::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;\
+ };
+#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::mpl::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::mpl::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::mpl::size_t<0> > >::type type;\
+ };
+#endif
+
+#endif//BOOST_TYPEOF_COMPLIANT_TYPEOF_IMPL_HPP_INCLUDED
projects / rsem.git / blobdiff