mirror of
https://github.com/ecency/ecency-mobile.git
synced 2024-12-23 13:22:02 +03:00
209 lines
4.8 KiB
C++
209 lines
4.8 KiB
C++
|
//---------------------------------------------------------------------------//
|
||
|
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
|
||
|
//
|
||
|
// 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://boostorg.github.com/compute for more information.
|
||
|
//---------------------------------------------------------------------------//
|
||
|
|
||
|
#ifndef BOOST_COMPUTE_FUNCTIONAL_LOGICAL_HPP
|
||
|
#define BOOST_COMPUTE_FUNCTIONAL_LOGICAL_HPP
|
||
|
|
||
|
namespace boost {
|
||
|
namespace compute {
|
||
|
namespace detail {
|
||
|
|
||
|
template<class Predicate, class Expr>
|
||
|
class invoked_unary_negate_function
|
||
|
{
|
||
|
public:
|
||
|
typedef int result_type;
|
||
|
|
||
|
invoked_unary_negate_function(const Predicate &pred,
|
||
|
const Expr &expr)
|
||
|
: m_pred(pred),
|
||
|
m_expr(expr)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
Predicate pred() const
|
||
|
{
|
||
|
return m_pred;
|
||
|
}
|
||
|
|
||
|
Expr expr() const
|
||
|
{
|
||
|
return m_expr;
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
Predicate m_pred;
|
||
|
Expr m_expr;
|
||
|
};
|
||
|
|
||
|
template<class Predicate, class Expr1, class Expr2>
|
||
|
class invoked_binary_negate_function
|
||
|
{
|
||
|
public:
|
||
|
typedef int result_type;
|
||
|
|
||
|
invoked_binary_negate_function(const Predicate &pred,
|
||
|
const Expr1 &expr1,
|
||
|
const Expr2 &expr2)
|
||
|
: m_pred(pred),
|
||
|
m_expr1(expr1),
|
||
|
m_expr2(expr2)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
Predicate pred() const
|
||
|
{
|
||
|
return m_pred;
|
||
|
}
|
||
|
|
||
|
Expr1 expr1() const
|
||
|
{
|
||
|
return m_expr1;
|
||
|
}
|
||
|
|
||
|
Expr2 expr2() const
|
||
|
{
|
||
|
return m_expr2;
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
Predicate m_pred;
|
||
|
Expr1 m_expr1;
|
||
|
Expr2 m_expr2;
|
||
|
};
|
||
|
|
||
|
} // end detail namespace
|
||
|
|
||
|
/// \internal_
|
||
|
template<class Arg, class Result>
|
||
|
struct unary_function
|
||
|
{
|
||
|
typedef Arg argument_type;
|
||
|
typedef Result result_type;
|
||
|
};
|
||
|
|
||
|
/// \internal_
|
||
|
template<class Arg1, class Arg2, class Result>
|
||
|
struct binary_function
|
||
|
{
|
||
|
typedef Arg1 first_argument_type;
|
||
|
typedef Arg2 second_argument_type;
|
||
|
typedef Result result_type;
|
||
|
};
|
||
|
|
||
|
/// \internal_
|
||
|
template<class Arg1, class Arg2, class Arg3, class Result>
|
||
|
struct ternary_function
|
||
|
{
|
||
|
typedef Arg1 first_argument_type;
|
||
|
typedef Arg2 second_argument_type;
|
||
|
typedef Arg3 third_argument_type;
|
||
|
typedef Result result_type;
|
||
|
};
|
||
|
|
||
|
/// The unary_negate function adaptor negates a unary function.
|
||
|
///
|
||
|
/// \see not1()
|
||
|
template<class Predicate>
|
||
|
class unary_negate : public unary_function<void, int>
|
||
|
{
|
||
|
public:
|
||
|
explicit unary_negate(Predicate pred)
|
||
|
: m_pred(pred)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
/// \internal_
|
||
|
template<class Arg>
|
||
|
detail::invoked_unary_negate_function<Predicate, Arg>
|
||
|
operator()(const Arg &arg) const
|
||
|
{
|
||
|
return detail::invoked_unary_negate_function<
|
||
|
Predicate,
|
||
|
Arg
|
||
|
>(m_pred, arg);
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
Predicate m_pred;
|
||
|
};
|
||
|
|
||
|
/// The binnary_negate function adaptor negates a binary function.
|
||
|
///
|
||
|
/// \see not2()
|
||
|
template<class Predicate>
|
||
|
class binary_negate : public binary_function<void, void, int>
|
||
|
{
|
||
|
public:
|
||
|
explicit binary_negate(Predicate pred)
|
||
|
: m_pred(pred)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
/// \internal_
|
||
|
template<class Arg1, class Arg2>
|
||
|
detail::invoked_binary_negate_function<Predicate, Arg1, Arg2>
|
||
|
operator()(const Arg1 &arg1, const Arg2 &arg2) const
|
||
|
{
|
||
|
return detail::invoked_binary_negate_function<
|
||
|
Predicate,
|
||
|
Arg1,
|
||
|
Arg2
|
||
|
>(m_pred, arg1, arg2);
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
Predicate m_pred;
|
||
|
};
|
||
|
|
||
|
/// Returns a unary_negate adaptor around \p predicate.
|
||
|
///
|
||
|
/// \param predicate the unary function to wrap
|
||
|
///
|
||
|
/// \return a unary_negate wrapper around \p predicate
|
||
|
template<class Predicate>
|
||
|
inline unary_negate<Predicate> not1(const Predicate &predicate)
|
||
|
{
|
||
|
return unary_negate<Predicate>(predicate);
|
||
|
}
|
||
|
|
||
|
/// Returns a binary_negate adaptor around \p predicate.
|
||
|
///
|
||
|
/// \param predicate the binary function to wrap
|
||
|
///
|
||
|
/// \return a binary_negate wrapper around \p predicate
|
||
|
template<class Predicate>
|
||
|
inline binary_negate<Predicate> not2(const Predicate &predicate)
|
||
|
{
|
||
|
return binary_negate<Predicate>(predicate);
|
||
|
}
|
||
|
|
||
|
/// The logical_not function negates its argument and returns it.
|
||
|
///
|
||
|
/// \see not1(), not2()
|
||
|
template<class T>
|
||
|
struct logical_not : public unary_function<T, int>
|
||
|
{
|
||
|
/// \internal_
|
||
|
template<class Expr>
|
||
|
detail::invoked_function<int, boost::tuple<Expr> >
|
||
|
operator()(const Expr &expr) const
|
||
|
{
|
||
|
return detail::invoked_function<int, boost::tuple<Expr> >(
|
||
|
"!", std::string(), boost::make_tuple(expr)
|
||
|
);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
} // end compute namespace
|
||
|
} // end boost namespace
|
||
|
|
||
|
#endif // BOOST_COMPUTE_FUNCTIONAL_LOGICAL_HPP
|