Concepts.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2021 - 2022.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SIMPLE_VECTOR_CONCEPTS_HPP
#define SIMPLE_VECTOR_CONCEPTS_HPP
 
#pragma once
 
#include <concepts>
#include <type_traits>
 
namespace sl::vec
{
    template <class TFrom, class TTo = TFrom>
    concept add_assignable = requires(TTo lhs, TFrom rhs)
    {
        { lhs += rhs };
    };
 
    template <class TFrom, class TTo = TFrom>
    concept sub_assignable = requires(TTo lhs, TFrom rhs)
    {
        { lhs -= rhs };
    };
 
    template <class TFrom, class TTo = TFrom>
    concept mul_assignable = requires(TTo lhs, TFrom rhs)
    {
        { lhs *= rhs };
    };
 
    template <class TFrom, class TTo = TFrom>
    concept div_assignable = requires(TTo lhs, TFrom rhs)
    {
        { lhs /= rhs };
    };
 
    template <class TFrom, class TTo = TFrom>
    concept mod_assignable = requires(TTo lhs, TFrom rhs)
    {
        { lhs %= rhs };
    };
 
    template <class TFrom, class TTo = TFrom>
    concept addable = requires(TTo lhs, TFrom rhs)
    {
        { lhs + rhs } -> std::convertible_to<TTo>;
    };
 
    template <class TFrom, class TTo = TFrom>
    concept subable = requires(TTo lhs, TFrom rhs)
    {
        { lhs - rhs } -> std::convertible_to<TTo>;
    };
 
    template <class TFrom, class TTo = TFrom>
    concept mulable = requires(TTo lhs, TFrom rhs)
    {
        { lhs * rhs } -> std::convertible_to<TTo>;
    };
 
    template <class TFrom, class TTo = TFrom>
    concept divable = requires(TTo lhs, TFrom rhs)
    {
        { lhs / rhs } -> std::convertible_to<TTo>;
    };
 
    template <class TFrom, class TTo = TFrom>
    concept modable = requires(TTo lhs, TFrom rhs)
    {
        { lhs % rhs } -> std::convertible_to<TTo>;
    };
 
    template <class TBinaryOp, class TResult, class TArg1, class TArg2>
    concept binary_invokable_with_all_overloads_implicit_convertible_to =
    std::is_convertible_v<std::invoke_result_t<TBinaryOp&, TArg1, TArg1>, TResult> &&
    std::is_convertible_v<std::invoke_result_t<TBinaryOp&, TArg1, TArg2>, TResult> &&
    std::is_convertible_v<std::invoke_result_t<TBinaryOp&, TArg2, TArg1>, TResult> &&
    std::is_convertible_v<std::invoke_result_t<TBinaryOp&, TArg2, TArg2>, TResult>;
 
    template <class T>
    concept value_type = std::regular<std::remove_cvref_t<T>> &&
                        addable<std::remove_cvref_t<T>> &&
                        subable<std::remove_cvref_t<T>> &&
                        mulable<std::remove_cvref_t<T>> &&
                        divable<std::remove_cvref_t<T>>;
 
    template <class T>
    struct vector_traits
    {
    };
 
    template <class T>
    using vector_value_t = typename vector_traits<std::remove_cvref_t<T>>::value_type;
 
    template <class T>
    constexpr auto vector_dims_v = vector_traits<std::remove_cvref_t<T>>::dimensions;
 
    template <class T>
    struct is_vectorial : std::false_type
    {
    };
 
    template <class T>
    constexpr bool is_vectorial_v = is_vectorial<T>::value;
 
    template <class T>
    concept vectorial = is_vectorial_v<std::remove_cvref_t<T>>;
 
}
 
#endif