Cockpit-cpp/EgoQt/thirdparty/Boost/include/boost/yap/detail/algorithm.hpp

// Copyright (C) 2016-2018 T. Zachary Laine
//
// 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_YAP_DETAIL_EXPRESSION_HPP_INCLUDED
#define BOOST_YAP_DETAIL_EXPRESSION_HPP_INCLUDED

#include <boost/yap/algorithm_fwd.hpp>

#include <boost/hana/size.hpp>
#include <boost/hana/tuple.hpp>

#include <memory>
#include <type_traits>


namespace boost { namespace yap { namespace detail {

    // static_const

    template<typename T>
    struct static_const
    {
        static constexpr T value{};
    };

    template<typename T>
    constexpr T static_const<T>::value;


    // partial_decay

    template<typename T>
    struct partial_decay
    {
        using type = T;
    };

    template<typename T>
    struct partial_decay<T[]>
    {
        using type = T *;
    };
    template<typename T, std::size_t N>
    struct partial_decay<T[N]>
    {
        using type = T *;
    };

    template<typename T>
    struct partial_decay<T (&)[]>
    {
        using type = T *;
    };
    template<typename T, std::size_t N>
    struct partial_decay<T (&)[N]>
    {
        using type = T *;
    };

    template<typename R, typename... A>
    struct partial_decay<R(A...)>
    {
        using type = R (*)(A...);
    };
    template<typename R, typename... A>
    struct partial_decay<R(A..., ...)>
    {
        using type = R (*)(A..., ...);
    };

    template<typename R, typename... A>
    struct partial_decay<R (&)(A...)>
    {
        using type = R (*)(A...);
    };
    template<typename R, typename... A>
    struct partial_decay<R (&)(A..., ...)>
    {
        using type = R (*)(A..., ...);
    };

    template<typename R, typename... A>
    struct partial_decay<R (*&)(A...)>
    {
        using type = R (*)(A...);
    };
    template<typename R, typename... A>
    struct partial_decay<R (*&)(A..., ...)>
    {
        using type = R (*)(A..., ...);
    };


    // operand_value_type_phase_1

    template<
        typename T,
        typename U = typename detail::partial_decay<T>::type,
        bool AddRValueRef = std::is_same<T, U>::value && !std::is_const<U>::value>
    struct operand_value_type_phase_1;

    template<typename T, typename U>
    struct operand_value_type_phase_1<T, U, true>
    {
        using type = U &&;
    };

    template<typename T, typename U>
    struct operand_value_type_phase_1<T, U, false>
    {
        using type = U;
    };


    // expr_ref

    template<template<expr_kind, class> class ExprTemplate, typename T>
    struct expr_ref
    {
        using type = expression_ref<ExprTemplate, T>;
    };

    template<template<expr_kind, class> class ExprTemplate, typename Tuple>
    struct expr_ref<ExprTemplate, ExprTemplate<expr_kind::expr_ref, Tuple> &>
    {
        using type = ExprTemplate<expr_kind::expr_ref, Tuple>;
    };

    template<template<expr_kind, class> class ExprTemplate, typename Tuple>
    struct expr_ref<
        ExprTemplate,
        ExprTemplate<expr_kind::expr_ref, Tuple> const &>
    {
        using type = ExprTemplate<expr_kind::expr_ref, Tuple>;
    };

    template<template<expr_kind, class> class ExprTemplate, typename T>
    using expr_ref_t = typename expr_ref<ExprTemplate, T>::type;

    template<template<expr_kind, class> class ExprTemplate, typename T>
    struct expr_ref_tuple;

    template<template<expr_kind, class> class ExprTemplate, typename Tuple>
    struct expr_ref_tuple<
        ExprTemplate,
        ExprTemplate<expr_kind::expr_ref, Tuple>>
    {
        using type = Tuple;
    };

    template<template<expr_kind, class> class ExprTemplate, typename T>
    using expr_ref_tuple_t = typename expr_ref_tuple<ExprTemplate, T>::type;


    // operand_type

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U = typename operand_value_type_phase_1<T>::type,
        bool RemoveRefs = std::is_rvalue_reference<U>::value,
        bool IsExpr = is_expr<T>::value,
        bool IsLRef = std::is_lvalue_reference<T>::value>
    struct operand_type;

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        bool RemoveRefs>
    struct operand_type<ExprTemplate, T, U, RemoveRefs, true, false>
    {
        using type = remove_cv_ref_t<T>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        bool RemoveRefs>
    struct operand_type<ExprTemplate, T, U, RemoveRefs, true, true>
    {
        using type = expr_ref_t<ExprTemplate, T>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        bool RemoveRefs,
        bool IsLRef>
    struct operand_type<ExprTemplate, T, U, RemoveRefs, true, IsLRef>
    {
        using type = remove_cv_ref_t<T>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        bool IsLRef>
    struct operand_type<ExprTemplate, T, U, true, false, IsLRef>
    {
        using type = terminal<ExprTemplate, std::remove_reference_t<U>>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        bool IsLRef>
    struct operand_type<ExprTemplate, T, U, false, false, IsLRef>
    {
        using type = terminal<ExprTemplate, U>;
    };

