timed_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 <iosfwd> //For stream support

#include "etl/wrapper_traits.hpp"

namespace etl {

template <typename Expr, typename R>
struct timed_expr final {
    using clock_resolution = R;             
    using expr_t           = Expr;          
    using value_type       = value_t<Expr>; 

private:
    Expr value;

    friend struct wrapper_traits<timed_expr>;

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

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

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

    //Expressions are invariant
    timed_expr& operator=(const timed_expr& e) = delete;
    timed_expr& operator=(timed_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 {
        auto start_time = etl::timer_clock::now();

        value.assign_to(lhs);

        auto end_time = etl::timer_clock::now();
        auto duration = std::chrono::duration_cast<clock_resolution>(end_time - start_time);

        std::cout << "timed(=): " << value << " took " << duration.count() << resolution_to_string<clock_resolution>() << std::endl;
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        auto start_time = etl::timer_clock::now();

        value.assign_add_to(lhs);

        auto end_time = etl::timer_clock::now();
        auto duration = std::chrono::duration_cast<clock_resolution>(end_time - start_time);

        std::cout << "timed(+=): " << value << " took " << duration.count() << resolution_to_string<clock_resolution>() << std::endl;
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        auto start_time = etl::timer_clock::now();

        value.assign_sub_to(lhs);

        auto end_time = etl::timer_clock::now();
        auto duration = std::chrono::duration_cast<clock_resolution>(end_time - start_time);

        std::cout << "timed(-=): " << value << " took " << duration.count() << resolution_to_string<clock_resolution>() << std::endl;
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        auto start_time = etl::timer_clock::now();

        value.assign_mul_to(lhs);

        auto end_time = etl::timer_clock::now();
        auto duration = std::chrono::duration_cast<clock_resolution>(end_time - start_time);

        std::cout << "timed(*=): " << value << " took " << duration.count() << resolution_to_string<clock_resolution>() << std::endl;
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        auto start_time = etl::timer_clock::now();

        value.assign_div_to(lhs);

        auto end_time = etl::timer_clock::now();
        auto duration = std::chrono::duration_cast<clock_resolution>(end_time - start_time);

        std::cout << "timed(/=): " << value << " took " << duration.count() << resolution_to_string<clock_resolution>() << std::endl;
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        auto start_time = etl::timer_clock::now();

        value.assign_mod_to(lhs);

        auto end_time = etl::timer_clock::now();
        auto duration = std::chrono::duration_cast<clock_resolution>(end_time - start_time);

        std::cout << "timed(%=): " << value << " took " << duration.count() << resolution_to_string<clock_resolution>() << std::endl;
    }

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

template <typename Expr, typename R>
struct etl_traits<etl::timed_expr<Expr, R>> : wrapper_traits<etl::timed_expr<Expr, R>> {};

} //end of namespace etl