core_language.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <type_traits>
 
#include <seqan3/core/platform.hpp>
#include <seqan3/std/concepts>
 
namespace seqan3::detail
{
 
template <class T, class U>
SEQAN3_CONCEPT weakly_equality_comparable_with =
    requires(std::remove_reference_t<T> const & t,
             std::remove_reference_t<U> const & u)
    {
        std::convertible_to<decltype(t == u), bool>;
        std::convertible_to<decltype(t != u), bool>;
        std::convertible_to<decltype(u == t), bool>;
        std::convertible_to<decltype(u != t), bool>;
    };
 
template <typename lhs_t, typename rhs_t>
struct weakly_equality_comparable_with_trait :
    std::integral_constant<bool, weakly_equality_comparable_with<lhs_t, rhs_t>>
{};
 
template <typename t1, typename t2>
SEQAN3_CONCEPT weakly_ordered_with = requires (std::remove_reference_t<t1> const & v1,
                                               std::remove_reference_t<t2> const & v2)
{
    std::convertible_to<decltype(v1 <  v2), bool>;
    std::convertible_to<decltype(v1 <= v2), bool>;
    std::convertible_to<decltype(v1 >  v2), bool>;
    std::convertible_to<decltype(v1 >= v2), bool>;
 
    std::convertible_to<decltype(v2 <  v1), bool>;
    std::convertible_to<decltype(v2 <= v1), bool>;
    std::convertible_to<decltype(v2 >  v1), bool>;
    std::convertible_to<decltype(v2 >= v1), bool>;
};
 
template <typename lhs_t, typename rhs_t>
struct weakly_ordered_with_trait : std::integral_constant<bool, weakly_ordered_with<lhs_t, rhs_t>>
{};
 
 
} // seqan3::detail
 
namespace seqan3
{
 
template <typename t, typename u>
SEQAN3_CONCEPT implicitly_convertible_to = std::is_convertible_v<t, u>;
 
template <typename t, typename u>
SEQAN3_CONCEPT explicitly_convertible_to = requires (t vt) { { static_cast<u>(vt)}; };
 
template <typename t>
SEQAN3_CONCEPT arithmetic = std::is_arithmetic_v<t>;
 
template <typename t>
SEQAN3_CONCEPT floating_point = arithmetic<t> && std::is_floating_point_v<t>;
 
 
template <typename t>
SEQAN3_CONCEPT builtin_character = std::integral<t> &&
                      (std::same_as<t, char> || std::same_as<t, unsigned char> || std::same_as<t, signed char> ||
#ifdef __cpp_char8_t
                       std::same_as<t, char8_t> ||
#endif
                       std::same_as<t, char16_t> || std::same_as<t, char32_t> || std::same_as<t, wchar_t>);
 
template <typename t>
SEQAN3_CONCEPT trivially_destructible = std::destructible<t> && std::is_trivially_destructible_v<t>;
 
template <typename t>
SEQAN3_CONCEPT trivially_copyable = std::copyable<t> && std::is_trivially_copyable_v<t>;
 
template <typename t>
SEQAN3_CONCEPT trivial = trivially_copyable<t> && trivially_destructible<t> && std::is_trivial_v<t>;
 
template <typename t>
SEQAN3_CONCEPT standard_layout = std::is_standard_layout_v<t>;
 
template <typename t, typename u>
SEQAN3_CONCEPT weakly_assignable_from = std::is_assignable_v<t, u>;
 
}  // namespace seqan3