tmp.hpp

//=======================================================================
// 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 <template <typename, size_t> typename TT, typename T>
struct is_2 : std::false_type {};

template <template <typename, size_t> typename TT, typename V1, size_t R>
struct is_2<TT, TT<V1, R>> : std::true_type {};

template <template <typename, size_t, size_t> typename TT, typename T>
struct is_3 : std::false_type {};

template <template <typename, size_t, size_t> typename TT, typename V1, size_t R1, size_t R2>
struct is_3<TT, TT<V1, R1, R2>> : std::true_type {};

template <template <typename, size_t...> typename TT, typename T>
struct is_var : std::false_type {};

template <template <typename, size_t...> typename TT, typename V1, size_t... R>
struct is_var<TT, TT<V1, R...>> : std::true_type {};

template <template <typename, typename, size_t...> typename TT, typename T>
struct is_var_2 : std::false_type {};

template <template <typename, typename, size_t...> typename TT, typename V1, typename V2, size_t... R>
struct is_var_2<TT, TT<V1, V2, R...>> : std::true_type {};

template <typename T>
struct etl_traits;

template <typename E>
using decay_traits = etl_traits<std::decay_t<E>>;

template <typename E>
using value_t = typename decay_traits<E>::value_type;

template <typename S>
using memory_t =
    std::conditional_t<std::is_const_v<std::remove_reference_t<S>>, typename std::decay_t<S>::const_memory_type, typename std::decay_t<S>::memory_type>;

template <typename S>
using const_memory_t = typename std::decay_t<S>::const_memory_type;

template <size_t S, size_t I, size_t F, size_t... Dims>
constexpr size_t nth_size() {
    if constexpr (I < S) {
        return nth_size<S, I + 1, Dims...>();
    } else {
        return F;
    }
}

template <size_t D1, size_t... D>
size_t dyn_nth_size(size_t i) {
    if constexpr (sizeof...(D)) {
        return i == 0 ? D1 : dyn_nth_size<D...>(i - 1);
    } else {
        cpp_assert(i == 0, "Invalid recursion");
        return D1;
    }
}

template <typename S1, typename S2, typename Enable = void>
struct sequence_equal;

template <>
struct sequence_equal<std::index_sequence<>, std::index_sequence<>> : std::true_type {};

template <size_t... I1, size_t... I2>
struct sequence_equal<std::index_sequence<I1...>, std::index_sequence<I2...>, std::enable_if_t<sizeof...(I1) != sizeof...(I2)>> : std::false_type {};

template <size_t I, size_t... I1, size_t... I2>
struct sequence_equal<std::index_sequence<I, I1...>, std::index_sequence<I, I2...>, std::enable_if_t<sizeof...(I1) == sizeof...(I2)>>
        : sequence_equal<std::index_sequence<I1...>, std::index_sequence<I2...>> {};

template <size_t I11, size_t I21, size_t... I1, size_t... I2>
struct sequence_equal<std::index_sequence<I11, I1...>, std::index_sequence<I21, I2...>, cpp::disable_if_t<I11 == I21>> : std::false_type {};

template <typename Int, typename T, Int Begin>
struct integer_range_impl;

template <typename Int, Int... N, Int Begin>
struct integer_range_impl<Int, std::integer_sequence<Int, N...>, Begin> {
    using type = std::integer_sequence<Int, N + Begin...>;
};

template <typename Int, Int Begin, Int End>
using make_integer_range = typename integer_range_impl<Int, std::make_integer_sequence<Int, End - Begin>, Begin>::type;

template <size_t Begin, size_t End>
using make_index_range = make_integer_range<size_t, Begin, End>;

template <typename... Dims>
std::string concat_sizes(Dims... sizes) {
    std::array<size_t, sizeof...(Dims)> tmp{{sizes...}};
    std::string result;
    std::string sep;
    for (auto& v : tmp) {
        result += sep;
        result += std::to_string(v);
        sep = ",";
    }
    return result;
}

struct dereference_op {
    template <typename T>
    static decltype(auto) apply(T&& t) {
        return *(std::forward<T>(t));
    }
};

struct forward_op {
    template <typename T>
    static decltype(auto) apply(T&& t) {
        return std::forward<T>(t);
    }
};

template <typename T>
using remove_const_deep = std::
    conditional_t<std::is_lvalue_reference_v<T>, std::add_lvalue_reference_t<std::remove_cvref_t<T>>, std::remove_const_t<T>>;

struct forward_op_nc {
    template <typename T>
    static decltype(auto) apply(T&& t) {
        using real_type = decltype(std::forward<T>(t));
        return const_cast<remove_const_deep<real_type>>(std::forward<T>(t));
    }
};

template <bool B, typename T>
constexpr decltype(auto) optional_move(T&& t) {
    if constexpr (B) {
        return std::move(t);
    } else {
        return std::forward<T>(t);
    }
}

} //end of namespace etl