| /////////////////////////////////////////////////////////////////////////////// |
| /// \file functional_fwd.hpp |
| /// |
| // Copyright 2005 Eric Niebler. Distributed under the Boost |
| // Software License, Version 1.0. (See accompanying file |
| // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| |
| #ifndef BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005 |
| #define BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005 |
| |
| #include <boost/mpl/if.hpp> |
| #include <boost/mpl/placeholders.hpp> |
| #include <boost/utility/enable_if.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #include <boost/type_traits/is_const.hpp> |
| |
| namespace boost { namespace numeric |
| { |
| // For using directives -- this namespace may be re-opened elsewhere |
| namespace operators |
| {} |
| |
| namespace op |
| { |
| using mpl::_; |
| using mpl::_1; |
| using mpl::_2; |
| } |
| |
| namespace functional |
| { |
| using namespace operators; |
| |
| template<typename T> |
| struct tag |
| { |
| typedef void type; |
| }; |
| |
| template<typename T> |
| struct tag<T const> |
| : tag<T> |
| {}; |
| |
| template<typename T> |
| struct tag<T volatile> |
| : tag<T> |
| {}; |
| |
| template<typename T> |
| struct tag<T const volatile> |
| : tag<T> |
| {}; |
| |
| template<typename T> |
| struct static_; |
| |
| template<typename A0, typename A1> |
| struct are_integral; |
| } |
| |
| /// INTERNAL ONLY |
| /// |
| #define BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(Name, Op) \ |
| namespace functional \ |
| { \ |
| template<typename Arg, typename EnableIf = void> \ |
| struct Name ## _base; \ |
| template<typename Arg, typename ArgTag = typename tag<Arg>::type> \ |
| struct Name; \ |
| } \ |
| namespace op \ |
| { \ |
| struct Name; \ |
| } \ |
| namespace \ |
| { \ |
| extern op::Name const &Name; \ |
| } |
| |
| /// INTERNAL ONLY |
| /// |
| #define BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(Name) \ |
| namespace functional \ |
| { \ |
| template<typename Left, typename Right, typename EnableIf = void> \ |
| struct result_of_ ## Name; \ |
| template<typename Left, typename Right, typename EnableIf = void> \ |
| struct Name ## _base; \ |
| template< \ |
| typename Left \ |
| , typename Right \ |
| , typename LeftTag = typename tag<Left>::type \ |
| , typename RightTag = typename tag<Right>::type \ |
| > \ |
| struct Name; \ |
| } \ |
| namespace op \ |
| { \ |
| struct Name; \ |
| } \ |
| namespace \ |
| { \ |
| extern op::Name const &Name; \ |
| } |
| |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater_equal) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less_equal) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(equal_to) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(not_equal_to) |
| |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(assign) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus_assign) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus_assign) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies_assign) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides_assign) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus_assign) |
| |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_plus, +) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_minus, -) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(complement, ~) |
| BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(logical_not, !) |
| |
| #undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP |
| #undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP |
| |
| |
| namespace functional |
| { |
| template<typename To, typename From, typename EnableIf = void> |
| struct promote_base; |
| template<typename Left, typename Right, typename EnableIf = void> |
| struct min_assign_base; |
| template<typename Left, typename Right, typename EnableIf = void> |
| struct max_assign_base; |
| template<typename Left, typename Right, typename EnableIf = void> |
| struct average_base; |
| template<typename Arg, typename EnableIf = void> |
| struct as_min_base; |
| template<typename Arg, typename EnableIf = void> |
| struct as_max_base; |
| template<typename Arg, typename EnableIf = void> |
| struct as_zero_base; |
| template<typename Arg, typename EnableIf = void> |
| struct as_one_base; |
| |
| template<typename To, typename From, typename ToTag = typename tag<To>::type, typename FromTag = typename tag<From>::type> |
| struct promote; |
| template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> |
| struct min_assign; |
| template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> |
| struct max_assign; |
| template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type> |
| struct average; |
| template<typename Arg, typename Tag = typename tag<Arg>::type> |
| struct as_min; |
| template<typename Arg, typename Tag = typename tag<Arg>::type> |
| struct as_max; |
| template<typename Arg, typename Tag = typename tag<Arg>::type> |
| struct as_zero; |
| template<typename Arg, typename Tag = typename tag<Arg>::type> |
| struct as_one; |
| } |
| |
| namespace op |
| { |
| template<typename To> |
| struct promote; |
| struct min_assign; |
| struct max_assign; |
| struct average; |
| struct as_min; |
| struct as_max; |
| struct as_zero; |
| struct as_one; |
| } |
| |
| namespace |
| { |
| extern op::min_assign const &min_assign; |
| extern op::max_assign const &max_assign; |
| extern op::average const &average; |
| extern op::as_min const &as_min; |
| extern op::as_max const &as_max; |
| extern op::as_zero const &as_zero; |
| extern op::as_one const &as_one; |
| } |
| |
| template<typename To, typename From> |
| typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type |
| promote(From &from); |
| |
| template<typename To, typename From> |
| typename mpl::if_<is_same<To const, From const>, To const &, To const>::type |
| promote(From const &from); |
| |
| template<typename T> |
| struct default_; |
| |
| template<typename T> |
| struct one; |
| |
| template<typename T> |
| struct zero; |
| |
| template<typename T> |
| struct one_or_default; |
| |
| template<typename T> |
| struct zero_or_default; |
| |
| }} // namespace boost::numeric |
| |
| #endif |