Remove Activ libs and includes

This commit is contained in:
John Colvin committed 2023-12-15 13:15:08 -05:00
1 parent 28ed30c944
commit 4b718994be
10967 files changed
-2306716

No files matched your search

-87
View File
@@ -1,87 +0,0 @@
#ifndef ACTIV_BOOST_BIND_APPLY_HPP_INCLUDED
#define ACTIV_BOOST_BIND_APPLY_HPP_INCLUDED
//
// apply.hpp
//
// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
//
// 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)
//
#include <ActivBoost/config.hpp>
namespace Boost
{
template<class R> struct apply
{
typedef R result_type;
#if !defined(ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(ACTIV_BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<class F, class... A> result_type operator()( F&& f, A&&... a ) const
{
return static_cast<F&&>( f )( static_cast<A&&>( a )... );
}
#else
template<class F> result_type operator()(F & f) const
{
return f();
}
template<class F, class A1> result_type operator()(F & f, A1 & a1) const
{
return f(a1);
}
template<class F, class A1, class A2> result_type operator()(F & f, A1 & a1, A2 & a2) const
{
return f(a1, a2);
}
template<class F, class A1, class A2, class A3> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3) const
{
return f(a1, a2, a3);
}
template<class F, class A1, class A2, class A3, class A4> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
{
return f(a1, a2, a3, a4);
}
template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
{
return f(a1, a2, a3, a4, a5);
}
template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
{
return f(a1, a2, a3, a4, a5, a6);
}
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
{
return f(a1, a2, a3, a4, a5, a6, a7);
}
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
{
return f(a1, a2, a3, a4, a5, a6, a7, a8);
}
template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
{
return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
}
#endif
};
} // namespace Boost
#endif // #ifndef ACTIV_BOOST_BIND_APPLY_HPP_INCLUDED
-69
View File
@@ -1,69 +0,0 @@
#ifndef ACTIV_BOOST_BIND_ARG_HPP_INCLUDED
#define ACTIV_BOOST_BIND_ARG_HPP_INCLUDED
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
//
// bind/arg.hpp
//
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
//
// 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)
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
#include <ActivBoost/config.hpp>
#include <ActivBoost/is_placeholder.hpp>
namespace Boost
{
template<bool Eq> struct _arg_eq
{
};
template<> struct _arg_eq<true>
{
typedef void type;
};
template< int I > struct arg
{
ACTIV_BOOST_CONSTEXPR arg()
{
}
template< class T > ACTIV_BOOST_CONSTEXPR arg( T const & /* t */, typename _arg_eq< I == is_placeholder<T>::value >::type * = 0 )
{
}
};
template< int I > ACTIV_BOOST_CONSTEXPR bool operator==( arg<I> const &, arg<I> const & )
{
return true;
}
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template< int I > struct is_placeholder< arg<I> >
{
enum _vt { value = I };
};
template< int I > struct is_placeholder< arg<I> (*) () >
{
enum _vt { value = I };
};
#endif
} // namespace Boost
#endif // #ifndef ACTIV_BOOST_BIND_ARG_HPP_INCLUDED
File diff suppressed because it is too large. Load diff
-117
View File
@@ -1,117 +0,0 @@
//
// bind/bind_cc.hpp - support for different calling conventions
//
// Do not include this header directly.
//
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
//
// 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)
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
template<class R>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) () ACTIV_BOOST_BIND_NOEXCEPT, _bi::list0>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) () ACTIV_BOOST_BIND_NOEXCEPT)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) () ACTIV_BOOST_BIND_NOEXCEPT;
typedef _bi::list0 list_type;
return _bi::bind_t<R, F, list_type> (f, list_type());
}
template<class R, class B1, class A1>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_1<A1>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_1<A1>::type list_type;
return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}
template<class R, class B1, class B2, class A1, class A2>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1, B2) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_2<A1, A2>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1, B2) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1, A2 a2)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1, B2) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}
template<class R,
class B1, class B2, class B3,
class A1, class A2, class A3>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1, B2, B3) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_3<A1, A2, A3>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1, B2, B3) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1, B2, B3) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}
template<class R,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1, B2, B3, B4) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_4<A1, A2, A3, A4>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1, B2, B3, B4) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1, B2, B3, B4) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}
template<class R,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1, B2, B3, B4, B5) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1, B2, B3, B4, B5) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1, B2, B3, B4, B5) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}
template<class R,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}
template<class R,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}
template<class R,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
template<class R,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t<R, ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8, B9) ACTIV_BOOST_BIND_NOEXCEPT, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
ACTIV_BOOST_BIND(ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9) ACTIV_BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef ACTIV_BOOST_BIND_ST R (ACTIV_BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9) ACTIV_BOOST_BIND_NOEXCEPT;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
@@ -1,228 +0,0 @@
//
// bind/bind_mf2_cc.hpp - member functions, type<> syntax
//
// Do not include this header directly.
//
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
// Copyright (c) 2008 Peter Dimov
//
// 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
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
// 0
template<class Rt2, class R, class T,
class A1>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) () ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf0)<R, T> F;
typedef typename _bi::list_av_1<A1>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}
template<class Rt2, class R, class T,
class A1>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) () const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf0)<R, T> F;
typedef typename _bi::list_av_1<A1>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}
// 1
template<class Rt2, class R, class T,
class B1,
class A1, class A2>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}
template<class Rt2, class R, class T,
class B1,
class A1, class A2>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}
// 2
template<class Rt2, class R, class T,
class B1, class B2,
class A1, class A2, class A3>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}
template<class Rt2, class R, class T,
class B1, class B2,
class A1, class A2, class A3>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}
// 3
template<class Rt2, class R, class T,
class B1, class B2, class B3,
class A1, class A2, class A3, class A4>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3,
class A1, class A2, class A3, class A4>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
// 4
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4, class A5>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4, class A5>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
// 5
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
// 6
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
// 7
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
// 8
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
ACTIV_BOOST_BIND(Boost::type<Rt2>, R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
@@ -1,441 +0,0 @@
//
// bind/bind_mf_cc.hpp - support for different calling conventions
//
// Do not include this header directly.
//
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
//
// 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)
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
// 0
template<class R, class T,
class A1>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) () ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf0)<R, T> F;
typedef typename _bi::list_av_1<A1>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}
template<class R, class T,
class A1>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) () const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf0)<R, T> F;
typedef typename _bi::list_av_1<A1>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}
template<class Rt2, class R, class T,
class A1>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) () ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf0)<R, T> F;
typedef typename _bi::list_av_1<A1>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}
template<class Rt2, class R, class T,
class A1>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) () const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf0)<R, T> F;
typedef typename _bi::list_av_1<A1>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}
// 1
template<class R, class T,
class B1,
class A1, class A2>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}
template<class R, class T,
class B1,
class A1, class A2>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}
template<class Rt2, class R, class T,
class B1,
class A1, class A2>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}
template<class Rt2, class R, class T,
class B1,
class A1, class A2>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
typedef typename _bi::list_av_2<A1, A2>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}
// 2
template<class R, class T,
class B1, class B2,
class A1, class A2, class A3>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}
template<class R, class T,
class B1, class B2,
class A1, class A2, class A3>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}
template<class Rt2, class R, class T,
class B1, class B2,
class A1, class A2, class A3>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}
template<class Rt2, class R, class T,
class B1, class B2,
class A1, class A2, class A3>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}
// 3
template<class R, class T,
class B1, class B2, class B3,
class A1, class A2, class A3, class A4>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
template<class R, class T,
class B1, class B2, class B3,
class A1, class A2, class A3, class A4>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3,
class A1, class A2, class A3, class A4>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3,
class A1, class A2, class A3, class A4>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
// 4
template<class R, class T,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4, class A5>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
template<class R, class T,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4, class A5>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4, class A5>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4,
class A1, class A2, class A3, class A4, class A5>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
// 5
template<class R, class T,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
template<class R, class T,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5, class A6>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5,
class A1, class A2, class A3, class A4, class A5, class A6>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
// 6
template<class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
template<class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6,
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
// 7
template<class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
template<class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
// 8
template<class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
template<class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t<R, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
template<class Rt2, class R, class T,
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
typename Boost::enable_if_c<!Boost::core::is_same<Rt2, R>::value,
_bi::bind_t<Rt2, _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
>::type ACTIV_BOOST_BIND(R (ACTIV_BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const ACTIV_BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
typedef _mfi::ACTIV_BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
@@ -1,345 +0,0 @@
//
// bind/bind_template.hpp
//
// Do not include this header directly.
//
// Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
//
// 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)
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
typedef typename result_traits<R, F>::type result_type;
result_type operator()()
{
list0 a;
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
result_type operator()() const
{
list0 a;
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1> result_type operator()(A1 & a1)
{
list1<A1 &> a(a1);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1> result_type operator()(A1 & a1) const
{
list1<A1 &> a(a1);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1> result_type operator()(A1 const & a1)
{
list1<A1 const &> a(a1);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1> result_type operator()(A1 const & a1) const
{
list1<A1 const &> a(a1);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
{
list2<A1 &, A2 &> a(a1, a2);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
{
list2<A1 &, A2 &> a(a1, a2);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
{
list2<A1 const &, A2 &> a(a1, a2);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
{
list2<A1 const &, A2 &> a(a1, a2);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
{
list2<A1 &, A2 const &> a(a1, a2);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
{
list2<A1 &, A2 const &> a(a1, a2);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
{
list2<A1 const &, A2 const &> a(a1, a2);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
{
list2<A1 const &, A2 const &> a(a1, a2);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
{
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
{
list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
{
list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
{
list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
{
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
{
list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
{
list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
{
list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
{
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
{
list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
{
list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
{
list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
{
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
{
list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
{
list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
{
list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
{
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
{
list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
{
list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
{
list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
{
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
{
list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
{
list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
{
list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
{
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
{
list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
{
list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
{
list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
#endif
template<class A> result_type eval(A & a)
{
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class A> result_type eval(A & a) const
{
ACTIV_BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
}
template<class V> void accept(V & v) const
{
#if !defined( ACTIV_BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( ACTIV_BOOST_BORLANDC )
using Boost::visit_each;
#endif
ACTIV_BOOST_BIND_VISIT_EACH(v, f_, 0);
l_.accept(v);
}
bool compare(this_type const & rhs) const
{
return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
}
private:
F f_;
L l_;
@@ -1,164 +0,0 @@
#ifndef ACTIV_BOOST_BIND_DETAIL_RESULT_TRAITS_HPP_INCLUDED
#define ACTIV_BOOST_BIND_DETAIL_RESULT_TRAITS_HPP_INCLUDED
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
//
// bind/detail/result_traits.hpp
//
// ActivBoost/bind.hpp support header, return type deduction
//
// Copyright 2006, 2020 Peter Dimov
//
// 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
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
#include <ActivBoost/config.hpp>
#if ACTIV_BOOST_CXX_VERSION >= 201700L
#include <functional>
#endif
namespace Boost
{
namespace _bi
{
template<class R, class F> struct result_traits
{
typedef R type;
};
struct unspecified {};
template<class F> struct result_traits<unspecified, F>
{
typedef typename F::result_type type;
};
template<class F> struct result_traits< unspecified, reference_wrapper<F> >
{
typedef typename F::result_type type;
};
#if ACTIV_BOOST_CXX_VERSION >= 201700L
template<class T> struct result_traits< unspecified, std::plus<T> >
{
typedef T type;
};
template<class T> struct result_traits< unspecified, std::minus<T> >
{
typedef T type;
};
template<class T> struct result_traits< unspecified, std::multiplies<T> >
{
typedef T type;
};
template<class T> struct result_traits< unspecified, std::divides<T> >
{
typedef T type;
};
template<class T> struct result_traits< unspecified, std::modulus<T> >
{
typedef T type;
};
template<class T> struct result_traits< unspecified, std::negate<T> >
{
typedef T type;
};
template<class T> struct result_traits< unspecified, std::equal_to<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::not_equal_to<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::greater<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::less<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::greater_equal<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::less_equal<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::logical_and<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::logical_or<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::logical_not<T> >
{
typedef bool type;
};
template<class T> struct result_traits< unspecified, std::bit_and<T> >
{
typedef T type;
};
template<class T> struct result_traits< unspecified, std::bit_or<T> >
{
typedef T type;
};
template<class T> struct result_traits< unspecified, std::bit_xor<T> >
{
typedef T type;
};
#if defined(ACTIV_BOOST_LIBSTDCXX_VERSION) && ACTIV_BOOST_LIBSTDCXX_VERSION < 40900
// libstdc++ 4.8 and below don't have std::bit_not
#else
template<class T> struct result_traits< unspecified, std::bit_not<T> >
{
typedef T type;
};
#endif
#endif
} // namespace _bi
} // namespace Boost
#endif // #ifndef ACTIV_BOOST_BIND_DETAIL_RESULT_TRAITS_HPP_INCLUDED
@@ -1,187 +0,0 @@
#ifndef ACTIV_BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
#define ACTIV_BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
//
// make_adaptable.hpp
//
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
//
// 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)
//
namespace Boost
{
namespace _bi
{
template<class R, class F> class af0
{
public:
typedef R result_type;
explicit af0(F f): f_(f)
{
}
result_type operator()()
{
return f_();
}
result_type operator()() const
{
return f_();
}
private:
F f_;
};
template<class R, class A1, class F> class af1
{
public:
typedef R result_type;
typedef A1 argument_type;
typedef A1 arg1_type;
explicit af1(F f): f_(f)
{
}
result_type operator()(A1 a1)
{
return f_(a1);
}
result_type operator()(A1 a1) const
{
return f_(a1);
}
private:
F f_;
};
template<class R, class A1, class A2, class F> class af2
{
public:
typedef R result_type;
typedef A1 first_argument_type;
typedef A2 second_argument_type;
typedef A1 arg1_type;
typedef A2 arg2_type;
explicit af2(F f): f_(f)
{
}
result_type operator()(A1 a1, A2 a2)
{
return f_(a1, a2);
}
result_type operator()(A1 a1, A2 a2) const
{
return f_(a1, a2);
}
private:
F f_;
};
template<class R, class A1, class A2, class A3, class F> class af3
{
public:
typedef R result_type;
typedef A1 arg1_type;
typedef A2 arg2_type;
typedef A3 arg3_type;
explicit af3(F f): f_(f)
{
}
result_type operator()(A1 a1, A2 a2, A3 a3)
{
return f_(a1, a2, a3);
}
result_type operator()(A1 a1, A2 a2, A3 a3) const
{
return f_(a1, a2, a3);
}
private:
F f_;
};
template<class R, class A1, class A2, class A3, class A4, class F> class af4
{
public:
typedef R result_type;
typedef A1 arg1_type;
typedef A2 arg2_type;
typedef A3 arg3_type;
typedef A4 arg4_type;
explicit af4(F f): f_(f)
{
}
result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4)
{
return f_(a1, a2, a3, a4);
}
result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4) const
{
return f_(a1, a2, a3, a4);
}
private:
F f_;
};
} // namespace _bi
template<class R, class F> _bi::af0<R, F> make_adaptable(F f)
{
return _bi::af0<R, F>(f);
}
template<class R, class A1, class F> _bi::af1<R, A1, F> make_adaptable(F f)
{
return _bi::af1<R, A1, F>(f);
}
template<class R, class A1, class A2, class F> _bi::af2<R, A1, A2, F> make_adaptable(F f)
{
return _bi::af2<R, A1, A2, F>(f);
}
template<class R, class A1, class A2, class A3, class F> _bi::af3<R, A1, A2, A3, F> make_adaptable(F f)
{
return _bi::af3<R, A1, A2, A3, F>(f);
}
template<class R, class A1, class A2, class A3, class A4, class F> _bi::af4<R, A1, A2, A3, A4, F> make_adaptable(F f)
{
return _bi::af4<R, A1, A2, A3, A4, F>(f);
}
} // namespace Boost
#endif // #ifndef ACTIV_BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
-403
View File
@@ -1,403 +0,0 @@
#ifndef ACTIV_BOOST_BIND_MEM_FN_HPP_INCLUDED
#define ACTIV_BOOST_BIND_MEM_FN_HPP_INCLUDED
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
//
// mem_fn.hpp - a generalization of std::mem_fun[_ref]
//
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
// Copyright (c) 2001 David Abrahams
// Copyright (c) 2003-2005 Peter Dimov
//
// 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)
//
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
//
#include <ActivBoost/config.hpp>
#include <ActivBoost/get_pointer.hpp>
#include <ActivBoost/detail/workaround.hpp>
namespace Boost
{
#if defined(ACTIV_BOOST_NO_VOID_RETURNS)
#define ACTIV_BOOST_MEM_FN_CLASS_F , class F
#define ACTIV_BOOST_MEM_FN_TYPEDEF(X)
namespace _mfi // mem_fun_impl
{
template<class V> struct mf
{
#define ACTIV_BOOST_MEM_FN_RETURN return
#define ACTIV_BOOST_MEM_FN_NAME(X) inner_##X
#define ACTIV_BOOST_MEM_FN_CC
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
#define ACTIV_BOOST_MEM_FN_CC __cdecl
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_STDCALL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
#define ACTIV_BOOST_MEM_FN_CC __stdcall
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_FASTCALL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
#define ACTIV_BOOST_MEM_FN_CC __fastcall
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#undef ACTIV_BOOST_MEM_FN_RETURN
}; // struct mf<V>
template<> struct mf<void>
{
#define ACTIV_BOOST_MEM_FN_RETURN
#define ACTIV_BOOST_MEM_FN_NAME(X) inner_##X
#define ACTIV_BOOST_MEM_FN_CC
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
#define ACTIV_BOOST_MEM_FN_CC __cdecl
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#ifdef ACTIV_BOOST_MEM_FN_ENABLE_STDCALL
#define ACTIV_BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
#define ACTIV_BOOST_MEM_FN_CC __stdcall
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#ifdef ACTIV_BOOST_MEM_FN_ENABLE_FASTCALL
#define ACTIV_BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
#define ACTIV_BOOST_MEM_FN_CC __fastcall
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#undef ACTIV_BOOST_MEM_FN_RETURN
}; // struct mf<void>
#undef ACTIV_BOOST_MEM_FN_CLASS_F
#undef ACTIV_BOOST_MEM_FN_TYPEDEF_F
#define ACTIV_BOOST_MEM_FN_NAME(X) X
#define ACTIV_BOOST_MEM_FN_NAME2(X) inner_##X
#define ACTIV_BOOST_MEM_FN_CC
#include <ActivBoost/bind/mem_fn_vw.hpp>
#undef ACTIV_BOOST_MEM_FN_NAME
#undef ACTIV_BOOST_MEM_FN_NAME2
#undef ACTIV_BOOST_MEM_FN_CC
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_cdecl
#define ACTIV_BOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
#define ACTIV_BOOST_MEM_FN_CC __cdecl
#include <ActivBoost/bind/mem_fn_vw.hpp>
#undef ACTIV_BOOST_MEM_FN_NAME
#undef ACTIV_BOOST_MEM_FN_NAME2
#undef ACTIV_BOOST_MEM_FN_CC
#endif
#ifdef ACTIV_BOOST_MEM_FN_ENABLE_STDCALL
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_stdcall
#define ACTIV_BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
#define ACTIV_BOOST_MEM_FN_CC __stdcall
#include <ActivBoost/bind/mem_fn_vw.hpp>
#undef ACTIV_BOOST_MEM_FN_NAME
#undef ACTIV_BOOST_MEM_FN_NAME2
#undef ACTIV_BOOST_MEM_FN_CC
#endif
#ifdef ACTIV_BOOST_MEM_FN_ENABLE_FASTCALL
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_fastcall
#define ACTIV_BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
#define ACTIV_BOOST_MEM_FN_CC __fastcall
#include <ActivBoost/bind/mem_fn_vw.hpp>
#undef ACTIV_BOOST_MEM_FN_NAME
#undef ACTIV_BOOST_MEM_FN_NAME2
#undef ACTIV_BOOST_MEM_FN_CC
#endif
} // namespace _mfi
#else // #ifdef ACTIV_BOOST_NO_VOID_RETURNS
#define ACTIV_BOOST_MEM_FN_CLASS_F
#define ACTIV_BOOST_MEM_FN_TYPEDEF(X) typedef X;
namespace _mfi
{
#define ACTIV_BOOST_MEM_FN_RETURN return
#define ACTIV_BOOST_MEM_FN_NAME(X) X
#define ACTIV_BOOST_MEM_FN_CC
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_cdecl
#define ACTIV_BOOST_MEM_FN_CC __cdecl
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_STDCALL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_stdcall
#define ACTIV_BOOST_MEM_FN_CC __stdcall
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_FASTCALL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_fastcall
#define ACTIV_BOOST_MEM_FN_CC __fastcall
#include <ActivBoost/bind/mem_fn_template.hpp>
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NAME
#endif
#undef ACTIV_BOOST_MEM_FN_RETURN
} // namespace _mfi
#undef ACTIV_BOOST_MEM_FN_CLASS_F
#undef ACTIV_BOOST_MEM_FN_TYPEDEF
#endif // #ifdef ACTIV_BOOST_NO_VOID_RETURNS
#define ACTIV_BOOST_MEM_FN_NAME(X) X
#define ACTIV_BOOST_MEM_FN_CC
#define ACTIV_BOOST_MEM_FN_NOEXCEPT
#include <ActivBoost/bind/mem_fn_cc.hpp>
#if defined( __cpp_noexcept_function_type ) || defined( _NOEXCEPT_TYPES_SUPPORTED )
# undef ACTIV_BOOST_MEM_FN_NOEXCEPT
# define ACTIV_BOOST_MEM_FN_NOEXCEPT noexcept
# include <ActivBoost/bind/mem_fn_cc.hpp>
#endif
#undef ACTIV_BOOST_MEM_FN_NAME
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NOEXCEPT
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_cdecl
#define ACTIV_BOOST_MEM_FN_CC __cdecl
#define ACTIV_BOOST_MEM_FN_NOEXCEPT
#include <ActivBoost/bind/mem_fn_cc.hpp>
#undef ACTIV_BOOST_MEM_FN_NAME
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NOEXCEPT
#endif
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_STDCALL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_stdcall
#define ACTIV_BOOST_MEM_FN_CC __stdcall
#define ACTIV_BOOST_MEM_FN_NOEXCEPT
#include <ActivBoost/bind/mem_fn_cc.hpp>
#undef ACTIV_BOOST_MEM_FN_NAME
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NOEXCEPT
#endif
#if defined(ACTIV_BOOST_MEM_FN_ENABLE_FASTCALL) && !defined(_M_X64)
#define ACTIV_BOOST_MEM_FN_NAME(X) X##_fastcall
#define ACTIV_BOOST_MEM_FN_CC __fastcall
#define ACTIV_BOOST_MEM_FN_NOEXCEPT
#include <ActivBoost/bind/mem_fn_cc.hpp>
#undef ACTIV_BOOST_MEM_FN_NAME
#undef ACTIV_BOOST_MEM_FN_CC
#undef ACTIV_BOOST_MEM_FN_NOEXCEPT
#endif
// data member support
namespace _mfi
{
template<class R, class T> class dm
{
public:
typedef R const & result_type;
typedef T const * argument_type;
private:
typedef R (T::*F);
F f_;
template<class U> R const & call(U & u, T const *) const
{
return (u.*f_);
}
template<class U> R const & call(U & u, void const *) const
{
return (get_pointer(u)->*f_);
}
public:
explicit dm(F f): f_(f) {}
R & operator()(T * p) const
{
return (p->*f_);
}
R const & operator()(T const * p) const
{
return (p->*f_);
}
template<class U> R const & operator()(U const & u) const
{
return call(u, &u);
}
#if !ACTIV_BOOST_WORKAROUND(ACTIV_BOOST_MSVC, <= 1300) && !ACTIV_BOOST_WORKAROUND(__MWERKS__, < 0x3200)
R & operator()(T & t) const
{
return (t.*f_);
}
R const & operator()(T const & t) const
{
return (t.*f_);
}
#endif
bool operator==(dm const & rhs) const
{
return f_ == rhs.f_;
}
bool operator!=(dm const & rhs) const
{
return f_ != rhs.f_;
}
};
} // namespace _mfi
template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
{
return _mfi::dm<R, T>(f);
}
} // namespace Boost
#endif // #ifndef ACTIV_BOOST_BIND_MEM_FN_HPP_INCLUDED
-103
View File
@@ -1,103 +0,0 @@
//
// bind/mem_fn_cc.hpp - support for different calling conventions
//
// Do not include this header directly.
//
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
//
// 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)
//
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
//
template<class R, class T> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf0)<R, T> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) () ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf0)<R, T>(f);
}
template<class R, class T> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf0)<R, T> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) () const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf0)<R, T>(f);
}
template<class R, class T, class A1> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf1)<R, T, A1> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1) ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf1)<R, T, A1>(f);
}
template<class R, class T, class A1> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf1)<R, T, A1> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1) const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf1)<R, T, A1>(f);
}
template<class R, class T, class A1, class A2> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf2)<R, T, A1, A2> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2) ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf2)<R, T, A1, A2>(f);
}
template<class R, class T, class A1, class A2> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2) const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2>(f);
}
template<class R, class T, class A1, class A2, class A3> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3) ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3>(f);
}
template<class R, class T, class A1, class A2, class A3> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3) const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4) ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4) const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5) ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5) const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6) ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6) const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7) ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7) const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::ACTIV_BOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (ACTIV_BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const ACTIV_BOOST_MEM_FN_NOEXCEPT)
{
return _mfi::ACTIV_BOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}
File diff suppressed because it is too large. Load diff
-130
View File
@@ -1,130 +0,0 @@
//
// bind/mem_fn_vw.hpp - void return helper wrappers
//
// Do not include this header directly
//
// Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
//
// 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)
//
// See http://www.boost.org/libs/bind/mem_fn.html for documentation.
//
template<class R, class T> struct ACTIV_BOOST_MEM_FN_NAME(mf0): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf0)<R, T, R (ACTIV_BOOST_MEM_FN_CC T::*) ()>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) ();
explicit ACTIV_BOOST_MEM_FN_NAME(mf0)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf0)<R, T, F>(f) {}
};
template<class R, class T> struct ACTIV_BOOST_MEM_FN_NAME(cmf0): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf0)<R, T, R (ACTIV_BOOST_MEM_FN_CC T::*) () const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) () const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf0)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf0)<R, T, F>(f) {}
};
template<class R, class T, class A1> struct ACTIV_BOOST_MEM_FN_NAME(mf1): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf1)<R, T, A1, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1)>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1);
explicit ACTIV_BOOST_MEM_FN_NAME(mf1)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf1)<R, T, A1, F>(f) {}
};
template<class R, class T, class A1> struct ACTIV_BOOST_MEM_FN_NAME(cmf1): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1) const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1) const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf1)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, F>(f) {}
};
template<class R, class T, class A1, class A2> struct ACTIV_BOOST_MEM_FN_NAME(mf2): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2)>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2);
explicit ACTIV_BOOST_MEM_FN_NAME(mf2)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, F>(f) {}
};
template<class R, class T, class A1, class A2> struct ACTIV_BOOST_MEM_FN_NAME(cmf2): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2) const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2) const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf2)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3> struct ACTIV_BOOST_MEM_FN_NAME(mf3): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3)>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
explicit ACTIV_BOOST_MEM_FN_NAME(mf3)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3> struct ACTIV_BOOST_MEM_FN_NAME(cmf3): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3) const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf3)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4> struct ACTIV_BOOST_MEM_FN_NAME(mf4): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4)>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
explicit ACTIV_BOOST_MEM_FN_NAME(mf4)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4> struct ACTIV_BOOST_MEM_FN_NAME(cmf4): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4) const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf4)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct ACTIV_BOOST_MEM_FN_NAME(mf5): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5)>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
explicit ACTIV_BOOST_MEM_FN_NAME(mf5)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct ACTIV_BOOST_MEM_FN_NAME(cmf5): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5) const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf5)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct ACTIV_BOOST_MEM_FN_NAME(mf6): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6)>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
explicit ACTIV_BOOST_MEM_FN_NAME(mf6)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct ACTIV_BOOST_MEM_FN_NAME(cmf6): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6) const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf6)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct ACTIV_BOOST_MEM_FN_NAME(mf7): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7)>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
explicit ACTIV_BOOST_MEM_FN_NAME(mf7)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct ACTIV_BOOST_MEM_FN_NAME(cmf7): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7) const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf7)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct ACTIV_BOOST_MEM_FN_NAME(mf8): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8)>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
explicit ACTIV_BOOST_MEM_FN_NAME(mf8)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
};
template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct ACTIV_BOOST_MEM_FN_NAME(cmf8): public mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (ACTIV_BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const>
{
typedef R (ACTIV_BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
explicit ACTIV_BOOST_MEM_FN_NAME(cmf8)(F f): mf<R>::ACTIV_BOOST_NESTED_TEMPLATE ACTIV_BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
};
@@ -1,74 +0,0 @@
#ifndef ACTIV_BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
#define ACTIV_BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
//
// bind/placeholders.hpp - _N definitions
//
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
// Copyright 2015 Peter Dimov
//
// 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
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
#include <ActivBoost/bind/arg.hpp>
#include <ActivBoost/config.hpp>
namespace Boost
{
namespace placeholders
{
#if defined(ACTIV_BOOST_BORLANDC) || defined(__GNUC__) && (__GNUC__ < 4)
inline Boost::arg<1> _1() { return Boost::arg<1>(); }
inline Boost::arg<2> _2() { return Boost::arg<2>(); }
inline Boost::arg<3> _3() { return Boost::arg<3>(); }
inline Boost::arg<4> _4() { return Boost::arg<4>(); }
inline Boost::arg<5> _5() { return Boost::arg<5>(); }
inline Boost::arg<6> _6() { return Boost::arg<6>(); }
inline Boost::arg<7> _7() { return Boost::arg<7>(); }
inline Boost::arg<8> _8() { return Boost::arg<8>(); }
inline Boost::arg<9> _9() { return Boost::arg<9>(); }
#elif !defined(ACTIV_BOOST_NO_CXX17_INLINE_VARIABLES)
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<1> _1;
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<2> _2;
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<3> _3;
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<4> _4;
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<5> _5;
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<6> _6;
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<7> _7;
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<8> _8;
ACTIV_BOOST_INLINE_CONSTEXPR Boost::arg<9> _9;
#else
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<1> _1;
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<2> _2;
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<3> _3;
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<4> _4;
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<5> _5;
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<6> _6;
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<7> _7;
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<8> _8;
ACTIV_BOOST_STATIC_CONSTEXPR Boost::arg<9> _9;
#endif
} // namespace placeholders
} // namespace Boost
#endif // #ifndef ACTIV_BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
-348
View File
@@ -1,348 +0,0 @@
#ifndef ACTIV_BOOST_BIND_PROTECT_HPP_INCLUDED
#define ACTIV_BOOST_BIND_PROTECT_HPP_INCLUDED
//
// protect.hpp
//
// Copyright 2002, 2020 Peter Dimov
// Copyright 2009 Steven Watanabe
//
// 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)
//
#include <ActivBoost/config.hpp>
#include <ActivBoost/config/workaround.hpp>
#include <utility>
namespace Boost
{
namespace _bi
{
#if !defined(ACTIV_BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(ACTIV_BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(ACTIV_BOOST_NO_CXX11_DECLTYPE) && !(defined(ACTIV_BOOST_GCC) && ACTIV_BOOST_GCC < 40600)
template<class T> struct protect_make_void
{
typedef void type;
};
template<class F, class E = void> struct protect_result_type
{
};
template<class F> struct protect_result_type< F, typename protect_make_void<typename F::result_type>::type >
{
typedef typename F::result_type result_type;
};
template<class F> class protected_bind_t: public protect_result_type<F>
{
private:
F f_;
public:
explicit protected_bind_t( F f ): f_( f )
{
}
template<class... A> auto operator()( A&&... a ) -> decltype( f_( std::forward<A>(a)... ) )
{
return f_( std::forward<A>(a)... );
}
template<class... A> auto operator()( A&&... a ) const -> decltype( f_( std::forward<A>(a)... ) )
{
return f_( std::forward<A>(a)... );
}
};
#else
template<class F> class protected_bind_t
{
private:
F f_;
public:
typedef typename F::result_type result_type;
explicit protected_bind_t(F f): f_(f)
{
}
result_type operator()()
{
return f_();
}
result_type operator()() const
{
return f_();
}
template<class A1> result_type operator()(A1 & a1)
{
return f_(a1);
}
template<class A1> result_type operator()(A1 & a1) const
{
return f_(a1);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1> result_type operator()(const A1 & a1)
{
return f_(a1);
}
template<class A1> result_type operator()(const A1 & a1) const
{
return f_(a1);
}
#endif
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
{
return f_(a1, a2);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
{
return f_(a1, a2);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
{
return f_(a1, a2);
}
template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
{
return f_(a1, a2);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
{
return f_(a1, a2);
}
template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
{
return f_(a1, a2);
}
template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
{
return f_(a1, a2);
}
template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
{
return f_(a1, a2);
}
#endif
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
{
return f_(a1, a2, a3);
}
template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
{
return f_(a1, a2, a3);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
{
return f_(a1, a2, a3);
}
template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
{
return f_(a1, a2, a3);
}
#endif
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
{
return f_(a1, a2, a3, a4);
}
template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
{
return f_(a1, a2, a3, a4);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
{
return f_(a1, a2, a3, a4);
}
template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
{
return f_(a1, a2, a3, a4);
}
#endif
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
{
return f_(a1, a2, a3, a4, a5);
}
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
{
return f_(a1, a2, a3, a4, a5);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
{
return f_(a1, a2, a3, a4, a5);
}
template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
{
return f_(a1, a2, a3, a4, a5);
}
#endif
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
{
return f_(a1, a2, a3, a4, a5, a6);
}
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
{
return f_(a1, a2, a3, a4, a5, a6);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
{
return f_(a1, a2, a3, a4, a5, a6);
}
template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
{
return f_(a1, a2, a3, a4, a5, a6);
}
#endif
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
{
return f_(a1, a2, a3, a4, a5, a6, a7);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
{
return f_(a1, a2, a3, a4, a5, a6, a7);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
{
return f_(a1, a2, a3, a4, a5, a6, a7);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
{
return f_(a1, a2, a3, a4, a5, a6, a7);
}
#endif
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
{
return f_(a1, a2, a3, a4, a5, a6, a7, a8);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
{
return f_(a1, a2, a3, a4, a5, a6, a7, a8);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
{
return f_(a1, a2, a3, a4, a5, a6, a7, a8);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
{
return f_(a1, a2, a3, a4, a5, a6, a7, a8);
}
#endif
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
{
return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
{
return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
}
#if !defined(ACTIV_BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
&& !ACTIV_BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
{
return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
{
return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
}
#endif
};
#endif
} // namespace _bi
template<class F> _bi::protected_bind_t<F> protect(F f)
{
return _bi::protected_bind_t<F>(f);
}
} // namespace Boost
#endif // #ifndef ACTIV_BOOST_BIND_PROTECT_HPP_INCLUDED
@@ -1,39 +0,0 @@
#ifndef ACTIV_BOOST_BIND_STD_PLACEHOLDERS_HPP_INCLUDED
#define ACTIV_BOOST_BIND_STD_PLACEHOLDERS_HPP_INCLUDED
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
// Copyright 2021 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <ActivBoost/is_placeholder.hpp>
#include <ActivBoost/config.hpp>
#if !defined(ACTIV_BOOST_NO_CXX11_HDR_FUNCTIONAL) && !defined(ACTIV_BOOST_NO_CXX11_DECLTYPE) && !defined(ACTIV_BOOST_NO_CXX11_HDR_TYPE_TRAITS)
#include <functional>
#include <type_traits>
namespace Boost
{
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_1)>::type > { enum _vt { value = 1 }; };
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_2)>::type > { enum _vt { value = 2 }; };
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_3)>::type > { enum _vt { value = 3 }; };
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_4)>::type > { enum _vt { value = 4 }; };
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_5)>::type > { enum _vt { value = 5 }; };
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_6)>::type > { enum _vt { value = 6 }; };
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_7)>::type > { enum _vt { value = 7 }; };
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_8)>::type > { enum _vt { value = 8 }; };
template<> struct is_placeholder< typename std::decay<decltype(std::placeholders::_9)>::type > { enum _vt { value = 9 }; };
} // namespace Boost
#endif
#endif // #ifndef ACTIV_BOOST_BIND_STD_PLACEHOLDERS_HPP_INCLUDED
-475
View File
@@ -1,475 +0,0 @@
#ifndef ACTIV_BOOST_BIND_STORAGE_HPP_INCLUDED
#define ACTIV_BOOST_BIND_STORAGE_HPP_INCLUDED
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
//
// bind/storage.hpp
//
// ActivBoost/bind.hpp support header, optimized storage
//
// Copyright (c) 2006 Peter Dimov
//
// 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
//
// See http://www.boost.org/libs/bind/bind.html for documentation.
//
#include <ActivBoost/config.hpp>
#include <ActivBoost/bind/arg.hpp>
#ifdef ACTIV_BOOST_MSVC
# pragma warning(push)
# pragma warning(disable: 4512) // assignment operator could not be generated
#endif
namespace Boost
{
namespace _bi
{
// 1
template<class A1> struct storage1
{
explicit storage1( A1 a1 ): a1_( a1 ) {}
template<class V> void accept(V & v) const
{
ACTIV_BOOST_BIND_VISIT_EACH(v, a1_, 0);
}
A1 a1_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( ACTIV_BOOST_BORLANDC )
template<int I> struct storage1< Boost::arg<I> >
{
explicit storage1( Boost::arg<I> ) {}
template<class V> void accept(V &) const { }
static Boost::arg<I> a1_() { return Boost::arg<I>(); }
};
template<int I> struct storage1< Boost::arg<I> (*) () >
{
explicit storage1( Boost::arg<I> (*) () ) {}
template<class V> void accept(V &) const { }
static Boost::arg<I> a1_() { return Boost::arg<I>(); }
};
#endif
// 2
template<class A1, class A2> struct storage2: public storage1<A1>
{
typedef storage1<A1> inherited;
storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
ACTIV_BOOST_BIND_VISIT_EACH(v, a2_, 0);
}
A2 a2_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template<class A1, int I> struct storage2< A1, Boost::arg<I> >: public storage1<A1>
{
typedef storage1<A1> inherited;
storage2( A1 a1, Boost::arg<I> ): storage1<A1>( a1 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a2_() { return Boost::arg<I>(); }
};
template<class A1, int I> struct storage2< A1, Boost::arg<I> (*) () >: public storage1<A1>
{
typedef storage1<A1> inherited;
storage2( A1 a1, Boost::arg<I> (*) () ): storage1<A1>( a1 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a2_() { return Boost::arg<I>(); }
};
#endif
// 3
template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
{
typedef storage2<A1, A2> inherited;
storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
ACTIV_BOOST_BIND_VISIT_EACH(v, a3_, 0);
}
A3 a3_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template<class A1, class A2, int I> struct storage3< A1, A2, Boost::arg<I> >: public storage2< A1, A2 >
{
typedef storage2<A1, A2> inherited;
storage3( A1 a1, A2 a2, Boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a3_() { return Boost::arg<I>(); }
};
template<class A1, class A2, int I> struct storage3< A1, A2, Boost::arg<I> (*) () >: public storage2< A1, A2 >
{
typedef storage2<A1, A2> inherited;
storage3( A1 a1, A2 a2, Boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a3_() { return Boost::arg<I>(); }
};
#endif
// 4
template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
{
typedef storage3<A1, A2, A3> inherited;
storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
ACTIV_BOOST_BIND_VISIT_EACH(v, a4_, 0);
}
A4 a4_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, Boost::arg<I> >: public storage3< A1, A2, A3 >
{
typedef storage3<A1, A2, A3> inherited;
storage4( A1 a1, A2 a2, A3 a3, Boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a4_() { return Boost::arg<I>(); }
};
template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, Boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
{
typedef storage3<A1, A2, A3> inherited;
storage4( A1 a1, A2 a2, A3 a3, Boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a4_() { return Boost::arg<I>(); }
};
#endif
// 5
template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
{
typedef storage4<A1, A2, A3, A4> inherited;
storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
ACTIV_BOOST_BIND_VISIT_EACH(v, a5_, 0);
}
A5 a5_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, Boost::arg<I> >: public storage4< A1, A2, A3, A4 >
{
typedef storage4<A1, A2, A3, A4> inherited;
storage5( A1 a1, A2 a2, A3 a3, A4 a4, Boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a5_() { return Boost::arg<I>(); }
};
template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, Boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
{
typedef storage4<A1, A2, A3, A4> inherited;
storage5( A1 a1, A2 a2, A3 a3, A4 a4, Boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a5_() { return Boost::arg<I>(); }
};
#endif
// 6
template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
{
typedef storage5<A1, A2, A3, A4, A5> inherited;
storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
ACTIV_BOOST_BIND_VISIT_EACH(v, a6_, 0);
}
A6 a6_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, Boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
{
typedef storage5<A1, A2, A3, A4, A5> inherited;
storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, Boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a6_() { return Boost::arg<I>(); }
};
template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, Boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
{
typedef storage5<A1, A2, A3, A4, A5> inherited;
storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, Boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a6_() { return Boost::arg<I>(); }
};
#endif
// 7
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
{
typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
ACTIV_BOOST_BIND_VISIT_EACH(v, a7_, 0);
}
A7 a7_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, Boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
{
typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, Boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a7_() { return Boost::arg<I>(); }
};
template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, Boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
{
typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, Boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a7_() { return Boost::arg<I>(); }
};
#endif
// 8
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
ACTIV_BOOST_BIND_VISIT_EACH(v, a8_, 0);
}
A8 a8_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, Boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, Boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a8_() { return Boost::arg<I>(); }
};
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, Boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, Boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a8_() { return Boost::arg<I>(); }
};
#endif
// 9
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
ACTIV_BOOST_BIND_VISIT_EACH(v, a9_, 0);
}
A9 a9_;
};
#if !defined( ACTIV_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, Boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, Boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a9_() { return Boost::arg<I>(); }
};
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, Boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, Boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
template<class V> void accept(V & v) const
{
inherited::accept(v);
}
static Boost::arg<I> a9_() { return Boost::arg<I>(); }
};
#endif
} // namespace _bi
} // namespace Boost
#ifdef ACTIV_BOOST_MSVC
# pragma warning(default: 4512) // assignment operator could not be generated
# pragma warning(pop)
#endif
#endif // #ifndef ACTIV_BOOST_BIND_STORAGE_HPP_INCLUDED