core_language.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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>
#include <seqan3/std/ranges>

namespace seqan3::detail
{

template <typename lhs_t, typename rhs_t>
SEQAN3_CONCEPT WeaklyEqualityComparableByMembersWith = requires (lhs_t const & lhs, rhs_t const & rhs)
{
    lhs.operator==(rhs); std::Boolean<decltype(lhs.operator==(rhs))>;
    lhs.operator!=(rhs); std::Boolean<decltype(lhs.operator!=(rhs))>;
};

template <typename lhs_t, typename rhs_t>
SEQAN3_CONCEPT WeaklyOrderedByMembersWith = requires (lhs_t const & lhs, rhs_t const & rhs)
{
    lhs.operator< (rhs); std::Boolean<decltype(lhs.operator< (rhs))>;
    lhs.operator> (rhs); std::Boolean<decltype(lhs.operator> (rhs))>;
    lhs.operator<=(rhs); std::Boolean<decltype(lhs.operator<=(rhs))>;
    lhs.operator>=(rhs); std::Boolean<decltype(lhs.operator>=(rhs))>;
};

template <typename source_t, typename target_t>
SEQAN3_CONCEPT ConvertibleToByMember = requires (source_t s)
{
    { s.operator target_t() } -> target_t;
};

} // seqan3::detail

namespace seqan3
{

template <typename t1, typename t2>
SEQAN3_CONCEPT WeaklyOrderedWith = requires (std::remove_reference_t<t1> const & v1,
                                                     std::remove_reference_t<t2> const & v2)
{
    { v1 <  v2 } -> bool &&;
    { v1 <= v2 } -> bool &&;
    { v2 >  v1 } -> bool &&;
    { v2 >= v1 } -> bool &&;
};

template <typename t, typename u>
SEQAN3_CONCEPT ImplicitlyConvertibleTo = std::is_convertible_v<t, u>;

template <typename t, typename u>
SEQAN3_CONCEPT ExplicitlyConvertibleTo = requires (t vt) { { static_cast<u>(vt)}; };

template <typename t>
SEQAN3_CONCEPT Arithmetic = std::is_arithmetic_v<t>;

template <typename t>
SEQAN3_CONCEPT FloatingPoint = Arithmetic<t> && std::is_floating_point_v<t>;


template <typename t>
SEQAN3_CONCEPT Char = std::Integral<t> &&
                      (std::Same<t, char> || std::Same<t, unsigned char> || std::Same<t, signed char> ||
#ifdef __cpp_char8_t
                       std::Same<t, char8_t> ||
#endif
                       std::Same<t, char16_t> || std::Same<t, char32_t> || std::Same<t, wchar_t>);

template <typename t>
SEQAN3_CONCEPT TriviallyDestructible = std::Destructible<t> && std::is_trivially_destructible_v<t>;

template <typename t>
SEQAN3_CONCEPT TriviallyCopyable = std::Copyable<t> && std::is_trivially_copyable_v<t>;

template <typename t>
SEQAN3_CONCEPT Trivial = TriviallyCopyable<t> && TriviallyDestructible<t> && std::is_trivial_v<t>;

template <typename t>
SEQAN3_CONCEPT StandardLayout = std::is_standard_layout_v<t>;

template <typename t, typename u>
SEQAN3_CONCEPT WeaklyAssignable = std::is_assignable_v<t, u>;

}  // namespace seqan3