detail.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>

namespace seqan3::detail
{

// ------------------------------------------------------------------
// AlphabetTupleBase
// ------------------------------------------------------------------

template <typename t>
SEQAN3_CONCEPT AlphabetTupleBase = requires
{
    typename t::seqan3_tuple_components;
    typename t::seqan3_recursive_tuple_components;
};

// ------------------------------------------------------------------
// tuple_components
// ------------------------------------------------------------------

template <typename t>
struct tuple_components;

template <AlphabetTupleBase t>
struct tuple_components<t>
{
    using type = typename t::seqan3_tuple_components;
};

// ------------------------------------------------------------------
// recursive_tuple_components
// ------------------------------------------------------------------

template <typename t>
struct recursive_tuple_components;

template <AlphabetTupleBase t>
struct recursive_tuple_components<t>
{
    using type = typename t::seqan3_recursive_tuple_components;
};

// ------------------------------------------------------------------
// Callable concept helpers for meta::invoke
// ------------------------------------------------------------------

template <typename T>
struct constructible_from
{
    template <typename type>
    using invoke = std::integral_constant<bool, std::is_constructible_v<type, T>>;
};

template <typename T>
struct implicitly_convertible_from
{
    template <typename type>
    using invoke = std::integral_constant<bool, ImplicitlyConvertibleTo<T, type>>;
};

template <typename T>
struct assignable_from
{
    template <typename type>
    using invoke = std::integral_constant<bool, WeaklyAssignable<type, T>>;
};

template <typename T>
struct weakly_equality_comparable_with
{
    template <typename type>
    using invoke = std::integral_constant<bool, std::detail::WeaklyEqualityComparableWith<type, T>>;
};

template <typename T>
struct weakly_ordered_with
{
    template <typename type>
    using invoke = std::integral_constant<bool, WeaklyOrderedWith<type, T>>;
};

} // namespace seqan3::detail

// ------------------------------------------------------------------
// Forwards
// ------------------------------------------------------------------

namespace seqan3
{

// forward
template <typename ...alternative_types>
    requires (detail::WritableConstexprAlphabet<alternative_types> && ...) &&
             (!std::is_reference_v<alternative_types> && ...) &&
             (sizeof...(alternative_types) >= 2)
             //TODO same char_type
class alphabet_variant;

template <typename derived_type,
          typename ...component_types>
    requires (detail::WritableConstexprSemialphabet<component_types> && ...) &&
             (!std::is_reference_v<component_types> && ...)
class alphabet_tuple_base;

} // namespace seqan3