stl_extensions.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2019 - 2023.
// 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 SL_UTILITY_CONCEPTS_STL_EXTENSIONS_HPP
#define SL_UTILITY_CONCEPTS_STL_EXTENSIONS_HPP
 
#pragma once
 
#include <compare>
#include <concepts>
 
// ReSharper disable CppClangTidyClangDiagnosticDocumentation
// ReSharper disable CppIdenticalOperandsInBinaryExpression
// ReSharper disable CppClangTidyMiscRedundantExpression
 
namespace sl::concepts
{
    template <class T>
    concept pointer = std::is_pointer_v<T>;
 
    template <class T>
    concept reference = std::is_reference_v<T>;
 
    template <class T>
    concept decayed = std::same_as<std::decay_t<T>, T>;
 
    template <class T>
    concept unqualified = std::same_as<std::remove_cvref_t<T>, T>;
 
    template <class TLhs, class TRhs>
    concept not_same_as = !std::same_as<TLhs, TRhs>;
 
    template <class TSource, class TTarget>
    concept initializes = std::constructible_from<TTarget, TSource>;
 
    template <class TSource, class TTarget>
    concept assignable_to = std::assignable_from<TTarget, TSource>;
 
    template <class T>
    concept weakly_equality_comparable = requires(const std::remove_cvref_t<T>& t)
    {
        { t == t } -> std::convertible_to<bool>;
        { t != t } -> std::convertible_to<bool>;
    };
 
    template <class T>
    concept nothrow_weakly_equality_comparable = weakly_equality_comparable<T>
                                                && requires(const std::remove_cvref_t<T>& t)
                                                {
                                                    { t == t } noexcept -> std::convertible_to<bool>;
                                                    { t != t } noexcept -> std::convertible_to<bool>;
                                                };
 
    template <class T1, class T2>
    concept weakly_equality_comparable_with = requires(const std::remove_cvref_t<T1>& t1, const std::remove_cvref_t<T2>& t2)
    {
        { t1 == t2 } -> std::convertible_to<bool>;
        { t1 != t2 } -> std::convertible_to<bool>;
        { t2 == t1 } -> std::convertible_to<bool>;
        { t2 != t1 } -> std::convertible_to<bool>;
    };
 
    template <class T1, class T2>
    concept nothrow_weakly_equality_comparable_with = requires(const std::remove_cvref_t<T1>& t1, const std::remove_cvref_t<T2>& t2)
    {
        { t1 == t2 } noexcept -> std::convertible_to<bool>;
        { t1 != t2 } noexcept -> std::convertible_to<bool>;
        { t2 == t1 } noexcept -> std::convertible_to<bool>;
        { t2 != t1 } noexcept -> std::convertible_to<bool>;
    };
 
    template <class T>
    concept comparison_category = !std::is_void_v<std::common_comparison_category_t<T>>;
 
    template <class TFrom, class TTo>
    concept explicitly_convertible_to = requires
    {
        static_cast<TTo>(std::declval<TFrom>());
    };
 
    template <class TFrom, class TTo>
    concept nothrow_explicitly_convertible_to = requires
    {
        { static_cast<TTo>(std::declval<TFrom>()) } noexcept;
    };
 
}
 
namespace sl::concepts::detail
{
    template <class Category, class MinimumCategory>
    concept compares_as = comparison_category<Category>
                        && comparison_category<MinimumCategory>
                        && std::same_as<std::common_comparison_category_t<Category, MinimumCategory>, MinimumCategory>;
}
 
namespace sl::concepts
{
    template <class T, class MinimumCategory = std::partial_ordering>
    concept weakly_three_way_comparable = weakly_equality_comparable<T>
                                        && comparison_category<MinimumCategory>
                                        && requires(const std::remove_reference_t<T>& t)
                                        {
                                            { t <=> t } -> detail::compares_as<MinimumCategory>;
                                        };
 
    template <class T, class MinimumCategory = std::partial_ordering>
    concept nothrow_weakly_three_way_comparable = nothrow_weakly_equality_comparable<T>
                                                && comparison_category<MinimumCategory>
                                                && requires(const std::remove_reference_t<T>& t)
                                                {
                                                    { t <=> t } noexcept -> detail::compares_as<MinimumCategory>;
                                                };
 
    template <class T1, class T2, class MinimumCategory = std::partial_ordering>
    concept weakly_three_way_comparable_with =
        weakly_equality_comparable_with<T1, T2>
        && comparison_category<MinimumCategory>
        && requires(const std::remove_reference_t<T1>& t1, const std::remove_reference_t<T2>& t2)
        {
            { t1 <=> t2 } -> detail::compares_as<MinimumCategory>;
            { t2 <=> t1 } -> detail::compares_as<MinimumCategory>;
        };
 
    template <class T1, class T2, class MinimumCategory = std::partial_ordering>
    concept nothrow_weakly_three_way_comparable_with =
        nothrow_weakly_equality_comparable_with<T1, T2>
        && comparison_category<MinimumCategory>
        && requires(const std::remove_reference_t<T1>& t1, const std::remove_reference_t<T2>& t2)
        {
            { t1 <=> t2 } noexcept -> detail::compares_as<MinimumCategory>;
            { t2 <=> t1 } noexcept -> detail::compares_as<MinimumCategory>;
        };
 
}
 
#endif