You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
221 lines
9.3 KiB
221 lines
9.3 KiB
/////////////////////////////////////////////////////////////////////////////// |
|
/// \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
|
|
|