expression_helpers.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

#pragma once

namespace etl::detail {

template <typename T>
using build_type = std::conditional_t<is_etl_value<T>, const std::decay_t<T>&, std::decay_t<T>>;

template <typename T>
using build_identity_type = std::conditional_t<is_etl_value<T>,
                                               std::conditional_t<std::is_const_v<std::remove_reference_t<T>>, const std::decay_t<T>&, std::decay_t<T>&>,
                                               std::decay_t<T>>;

template <typename T>
using wrap_scalar_t = std::conditional_t<etl::is_etl_expr<T>, T, etl::scalar<std::decay_t<T>>>;

template <typename H, typename T>
using smart_wrap_scalar_t = std::conditional_t<etl::is_etl_expr<T>, T, etl::scalar<etl::value_t<H>>>;

template <typename T>
struct wrap_scalar_value_t_impl;

template <typename T>
requires(etl_expr<T>)
struct wrap_scalar_value_t_impl<T> {
    using type = etl::value_t<T>;
};

template <typename T>
requires(!etl_expr<T>)
struct wrap_scalar_value_t_impl<T> {
    using type = std::decay_t<T>;
};

template <typename T>
using wrap_scalar_value_t = typename wrap_scalar_value_t_impl<T>::type;

template <typename T>
decltype(auto) wrap_scalar(T&& value) requires (etl_expr<T>) {
    return std::forward<T>(value);
}

template <typename T>
etl::scalar<std::decay_t<T>> wrap_scalar(T&& value) requires(!etl_expr<T>) {
    return etl::scalar<std::decay_t<T>>{value};
}

template <typename Hint, typename T>
decltype(auto) smart_wrap_scalar(T&& value) {
    if constexpr (is_etl_expr<T>) {
        return std::forward<T>(value);
    } else {
        using scalar_type = etl::value_t<Hint>;
        return etl::scalar<scalar_type>{scalar_type(value)};
    }
}

template <typename LE, typename RE, template <typename> typename OP>
using left_binary_helper = binary_expr<value_t<LE>, build_type<LE>, OP<value_t<LE>>, build_type<RE>>;

template <typename LE, typename RE, typename OP>
using left_binary_helper_op = binary_expr<value_t<LE>, build_type<LE>, OP, build_type<RE>>;

template <typename LE, typename RE, typename OP>
using left_binary_helper_op_scalar = binary_expr<wrap_scalar_value_t<LE>, build_type<wrap_scalar_t<LE>>, OP, build_type<smart_wrap_scalar_t<LE, RE>>>;

template <typename LE, typename RE, template <typename> typename OP>
using right_binary_helper = binary_expr<value_t<RE>, build_type<LE>, OP<value_t<RE>>, build_type<RE>>;

template <typename LE, typename RE, typename OP>
using right_binary_helper_op = binary_expr<value_t<RE>, build_type<LE>, OP, build_type<RE>>;

template <typename LE, typename RE, template <typename> typename OP>
using bool_left_binary_helper = binary_expr<bool, build_type<LE>, OP<value_t<LE>>, build_type<RE>>;

template <typename LE, typename RE, template <typename> typename OP>
using bool_right_binary_helper = binary_expr<bool, build_type<LE>, OP<value_t<RE>>, build_type<RE>>;

template <typename LE, typename RE, template <typename> typename OP>
using bool_left_binary_helper_scalar = binary_expr<bool, build_type<wrap_scalar_t<LE>>, OP<wrap_scalar_value_t<LE>>, build_type<wrap_scalar_t<RE>>>;

template <typename E, template <typename> typename OP>
using unary_helper = unary_expr<value_t<E>, build_type<E>, OP<value_t<E>>>;

template <typename E, typename OP>
using identity_helper = unary_expr<value_t<E>, OP, identity_op>;

template <typename E, typename OP>
using virtual_helper = unary_expr<E, OP, transform_op>;

template <typename E, template <typename> typename OP>
using stable_transform_helper = unary_expr<value_t<E>, OP<build_type<E>>, transform_op>;

template <typename LE, typename RE, template <typename, typename> typename OP>
using stable_transform_binary_helper = unary_expr<value_t<LE>, OP<build_type<LE>, build_type<RE>>, transform_op>;

template <typename E, template <typename> typename OP, typename... Args>
auto make_transform_expr(Args&&... args) {
    return stable_transform_helper<E, OP>{OP<build_type<E>>(std::forward<Args>(args)...)};
}

template <typename E, typename OP, typename... Args>
auto make_stateful_unary_expr(Args&&... args) {
    return unary_expr<value_t<E>, build_type<E>, stateful_op<OP>>(std::forward<Args>(args)...);
}

} //end of namespace etl::detail