creduce 2.5.0
18e04be
Linux
cookie
4.13.0-37-generic
#42~16.04.1-Ubuntu SMP Wed Mar 7 16:03:28 UTC 2018
x86_64
***************************************************
pass_clang::template-non-type-arg-to-int has encountered a bug:
pass failed to modify the variant
Please consider tarring up
/home/ian/projects/debian/a-boost1.58/boost1.58-1.58.0+dfsg/creduce_bug_001
and mailing it to creduce-bugs@flux.utah.edu and we will try to fix
the bug.
This bug is not fatal, C-Reduce will continue to execute.
***************************************************
struct iterator_traits
;
template<typename _Iterator, typename _Container>
class __normal_iterator
{
};
;
extern "C++"
class exception
{
};
template<typename _Tp>
class new_allocator
{
public:
typedef int* pointer;
};
template<typename _Tp>
class allocator: public new_allocator<int>
{
public:
template<typename _Tp1>
struct rebind
{ typedef allocator other; };
};
template<typename _Arg1, typename _Arg2, typename _Result>
struct binary_function
;
;
template<typename _Alloc>
struct __alloc_traits
{
typedef int pointer;
template<typename _Tp>
struct rebind
{ typedef int other; };
};
template<typename _CharT, typename _Traits, typename _Alloc>
class Trans_NS___cxx11_basic_string
;
;
__extension__
namespace mpl_ { }
namespace mpl { using namespace mpl_;
}
namespace mpl_ {
}
namespace mpl {
}
class locale
{
class facet;
};
class locale::facet
{
};
template<typename _CharT>
class Trans_NS___cxx11_numpunct : public locale::facet
{
};
struct nil_t ;
namespace mpl_ {
template< bool C_ > struct bool_;
template< bool C_ > struct bool_
;
template< typename T, T N >
struct integral_c
{
};
}
template <class T, int val>
struct integral_constant : public mpl::integral_c<int, val>
{
};
template< typename T >
struct is_arithmetic_impl
;
template< typename T > struct is_arithmetic : public ::integral_constant<bool,::is_arithmetic_impl<T>::value> { public: };
template< typename T, typename U > struct is_same : public ::integral_constant<bool,false> { public: };
template <class T>
struct rvalue_ref_filter_rem_cv
;
template< typename T > struct remove_cv ;
struct is_pointer_impl
;
struct
error_info_injector:
public exception
{
};
template <typename T> struct alignment_of;
template <typename T>
struct alignment_of
;
template< typename T > struct is_void : public ::integral_constant<bool,false> { public: };
struct void_;
struct na
;
namespace mpl {
template<
typename T = na
, typename Tag = void_
>
struct lambda;
template<
bool C
, typename T1
, typename T2
>
struct if_c
;
template<
typename T1 = na
, typename T2 = na
, typename T3 = na
>
struct if_
;
}
namespace mpl {
template<
typename C = na
, typename F1 = na
>
struct eval_if
;
}
template <typename B, typename D>
struct is_base_and_derived_impl
;
template< typename Base, typename Derived > struct is_base_and_derived : public ::integral_constant<bool,::is_base_and_derived_impl<int,Derived>::value> { public: };
namespace mpl {
}
template<class OptionalPointee>
struct less_pointees_t : binary_function<OptionalPointee,OptionalPointee,bool>
{
};
class aligned_storage
;
template <typename T>
struct no_base ;
template <typename DerivedT, typename BaseT = no_base<DerivedT> >
struct safe_bool : BaseT
{
};
struct or_impl
;
template<
typename T1 = na
>
struct or_
;
template <class T>
struct is_abstract_imp
;
template< typename T > struct is_abstract : public ::integral_constant<bool,::is_abstract_imp<T>::value> { public: };
struct is_convertible_impl
;
template <bool trivial1, bool trivial2, bool abstract_target>
struct is_convertible_impl_select
;
template <typename From, typename To>
struct is_convertible_impl_dispatch_base
;
template <typename From, typename To>
struct is_convertible_impl_dispatch
;
template< typename From, typename To > struct is_convertible : public ::integral_constant<bool,::is_convertible_impl_dispatch<int,To>::value> { public: };
template <typename T = nil_t>
class match : public safe_bool<match<T> >
{
};
struct action_policy;
template <
typename ActionPolicyT = action_policy>
class scanner;
template <typename MatchPolicyT, typename T>
struct match_result
;
template <typename DerivedT>
struct parser
{
};
struct get_param
;
template <
typename DerivedT
, typename EmbedT
, typename T0 = nil_t
, typename T1 = nil_t
>
class rule_base;
template <
typename T0 = nil_t
, typename T1 = nil_t
, typename T2 = nil_t
>
class rule
{
typedef rule self_t;
typedef int base_t;
};
template <typename CharT>
class basic_chset;
template< class T > struct sp_member_access
{
typedef basic_chset<wchar_t> * type;
};
template<class T> class shared_ptr
{
public:
template<class Y>
explicit shared_ptr( Y * p )
;
typename sp_member_access< int >::type operator-> () const
;
};
template <typename DerivedT>
struct char_parser : public parser<int>
{
template <typename ScannerT>
struct result
;
};
template<typename _Tp, typename _Alloc>
struct _Vector_base
{
typedef int pointer;
};
template<typename _Tp, typename _Alloc = allocator<_Tp> >
class vector : protected _Vector_base<_Tp, int>
{
typedef _Vector_base<_Tp, int> _Base;
public:
typedef _Tp value_type;
typedef __normal_iterator<_Tp, int> iterator;
iterator
insert(iterator __position, const value_type& __x);
void
_M_insert_aux( const value_type& __x);
};
template<typename _Tp, typename _Alloc>
typename vector<_Tp, _Alloc>::iterator
vector<_Tp, _Alloc>::
insert(iterator __position, const value_type& __x)
{
_M_insert_aux( __x);
}
template<typename _Tp, typename _Alloc>
void
vector<_Tp, _Alloc>::
_M_insert_aux( const _Tp& __x)
{
}
template <typename CharT>
struct range {
range(int first, int last);
};
template <typename CharT>
class range_run {
public:
typedef range<CharT> range_t;
typedef vector<range_t> run_t;
void set(range_t const& r);
run_t run;
};
enum float_round_style
{
};
struct __numeric_limits_base
{
static const int digits = 0;
};
template<typename _Tp>
struct numeric_limits : public __numeric_limits_base
{
};
template <typename CharT>
void
range_run<CharT>::set(range<CharT> const& r)
{
typename run_t::iterator iter =
run.insert(iter, r);
}
template <typename CharT>
class basic_chset
{
public:
void set(CharT c);
private: range_run<CharT> rr;
};
template <typename CharT>
inline void
basic_chset<CharT>::set(CharT c)
{ rr.set(range<CharT>(c, c)); }
template <typename CharT = char>
class chset: public char_parser<int > {
public:
explicit chset(CharT arg_);
shared_ptr<basic_chset<CharT> > ptr;
};
wchar_t chset_p_ch;
inline chset<wchar_t>
chset_p(void)
{ return chset<wchar_t>(chset_p_ch); }
template <typename CharT>
inline chset<CharT>::chset(CharT arg_)
: ptr(new basic_chset<CharT>)
{ ptr->set(arg_); }
template<class T>
class integer_traits : public numeric_limits<int>
{
};
template<class T, int min_val, int max_val>
class integer_traits_base
{
static const int const_max = max_val;
};
template<>
class integer_traits<unsigned char>
: public numeric_limits<unsigned char>,
public integer_traits_base<unsigned char, 0, 0x7f * 2 + 1>
{ };
struct basic_traits;
template<class T>
struct implementation_level_impl ;
template<class T>
struct implementation_level :
public implementation_level_impl<const T>
{
};
namespace mpl {
template< typename SourceTag, typename TargetTag > struct numeric_cast
;
}
namespace mpl {
template< typename T > struct type_wrapper
;
typedef char (&yes_tag)[2];
;
template<
typename F, typename T1
>
struct apply_wrap1
;
template<
typename F, typename T1, typename T2
>
struct apply_wrap2
;
template<
typename F, typename T1, typename T2, typename T3, typename T4
>
struct apply_wrap5
;
}
namespace mpl {
template<
typename F
, typename Tag1
, typename Tag2
>
struct cast1st_impl
;
template<
typename F
, typename Tag1
, typename Tag2
>
struct cast2nd_impl
;
}
namespace mpl {
template<
typename Tag1
, typename Tag2
>
struct equal_to_impl
: if_c<
Tag1::value
, cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, int >
, cast1st_impl< equal_to_impl< int,int >,Tag1, int >
>::type
{
typedef
scanner<
> scanner_t;
};
}
template <typename T>
struct is_empty_impl
;
template< typename T > struct is_empty : public ::integral_constant<bool,::is_empty_impl<T>::value> { public: };
template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
struct compressed_pair_switch;
template <class T1, class T2, int Version> class compressed_pair_imp;
template <class T1, class T2>
class compressed_pair_imp<T1, T2, 0>
;
template <class T1, class T2>
class compressed_pair
: private ::compressed_pair_imp<T1, T2,
::compressed_pair_switch<
T1,
T2,
::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
::is_empty<T1>::value,
::is_empty<T2>::value>::value>
{
typedef T1 base;
};
template <class T>
class compressed_pair<T, T>
: private compressed_pair_imp<T, T,
::compressed_pair_switch<
T,
T,
::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
::is_empty<T>::value,
::is_empty<T>::value>::value>
{
typedef compressed_pair_imp<T, T,
::compressed_pair_switch<
T,
T,
::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
::is_empty<T>::value,
::is_empty<T>::value>::value> base;
};
template <typename S, typename BaseT>
class unary : public BaseT
{
};
template <typename T>
struct ureal_parser_policies;
template <typename T>
struct real_parser_policies : public ureal_parser_policies<T>
{
};
;
template< int Category > struct int_least_helper ;
template <int Bits>
struct exact_signed_base_helper;
template< int Bits >
struct int_t : public exact_signed_base_helper<Bits>
{
typedef typename int_least_helper
<
Bits <= 0
>::least least;
};
template< long long MaxValue >
struct int_max_value_t
;
template<typename Signature> class function;
struct function_buffer
;
struct function_ptr_tag ;
struct function_obj_tag ;
struct function_obj_ref_tag ;
struct function_allows_small_object_optimization
;
template<
typename FunctionPtr,
typename R
>
struct function_invoker0
;
template<
typename FunctionPtr,
typename R
>
struct void_function_invoker0
;
template<
typename FunctionObj,
typename R
>
struct function_obj_invoker0
;
template<
typename FunctionObj,
typename R
>
struct void_function_obj_invoker0
;
template<
typename FunctionObj,
typename R
>
struct function_ref_invoker0
;
template<
typename FunctionObj,
typename R
>
struct void_function_ref_invoker0
;
template<
typename FunctionPtr,
typename R
>
struct get_function_invoker0
;
template<
typename FunctionObj,
typename R
>
struct get_function_obj_invoker0
;
template<
typename FunctionObj,
typename R
>
struct get_function_ref_invoker0
;
template<typename Tag>
struct get_invoker0 ;
template<>
struct get_invoker0<function_ptr_tag>
;
template<>
struct get_invoker0<function_obj_tag>
;
template<>
struct get_invoker0<function_obj_ref_tag>
;
template<
typename T0
>
struct function_invoker1
;
template<
typename T0
>
struct void_function_invoker1
;
template<
typename T0
>
struct function_obj_invoker1
;
template<
typename T0
>
struct void_function_obj_invoker1
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1
>
struct function_invoker2
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1
>
struct void_function_invoker2
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1
>
struct function_ref_invoker2
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1
>
struct void_function_ref_invoker2
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1
>
struct function_mem_invoker2
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1
>
struct function_void_mem_invoker2
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1
>
struct get_function_invoker2
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1
>
struct get_function_ref_invoker2
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1
>
struct get_member_invoker2
;
template<typename Tag>
struct get_invoker2 ;
template<>
struct get_invoker2<function_ptr_tag>
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2
>
struct function_invoker3
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2
>
struct void_function_invoker3
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2
>
struct function_obj_invoker3
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2
>
struct void_function_obj_invoker3
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2
>
struct function_ref_invoker3
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2
>
struct void_function_ref_invoker3
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2
>
struct function_mem_invoker3
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2
>
struct function_void_mem_invoker3
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2
>
struct get_function_invoker3
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2
>
struct get_function_obj_invoker3
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2
>
struct get_function_ref_invoker3
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2
>
struct get_member_invoker3
;
template<typename Tag>
struct get_invoker3 ;
template<>
struct get_invoker3<function_ptr_tag>
;
template<
typename R ,
typename T0 , typename T1 , typename T2>
class function<R ( T0 , T1 , T2)>
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct function_invoker4
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct void_function_invoker4
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct function_obj_invoker4
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct void_function_obj_invoker4
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct function_ref_invoker4
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct void_function_ref_invoker4
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct function_mem_invoker4
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct function_void_mem_invoker4
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct get_function_invoker4
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct get_function_obj_invoker4
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct get_function_ref_invoker4
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3
>
struct get_member_invoker4
;
template<typename Tag>
struct get_invoker4 ;
template<>
struct get_invoker4<function_ptr_tag>
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct function_invoker5
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct void_function_invoker5
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct function_obj_invoker5
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct void_function_obj_invoker5
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct function_ref_invoker5
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct void_function_ref_invoker5
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct function_mem_invoker5
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct function_void_mem_invoker5
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct get_function_invoker5
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct get_function_obj_invoker5
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct get_function_ref_invoker5
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4
>
struct get_member_invoker5
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct function_obj_invoker6
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct void_function_obj_invoker6
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct function_ref_invoker6
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct void_function_ref_invoker6
;
template<
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct function_mem_invoker6
;
template<
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct function_void_mem_invoker6
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct get_function_invoker6
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct get_function_obj_invoker6
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct get_function_ref_invoker6
;
template<
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
>
struct get_member_invoker6
;
template<typename Tag>
struct get_invoker6 ;
template<>
struct get_invoker6<function_ptr_tag>
;
template<>
struct get_invoker6<function_obj_tag>
;
template<
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
>
struct void_function_obj_invoker8
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct function_invoker9
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct void_function_invoker9
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct function_obj_invoker9
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct void_function_obj_invoker9
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct function_ref_invoker9
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct void_function_ref_invoker9
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct function_mem_invoker9
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct function_void_mem_invoker9
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct get_function_invoker9
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct get_function_obj_invoker9
;
template<
typename FunctionObj,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct get_function_ref_invoker9
;
template<
typename MemberPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
>
struct get_member_invoker9
;
template<typename Tag>
struct get_invoker9 ;
template<>
struct get_invoker9<function_obj_ref_tag>
;
template<typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
>
struct function_invoker10
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
>
struct void_function_invoker10
;
template<
typename FunctionPtr,
typename R ,
typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
>
struct get_function_invoker10
;
class time_base
{
};
template<typename _CharT, typename _InIter>
class Trans_NS___cxx11_time_get : public locale::facet, public time_base
{
};
struct bidirectional_traversal_tag
;
struct random_access_traversal_tag
;
struct old_category_to_traversal
;
template <class Cat>
struct iterator_category_to_traversal
;
template <typename A, typename B>
struct is_interoperable
;
namespace mpl {
template<
typename T1 = na
>
struct and_
;
}
template <class Cond,
class Return>
struct enable_if
;
namespace mpl {
template<
typename F, typename T1 = na, typename T2 = na, typename T3 = na
, typename T4 = na, typename T5 = na
>
struct bind;
template<
typename T = na
>
struct protect : T
{
};
template<
typename T, typename U1, typename U2, typename U3, typename U4
, typename U5
>
struct resolve_bind_arg
;
template<
typename F
>
struct bind0
;
template<
typename F, typename U1, typename U2, typename U3, typename U4
, typename U5
>
struct resolve_bind_arg
;
template<
typename F
>
struct bind< F,na,na,na,na,na >
;
template<
typename F, typename T1
>
struct bind1
;
template<
typename F, typename T1, typename U1, typename U2, typename U3
, typename U4, typename U5
>
struct resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
>
;
;
template<
typename F, typename T1, typename T2, typename T3
>
struct bind3
;
template<
typename F, typename T1, typename T2, typename T3, typename T4
>
struct bind4
;
template<
typename F, typename T1, typename T2, typename T3, typename T4
, typename U1, typename U2, typename U3, typename U4, typename U5
>
struct resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
>
;
;
template<
typename F, typename T1, typename T2, typename T3, typename T4
>
struct bind5
;
}
namespace mpl {
template< typename T, typename fallback_ = mpl::bool_<true> > struct has_type ;
}
namespace mpl {
template< typename T, bool has_type_ >
struct quote_impl
;
template<
template< typename P1 > class F
, typename Tag = void_
>
struct quote1
;
template<
typename F
, typename Tag
>
struct lambda
;
template<
typename IsLE, typename Tag
, template< typename P1 > class F
, typename L1
>
struct le_result1
;
template<
typename Tag
, template< typename P1 > class F
, typename L1
>
struct le_result1< bool_<true>,Tag,F,L1 >
;
template<
template< typename P1, typename P2, typename P3 > class F
, typename T1, typename T2, typename T3
, typename Tag
>
struct lambda<
F< T1,T2,T3 >
, Tag
>
;
template<
typename F, typename T1, typename T2, typename T3
, typename Tag
>
struct lambda<
bind3< F,T1,T2,T3 >
, Tag
>
;
template<
typename F, typename T1, typename T2, typename T3, typename T4
, typename T5
, typename Tag
>
struct lambda<
bind< F,T1,T2,T3,T4,T5 >
, Tag
>
;
}
template< typename CategoryOrTraversal, typename Required >
struct is_traversal_at_least :
public is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, int >
{};
template <
class Facade1
, class Facade2
, class Return
>
struct enable_if_interoperable :
public enable_if<
is_interoperable< int, int >
, Return
>
{};
template <
class Facade1
, class Return
, class CategoryOrTraversal
, class Reference
, class Difference
, bool IsBidirectionalTraversal
, bool IsRandomAccessTraversal
>
class iterator_facade_base;
template <
class Derived
, class Value
, class CategoryOrTraversal
, class Reference
, class Difference
>
class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
;
template <
class Derived
, class Value
, class CategoryOrTraversal
, class Reference
, class Difference
>
class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
{
};
template <
class Derived
, class Value
, class CategoryOrTraversal
, class Reference = int&
, class Difference = long
>
class iterator_facade :
public iterator_facade_base<
int,
int,
CategoryOrTraversal,
int,
int,
is_traversal_at_least< CategoryOrTraversal, int >::value,
is_traversal_at_least< CategoryOrTraversal, int >::value
>
{
};
template <class T, class DefaultNullaryFn>
struct ia_dflt_help
;
template <
class Derived
, class Value
, class Reference
>
struct iterator_adaptor_base
;
struct iterator_pointee
;