    template<template<expr_kind, class> class ExprTemplate, typename T>
    using operand_type_t = typename operand_type<ExprTemplate, T>::type;


    // make_operand

    template<typename T>
    struct make_operand
    {
        template<typename U>
        constexpr auto operator()(U && u)
        {
            return T{static_cast<U &&>(u)};
        }
    };

    template<template<expr_kind, class> class ExprTemplate, typename Tuple>
    struct make_operand<ExprTemplate<expr_kind::expr_ref, Tuple>>
    {
        constexpr auto operator()(ExprTemplate<expr_kind::expr_ref, Tuple> expr)
        {
            return expr;
        }

        template<typename U>
        constexpr auto operator()(U && u)
        {
            return ExprTemplate<expr_kind::expr_ref, Tuple>{
                Tuple{std::addressof(u)}};
        }
    };


    // free_binary_op_result

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U,
        bool TNonExprUExpr = !is_expr<T>::value && is_expr<U>::value,
        bool ULvalueRef = std::is_lvalue_reference<U>::value>
    struct free_binary_op_result;

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U>
    struct free_binary_op_result<ExprTemplate, OpKind, T, U, true, true>
    {
        using lhs_type = operand_type_t<ExprTemplate, T>;
        using rhs_type = expr_ref_t<ExprTemplate, U>;
        using rhs_tuple_type = expr_ref_tuple_t<ExprTemplate, rhs_type>;
        using type = ExprTemplate<OpKind, hana::tuple<lhs_type, rhs_type>>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U>
    struct free_binary_op_result<ExprTemplate, OpKind, T, U, true, false>
    {
        using lhs_type = operand_type_t<ExprTemplate, T>;
        using rhs_type = remove_cv_ref_t<U>;
        using type = ExprTemplate<OpKind, hana::tuple<lhs_type, rhs_type>>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U>
    using free_binary_op_result_t =
        typename free_binary_op_result<ExprTemplate, OpKind, T, U>::type;


    // ternary_op_result

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        typename V,
        bool Valid =
            is_expr<T>::value || is_expr<U>::value || is_expr<V>::value>
    struct ternary_op_result;

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        typename V>
    struct ternary_op_result<ExprTemplate, T, U, V, true>
    {
        using cond_type = operand_type_t<ExprTemplate, T>;
        using then_type = operand_type_t<ExprTemplate, U>;
        using else_type = operand_type_t<ExprTemplate, V>;
        using type = ExprTemplate<
            expr_kind::if_else,
            hana::tuple<cond_type, then_type, else_type>>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        typename V>
    using ternary_op_result_t =
        typename ternary_op_result<ExprTemplate, T, U, V>::type;


    // udt_any_ternary_op_result

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        typename V,
        template<class> class UdtTrait,
        bool Valid = !is_expr<T>::value && !is_expr<U>::value &&
                     !is_expr<V>::value &&
                     (UdtTrait<remove_cv_ref_t<T>>::value ||
                      UdtTrait<remove_cv_ref_t<U>>::value ||
                      UdtTrait<remove_cv_ref_t<V>>::value)>
    struct udt_any_ternary_op_result;

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        typename V,
        template<class> class UdtTrait>
    struct udt_any_ternary_op_result<ExprTemplate, T, U, V, UdtTrait, true>
    {
        using cond_type = operand_type_t<ExprTemplate, T>;
        using then_type = operand_type_t<ExprTemplate, U>;
        using else_type = operand_type_t<ExprTemplate, V>;
        using type = ExprTemplate<
            expr_kind::if_else,
            hana::tuple<cond_type, then_type, else_type>>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        typename T,
        typename U,
        typename V,
        template<class> class UdtTrait>
    using udt_any_ternary_op_result_t =
        typename udt_any_ternary_op_result<ExprTemplate, T, U, V, UdtTrait>::
            type;


    // udt_unary_op_result

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        template<class> class UdtTrait,
        bool Valid = !is_expr<T>::value && UdtTrait<remove_cv_ref_t<T>>::value>
    struct udt_unary_op_result;

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        template<class> class UdtTrait>
    struct udt_unary_op_result<ExprTemplate, OpKind, T, UdtTrait, true>
    {
        using x_type = operand_type_t<ExprTemplate, T>;
        using type = ExprTemplate<OpKind, hana::tuple<x_type>>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        template<class> class UdtTrait>
    using udt_unary_op_result_t =
        typename udt_unary_op_result<ExprTemplate, OpKind, T, UdtTrait>::type;


    // udt_udt_binary_op_result

