generator_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

namespace etl {

template <typename Generator>
class generator_expr final {
private:
    mutable Generator generator;

public:
    using value_type = typename Generator::value_type; 

    template <typename... Args>
    explicit generator_expr(Args&&... args) : generator(std::forward<Args>(args)...) {}

    generator_expr(const generator_expr& e)     = default;
    generator_expr(generator_expr&& e) noexcept = default;

    generator_expr(generator_expr& e) : generator_expr(const_cast<const generator_expr&>(e)) {
        // Nothing else to init
    }

    //Expression are invariant
    generator_expr& operator=(const generator_expr& e) = delete;
    generator_expr& operator=(generator_expr&& e) = delete;

    //Apply the expression

    value_type operator[]([[maybe_unused]] size_t i) const {
        return generator();
    }

    value_type read_flat([[maybe_unused]] size_t i) const {
        return generator();
    }

    template <typename Y>
    decltype(auto) gpu_compute_hint(Y& y) const {
        return generator.gpu_compute_hint(y);
    }

    template <typename Y>
    decltype(auto) gpu_compute(Y& y) const {
        return generator.gpu_compute(y);
    }

    template <typename E>
    constexpr bool alias(const E& rhs) const noexcept {
        return (void)rhs, false;
    }

    value_type operator()() const {
        return generator();
    }

    const Generator& get_generator() const {
        return generator;
    }

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        std_assign_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, std::forward<L>(lhs));
    }

    // Internals

    template <typename V>
    void visit([[maybe_unused]] V&& visitor) const {}

    void ensure_cpu_up_to_date() const {
        // Nothing to ensure
    }

    void ensure_gpu_up_to_date() const {
        // Nothing to ensure
    }

    friend std::ostream& operator<<(std::ostream& os, const generator_expr& expr) {
        return os << expr.get_generator();
    }
};

template <typename Generator>
struct etl_traits<etl::generator_expr<Generator>> {
    using value_type = typename Generator::value_type; 

    static constexpr bool is_etl         = true;                      
    static constexpr bool is_transformer = false;                     
    static constexpr bool is_view        = false;                     
    static constexpr bool is_magic_view  = false;                     
    static constexpr bool is_linear      = true;                      
    static constexpr bool is_thread_safe = false;                     
    static constexpr bool is_fast        = true;                      
    static constexpr bool is_value       = false;                     
    static constexpr bool is_direct      = false;                     
    static constexpr bool is_generator   = true;                      
    static constexpr bool is_temporary   = false;                     
    static constexpr bool is_padded      = false;                     
    static constexpr bool is_aligned     = false;                     
    static constexpr bool gpu_computable = Generator::gpu_computable; 
    static constexpr order storage_order = order::RowMajor;           

    template <vector_mode_t V>
    static constexpr bool vectorizable = false;

    static constexpr size_t size() {
        return 0;
    }

    static constexpr size_t dimensions() {
        return 0;
    }

    static constexpr int complexity() noexcept {
        return 4;
    }
};

} //end of namespace etl