optimized_expr.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

#include "etl/wrapper_traits.hpp"

namespace etl {

template <typename Expr>
struct optimized_expr final {
    using expr_t     = Expr;          
    using value_type = value_t<Expr>; 

private:
    Expr value;

    friend struct wrapper_traits<optimized_expr>;

public:
    //Cannot be constructed with no args
    optimized_expr() = delete;

    explicit optimized_expr(Expr l) : value(std::forward<Expr>(l)) {
        //Nothing else to init
    }

    //Expresison can be copied and moved
    optimized_expr(const optimized_expr& e)     = default;
    optimized_expr(optimized_expr&& e) noexcept = default;

    //Expressions are invariant
    optimized_expr& operator=(const optimized_expr& e) = delete;
    optimized_expr& operator=(optimized_expr&& e) = delete;

    template <typename E>
    bool alias(const E& other) const noexcept {
        return value.alias(other);
    }

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        //Note: This is more than ugly...
        optimized_forward(value, [&lhs](auto&& optimized) mutable { optimized.assign_to(lhs); });
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        //Note: This is more than ugly...
        optimized_forward(value, [&lhs](auto&& optimized) mutable { optimized.assign_add_to(lhs); });
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        //Note: This is more than ugly...
        optimized_forward(value, [&lhs](auto&& optimized) mutable { optimized.assign_sub_to(lhs); });
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        //Note: This is more than ugly...
        optimized_forward(value, [&lhs](auto&& optimized) mutable { optimized.assign_mul_to(lhs); });
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        //Note: This is more than ugly...
        optimized_forward(value, [&lhs](auto&& optimized) mutable { optimized.assign_div_to(lhs); });
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        //Note: This is more than ugly...
        optimized_forward(value, [&lhs](auto&& optimized) mutable { optimized.assign_mod_to(lhs); });
    }

    friend std::ostream& operator<<(std::ostream& os, const optimized_expr& expr) {
        return os << "OPT(" << expr.value << ")";
    }
};

template <typename Expr>
struct etl_traits<etl::optimized_expr<Expr>> : wrapper_traits<etl::optimized_expr<Expr>> {};

} //end of namespace etl