    template<typename T, template<class> class UdtTrait>
    struct is_udt_arg
    {
        static bool const value =
            !is_expr<T>::value && UdtTrait<remove_cv_ref_t<T>>::value;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U,
        template<class> class TUdtTrait,
        template<class> class UUdtTrait,
        bool Valid =
            is_udt_arg<T, TUdtTrait>::value && is_udt_arg<U, UUdtTrait>::value>
    struct udt_udt_binary_op_result;

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U,
        template<class> class TUdtTrait,
        template<class> class UUdtTrait>
    struct udt_udt_binary_op_result<
        ExprTemplate,
        OpKind,
        T,
        U,
        TUdtTrait,
        UUdtTrait,
        true>
    {
        using lhs_type = operand_type_t<ExprTemplate, T>;
        using rhs_type = operand_type_t<ExprTemplate, U>;
        using type = ExprTemplate<OpKind, hana::tuple<lhs_type, rhs_type>>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U,
        template<class> class TUdtTrait,
        template<class> class UUdtTrait>
    using udt_udt_binary_op_result_t = typename udt_udt_binary_op_result<
        ExprTemplate,
        OpKind,
        T,
        U,
        TUdtTrait,
        UUdtTrait>::type;


    // udt_any_binary_op_result

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U,
        template<class> class UdtTrait,
        bool Valid = !is_expr<T>::value && !is_expr<U>::value &&
                     (UdtTrait<remove_cv_ref_t<T>>::value ||
                      UdtTrait<remove_cv_ref_t<U>>::value)>
    struct udt_any_binary_op_result;

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U,
        template<class> class UdtTrait>
    struct udt_any_binary_op_result<ExprTemplate, OpKind, T, U, UdtTrait, true>
    {
        using lhs_type = operand_type_t<ExprTemplate, T>;
        using rhs_type = operand_type_t<ExprTemplate, U>;
        using type = ExprTemplate<OpKind, hana::tuple<lhs_type, rhs_type>>;
    };

    template<
        template<expr_kind, class> class ExprTemplate,
        expr_kind OpKind,
        typename T,
        typename U,
        template<class> class UdtTrait>
    using udt_any_binary_op_result_t = typename udt_any_binary_op_result<
        ExprTemplate,
        OpKind,
        T,
        U,
        UdtTrait>::type;


    // not_copy_or_move

    template<typename LeftT, typename RightT>
    struct copy_or_move : std::false_type
    {
    };

    template<typename T>
    struct copy_or_move<T, T const &> : std::true_type
    {
    };

    template<typename T>
    struct copy_or_move<T, T &> : std::true_type
    {
    };

    template<typename T>
    struct copy_or_move<T, T &&> : std::true_type
    {
    };


    // expr_arity

    enum class expr_arity { invalid, one, two, three, n };

    template<expr_kind Kind>
    constexpr expr_arity arity_of()
    {
        switch (Kind) {
        case expr_kind::expr_ref:

        case expr_kind::terminal:

        // unary
        case expr_kind::unary_plus:  // +
        case expr_kind::negate:      // -
        case expr_kind::dereference: // *
        case expr_kind::complement:  // ~
        case expr_kind::address_of:  // &
        case expr_kind::logical_not: // !
        case expr_kind::pre_inc:     // ++
        case expr_kind::pre_dec:     // --
        case expr_kind::post_inc:    // ++(int)
        case expr_kind::post_dec:    // --(int)
            return expr_arity::one;

        // binary
        case expr_kind::shift_left:         // <<
        case expr_kind::shift_right:        // >>
        case expr_kind::multiplies:         // *
        case expr_kind::divides:            // /
        case expr_kind::modulus:            // %
        case expr_kind::plus:               // +
        case expr_kind::minus:              // -
        case expr_kind::less:               // <
        case expr_kind::greater:            // >
        case expr_kind::less_equal:         // <=
        case expr_kind::greater_equal:      // >=
        case expr_kind::equal_to:           // ==
        case expr_kind::not_equal_to:       // !=
        case expr_kind::logical_or:         // ||
        case expr_kind::logical_and:        // &&
        case expr_kind::bitwise_and:        // &
        case expr_kind::bitwise_or:         // |
        case expr_kind::bitwise_xor:        // ^
        case expr_kind::comma:              // :
        case expr_kind::mem_ptr:            // ->*
        case expr_kind::assign:             // =
        case expr_kind::shift_left_assign:  // <<=
        case expr_kind::shift_right_assign: // >>=
        case expr_kind::multiplies_assign:  // *=
        case expr_kind::divides_assign:     // /=
        case expr_kind::modulus_assign:     // %=
        case expr_kind::plus_assign:        // +=
        case expr_kind::minus_assign:       // -=
        case expr_kind::bitwise_and_assign: // &=
        case expr_kind::bitwise_or_assign:  // |=
        case expr_kind::bitwise_xor_assign: // ^=
        case expr_kind::subscript:          // []
            return expr_arity::two;

        // ternary
        case expr_kind::if_else: // (analogous to) ?:
            return expr_arity::three;

        // n-ary
        case expr_kind::call: // ()
            return expr_arity::n;

        default: return expr_arity::invalid;
        }
    }

}}}

#endif