mirror of
https://github.com/boostorg/yap.git
synced 2026-02-22 16:02:10 +00:00
314 lines
7.7 KiB
C++
314 lines
7.7 KiB
C++
#include <boost/yap/expression.hpp>
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
|
|
#define user_expr user_expr_1
|
|
|
|
/// [USER_UNARY_OPERATOR_MEMBER]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
|
|
// Member operator overloads for operator!().
|
|
BOOST_YAP_USER_UNARY_OPERATOR_MEMBER(logical_not, this_type, ::user_expr)
|
|
};
|
|
/// [USER_UNARY_OPERATOR_MEMBER]
|
|
|
|
struct lazy_vector_1 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef user_expr
|
|
|
|
#define user_expr user_expr_2
|
|
|
|
/// [USER_BINARY_OPERATOR_MEMBER]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
|
|
// Member operator overloads for operator&&(). These will match any value
|
|
// on the right-hand side, even another expression. Left as-is, there is
|
|
// no matching overload for x && y, where x is not an expression and y is.
|
|
// BOOST_YAP_USER_FREE_BINARY_OPERATOR can help with that.
|
|
BOOST_YAP_USER_BINARY_OPERATOR_MEMBER(logical_and, this_type, ::user_expr)
|
|
};
|
|
/// [USER_BINARY_OPERATOR_MEMBER]
|
|
|
|
struct lazy_vector_2 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef user_expr
|
|
|
|
#define user_expr user_expr_3
|
|
|
|
/// [USER_MEMBER_CALL_OPERATOR]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
|
|
// Member operator overloads for operator()(). These will match any
|
|
// number of parameters. Each one can be any type, even another
|
|
// expression.
|
|
BOOST_YAP_USER_MEMBER_CALL_OPERATOR(this_type, ::user_expr)
|
|
};
|
|
/// [USER_MEMBER_CALL_OPERATOR]
|
|
|
|
struct lazy_vector_3 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef user_expr
|
|
|
|
#define user_expr user_expr_4
|
|
|
|
/// [USER_FREE_BINARY_OPERATOR]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
|
|
// Member operator overloads for operator&&(). These will match any value
|
|
// on the right-hand side, even another expression.
|
|
BOOST_YAP_USER_BINARY_OPERATOR_MEMBER(logical_and, this_type, ::user_expr)
|
|
};
|
|
|
|
// Free operator overloads for operator&&(). These will match any value on
|
|
// the left-hand side, *except* an expression; the right-hand side must be an
|
|
// expression.
|
|
BOOST_YAP_USER_FREE_BINARY_OPERATOR(logical_and, ::user_expr)
|
|
/// [USER_FREE_BINARY_OPERATOR]
|
|
|
|
struct lazy_vector_4 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef user_expr
|
|
|
|
#define user_expr user_expr_5
|
|
|
|
/// [USER_EXPR_IF_ELSE]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
};
|
|
|
|
// Defines an overload of if_else() that returns expressions instantiated from
|
|
// user_expr.
|
|
BOOST_YAP_USER_EXPR_IF_ELSE(::user_expr)
|
|
/// [USER_EXPR_IF_ELSE]
|
|
|
|
struct lazy_vector_5 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef user_expr
|
|
|
|
#define user_expr user_expr_6
|
|
#define is_vector is_vector_1
|
|
|
|
/// [USER_UDT_ANY_IF_ELSE]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
};
|
|
|
|
template <typename T>
|
|
struct is_vector : std::false_type {};
|
|
|
|
template <typename T, typename A>
|
|
struct is_vector<std::vector<T, A>> : std::true_type {};
|
|
|
|
// Defines an overload of if_else() that returns expressions instantiated from
|
|
// user_expr.
|
|
BOOST_YAP_USER_UDT_ANY_IF_ELSE(::user_expr, is_vector)
|
|
/// [USER_UDT_ANY_IF_ELSE]
|
|
|
|
struct lazy_vector_6 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef is_vector
|
|
#undef user_expr
|
|
|
|
#define user_expr user_expr_7
|
|
#define is_vector is_vector_2
|
|
|
|
/// [USER_UDT_UNARY_OPERATOR]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
};
|
|
|
|
template <typename T>
|
|
struct is_vector : std::false_type {};
|
|
|
|
template <typename T, typename A>
|
|
struct is_vector<std::vector<T, A>> : std::true_type {};
|
|
|
|
// Defines an overload of operator!() that applies to vectors and returns
|
|
// expressions instantiated from user_expr.
|
|
BOOST_YAP_USER_UDT_UNARY_OPERATOR(logical_not, ::user_expr, is_vector)
|
|
/// [USER_UDT_UNARY_OPERATOR]
|
|
|
|
struct lazy_vector_7 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef is_vector
|
|
#undef user_expr
|
|
|
|
#define user_expr user_expr_8
|
|
#define is_vector is_vector_3
|
|
|
|
/// [USER_UDT_UDT_BINARY_OPERATOR]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
};
|
|
|
|
template <typename T>
|
|
struct is_vector : std::false_type {};
|
|
|
|
template <typename T, typename A>
|
|
struct is_vector<std::vector<T, A>> : std::true_type {};
|
|
|
|
template <typename T>
|
|
struct is_string : std::false_type {};
|
|
|
|
template <>
|
|
struct is_string<std::string> : std::true_type {};
|
|
|
|
// Defines an overload of operator||() that applies to vectors on the left and
|
|
// strings on the right, and returns expressions instantiated from user_expr.
|
|
BOOST_YAP_USER_UDT_UDT_BINARY_OPERATOR(logical_or, ::user_expr, is_vector, is_string)
|
|
|
|
// Defines an overload of operator&&() that applies to strings and returns
|
|
// expressions instantiated from user_expr.
|
|
BOOST_YAP_USER_UDT_UDT_BINARY_OPERATOR(logical_and, ::user_expr, is_string, is_string)
|
|
/// [USER_UDT_UDT_BINARY_OPERATOR]
|
|
|
|
struct lazy_vector_8 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef is_vector
|
|
#undef user_expr
|
|
|
|
#define user_expr user_expr_9
|
|
#define is_vector is_vector_4
|
|
|
|
/// [USER_UDT_ANY_BINARY_OPERATOR]
|
|
template <boost::yap::expr_kind Kind, typename Tuple>
|
|
struct user_expr
|
|
{
|
|
using this_type = user_expr<Kind, Tuple>;
|
|
|
|
static const boost::yap::expr_kind kind = Kind;
|
|
|
|
Tuple elements;
|
|
};
|
|
|
|
template <typename T>
|
|
struct is_vector : std::false_type {};
|
|
|
|
template <typename T, typename A>
|
|
struct is_vector<std::vector<T, A>> : std::true_type {};
|
|
|
|
// Defines an overload of operator&&() that matches a string on either side,
|
|
// and any type (possibly a string) on the other.
|
|
BOOST_YAP_USER_UDT_ANY_BINARY_OPERATOR(logical_and, ::user_expr, is_string)
|
|
/// [USER_UDT_ANY_BINARY_OPERATOR]
|
|
|
|
struct lazy_vector_9 :
|
|
user_expr<
|
|
boost::yap::expr_kind::terminal,
|
|
boost::hana::tuple<std::vector<double>>
|
|
>
|
|
{};
|
|
|
|
#undef is_vector
|
|
#undef user_expr
|
|
|
|
|
|
int main ()
|
|
{
|
|
lazy_vector_2 v1{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector_2 v2{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector_3 v3{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector_4 v4{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector_5 v5{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector_6 v6{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector_7 v7{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector_8 v8{{std::vector<double>(4, 1.0)}};
|
|
lazy_vector_9 v9{{std::vector<double>(4, 1.0)}};
|
|
|
|
return 0;
|
|
}
|