The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time.. More...

#include <bio/alphabet/composite/tuple_base.hpp>

Inheritance diagram for bio::alphabet::tuple_base< derived_type, component_types >:

Public Member Functions
Read functions
constexpr char_type	to_char () const noexcept
	Return the letter as a character of char_type.

constexpr rank_type	to_rank () const noexcept
	Return the letter's numeric value (rank in the alphabet).

Write functions
constexpr derived_type &	assign_char (char_type const c) noexcept
	Assign from a character, implicitly converts invalid characters.

constexpr derived_type &	assign_rank (rank_type const c) noexcept
	Assign from a numeric value.

Static Public Attributes
static constexpr size_t	alphabet_size
	The size of the alphabet, i.e. the number of different values it can take.

Protected Types
Member types
using	char_type = std::conditional_t< std::same_as< void, void >, char, void >
	The char representation; conditional needed to make semi alphabet definitions legal.

using	rank_type = meta::detail::min_viable_uint_t< size - 1 >
	The type of the alphabet when represented as a number (e.g. via to_rank()).

Friends
Comparison operators (against indirect component_list)
These overloads enable comparison for all types that a component type is comparable with.
template<std::same_as< derived_type > derived_type_t, typename indirect_component_type > requires (detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> && (meta::weakly_equality_comparable_with<indirect_component_type, component_types> \|\| ...))
constexpr bool	operator== (derived_type_t const lhs, indirect_component_type const rhs) noexcept
	Comparison against types comparable with components.

template<std::same_as< derived_type > derived_type_t, typename indirect_component_type > requires (detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> && (meta::weakly_ordered_with<indirect_component_type, component_types> \|\| ...))
constexpr auto	operator<=> (derived_type_t const lhs, indirect_component_type const rhs) noexcept
	Comparison against types comparable with components.

Constructors, destructor and assignment
Attention Please do not directly use the CRTP base class. The functions are only public for the usage in their derived classes (e.g. bio::alphabet::qualified, bio::alphabet::masked).
constexpr	tuple_base (component_types... components) noexcept
	Construction from initialiser-list.

template<typename component_type > requires ((!std::is_base_of_v<tuple_base, component_type>) && is_unique_component<component_type>)
constexpr	tuple_base (component_type const alph) noexcept
	Construction via a value of one of the components.

template<typename indirect_component_type > requires (detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> && (std::is_convertible_v<indirect_component_type, component_types> \|\| ...))
constexpr	tuple_base (indirect_component_type const alph) noexcept
	Construction via a value of a subtype that is assignable to one of the components.

template<typename component_type > requires ((!std::derived_from<component_type, tuple_base>) && is_unique_component<component_type>)
constexpr derived_type &	operator= (component_type const alph) noexcept
	Assignment via a value of one of the components.

template<typename indirect_component_type > requires ((!std::derived_from<indirect_component_type, tuple_base>) && (!is_unique_component<indirect_component_type>) && (std::assignable_from<component_types, indirect_component_type> \|\| ...))
constexpr derived_type &	operator= (indirect_component_type const alph) noexcept
	Assignment via a value of a subtype that is assignable to one of the components.

Read functions
All read operations are constant complexity.
template<typename type > requires is_unique_component<type>
constexpr	operator type () const noexcept
	Implicit cast to a single letter. Works only if the type is unique in the type list.

template<size_t index>
constexpr auto	get (tuple_base &l) noexcept
	Tuple-like access to the contained components.

template<typename type > requires is_unique_component<type>
constexpr auto	get (tuple_base &l) noexcept
	Tuple-like access to the contained components.

template<size_t index>
constexpr auto	get (tuple_base const &l) noexcept
	Tuple-like access to the contained components.

template<typename type > requires is_unique_component<type>
constexpr type	get (tuple_base const &l) noexcept
	Tuple-like access to the contained components.

Detailed Description

template<typename derived_type, typename... component_types>
requires ((detail::writable_constexpr_semialphabet<component_types> && ...) && (std::regular<component_types> && ...))
class bio::alphabet::tuple_base< derived_type, component_types >

The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time.

.

Template Parameters

component_types Types of letters; must model std::regular and bio::alphabet::writable_semialphabet and all required function calls need to be callable in constexpr-context.

This data structure is a CRTP base class for combined alphabets, where the different alphabet letters exist independently as a components, similar to a tuple.

Short description:

combines multiple alphabets as independent components, similar to a tuple;
models bio::meta::tuple_like, i.e. provides a get interface to its component_list;
is itself a bio::alphabet::writable_semialphabet, but most derived types implement the full bio::alphabet::writable_alphabet;
its alphabet size is the product of the individual sizes;
constructible, assignable and comparable with each component type and also all types that these are constructible/assignable/comparable with;
explicitly convertible to each of its component types

Attention: This is a "pure base class", you cannot instantiate it, you can only inherit from it. Most likely you are interested in using one of it's descendants like bio::alphabet::qualified or bio::alphabet::masked.

See also: qualified; masked

Constructor & Destructor Documentation

◆ tuple_base() [1/2]

template<typename derived_type , typename... component_types>

template<typename component_type >
requires ((!std::is_base_of_v<tuple_base, component_type>) && is_unique_component<component_type>)

constexpr bio::alphabet::tuple_base< derived_type, component_types >::tuple_base ( component_type const alph )

inlineexplicitconstexprnoexcept

Construction via a value of one of the components.

Template Parameters

component_type Must be one uniquely contained in the type list of the composite.

Parameters

alph	The value of a component that should be assigned.

Note: Since the tuple_base is a CRTP base class, we show the working examples with one of its derived classes (bio::alphabet::qualified).

#include <bio/alphabet/nucleotide/dna4.hpp>
#include <bio/alphabet/quality/phred42.hpp>
#include <bio/alphabet/quality/qualified.hpp>
#include <bio/alphabet/fmt.hpp>
 
int main()
{
    using namespace bio::alphabet::literals;
 
    bio::alphabet::qualified<bio::alphabet::dna4, bio::alphabet::phred42> letter1{'C'_dna4};
    // creates {'C'_dna4, bio::alphabet::phred42{0}}
    bio::alphabet::qualified<bio::alphabet::dna4, bio::alphabet::phred42> letter2{bio::alphabet::phred42{1}};
    // creates {'A'_dna4, bio::alphabet::phred42{1}}
 
    if (letter1 == letter2)
        fmt::print("{}", "yeah\n"); // yeah
}

◆ tuple_base() [2/2]

template<typename derived_type , typename... component_types>

template<typename indirect_component_type >
requires (detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> && (std::is_convertible_v<indirect_component_type, component_types> || ...))

constexpr bio::alphabet::tuple_base< derived_type, component_types >::tuple_base ( indirect_component_type const alph )

inlineexplicitconstexprnoexcept

Construction via a value of a subtype that is assignable to one of the components.

Template Parameters

indirect_component_type Type that models bio::alphabet::weakly_assignable_from for one of the component types.

Parameters

alph	The value that should be assigned.

Note that the value will be assigned to the FIRST type T that fulfils assignable_from<T, indirect_component_type>, regardless if other types are also fit for assignment.

Note: Since the tuple_base is a CRTP base class, we show the working examples with one of its derived classes (bio::alphabet::qualified).

#include <bio/alphabet/nucleotide/all.hpp>
#include <bio/alphabet/quality/phred42.hpp>
#include <bio/alphabet/quality/qualified.hpp>
#include <bio/alphabet/fmt.hpp>
 
int main()
{
    using namespace bio::alphabet::literals;
    using namespace bio::alphabet::literals;
 
    // The following creates {'C'_dna4, phred42{0}}
    bio::alphabet::qualified<bio::alphabet::dna4, bio::alphabet::phred42> letter1{'C'_dna4};
    // The following also creates {'C'_dna4, bio::alphabet::phred42{0}}, since rna4 assignable to dna4
    bio::alphabet::qualified<bio::alphabet::dna4, bio::alphabet::phred42> letter2{'C'_rna4};
 
    if (letter1 == letter2)
        fmt::print("{}", "yeah\n"); // yeah
}

Member Function Documentation

◆ assign_char()

constexpr derived_type & bio::alphabet::base< derived_type, size, void >::assign_char ( char_type const c )

inlineconstexprnoexceptinherited

Assign from a character, implicitly converts invalid characters.

Parameters

c	The character to be assigned.

Provides an implementation for bio::alphabet::assign_char_to, required to model bio::alphabet::alphabet.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

◆ assign_rank()

constexpr derived_type & bio::alphabet::base< derived_type, size, void >::assign_rank ( rank_type const c )

inlineconstexprnoexceptinherited

Assign from a numeric value.

Parameters

c	The rank to be assigned.

Provides an implementation for bio::alphabet::assign_rank_to, required to model bio::alphabet::semialphabet.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

◆ operator type()

template<typename derived_type , typename... component_types>

template<typename type >
requires is_unique_component<type>

constexpr bio::alphabet::tuple_base< derived_type, component_types >::operator type ( ) const

inlineconstexprnoexcept

Implicit cast to a single letter. Works only if the type is unique in the type list.

◆ operator=() [1/2]

template<typename derived_type , typename... component_types>

template<typename component_type >
requires ((!std::derived_from<component_type, tuple_base>) && is_unique_component<component_type>)

constexpr derived_type & bio::alphabet::tuple_base< derived_type, component_types >::operator= ( component_type const alph )

inlineconstexprnoexcept

Assignment via a value of one of the components.

Template Parameters

component_type One of the component types. Must be uniquely contained in the type list of the composite.

Parameters

alph	The value of a component that should be assigned.

Note: Since the tuple_base is a CRTP base class, we show the working examples with one of its derived classes (bio::alphabet::qualified).

#include <bio/alphabet/nucleotide/dna4.hpp>
#include <bio/alphabet/quality/phred42.hpp>
#include <bio/alphabet/quality/qualified.hpp>
 
int main()
{
    using namespace bio::alphabet::literals;
 
    bio::alphabet::qualified<bio::alphabet::dna4, bio::alphabet::phred42> letter1{'T'_dna4, bio::alphabet::phred42{1}};
 
    letter1 = 'C'_dna4;           // yields {'C'_dna4, bio::alphabet::phred42{1}}
    letter1 = bio::alphabet::phred42{2}; // yields {'C'_dna4, bio::alphabet::phred42{2}}
}

◆ operator=() [2/2]

template<typename derived_type , typename... component_types>

template<typename indirect_component_type >
requires ((!std::derived_from<indirect_component_type, tuple_base>) && (!is_unique_component<indirect_component_type>) && (std::assignable_from<component_types, indirect_component_type> || ...))

constexpr derived_type & bio::alphabet::tuple_base< derived_type, component_types >::operator= ( indirect_component_type const alph )

inlineconstexprnoexcept

Assignment via a value of a subtype that is assignable to one of the components.

Template Parameters

indirect_component_type Type that models bio::alphabet::weakly_assignable_from for one of the component types.

Parameters

alph	The value of a component that should be assigned.

Note: Since the tuple_base is a CRTP base class, we show the working examples with one of its derived classes (bio::alphabet::qualified).

#include <bio/alphabet/nucleotide/all.hpp>
#include <bio/alphabet/quality/phred42.hpp>
#include <bio/alphabet/quality/qualified.hpp>
 
int main()
{
    using namespace bio::alphabet::literals;
    using namespace bio::alphabet::literals;
 
    bio::alphabet::qualified<bio::alphabet::dna4, bio::alphabet::phred42> letter1{'T'_dna4, bio::alphabet::phred42{1}};
 
    letter1 = 'C'_rna4; // yields {'C'_dna4, bio::alphabet::phred42{1}}
}

◆ to_char()

constexpr char_type bio::alphabet::base< derived_type, size, void >::to_char ( ) const

inlineconstexprnoexceptinherited

Return the letter as a character of char_type.

Provides an implementation for bio::alphabet::to_char, required to model bio::alphabet::alphabet.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

◆ to_rank()

constexpr rank_type bio::alphabet::base< derived_type, size, void >::to_rank ( ) const

inlineconstexprnoexceptinherited

Return the letter's numeric value (rank in the alphabet).

Provides an implementation for bio::alphabet::to_rank, required to model bio::alphabet::semialphabet.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

Friends And Related Function Documentation

◆ get [1/4]

template<typename derived_type , typename... component_types>

template<size_t index>

constexpr auto get ( tuple_base< derived_type, component_types > & l )

friend

Tuple-like access to the contained components.

Template Parameters

index Return the i-th element.

Returns: A proxy to the contained element that models the same alphabets concepts and supports assignment.

◆ get [2/4]

template<typename derived_type , typename... component_types>

template<typename type >
requires is_unique_component<type>

constexpr auto get ( tuple_base< derived_type, component_types > & l )

friend

Tuple-like access to the contained components.

Template Parameters

type	Return the element of specified type; only available if the type is unique in the set of components.

Returns: A proxy to the contained element that models the same alphabets concepts and supports assignment.

◆ get [3/4]

template<typename derived_type , typename... component_types>

template<size_t index>

constexpr auto get ( tuple_base< derived_type, component_types > const & l )

friend

Tuple-like access to the contained components.

Template Parameters

index Return the i-th element.

Returns: A copy of the contained element.

◆ get [4/4]

template<typename derived_type , typename... component_types>

template<typename type >
requires is_unique_component<type>

constexpr type get ( tuple_base< derived_type, component_types > const & l )

friend

Tuple-like access to the contained components.

Template Parameters

type	Return the element of specified type; only available if the type is unique in the set of components.

Returns: A copy of the contained element.

◆ operator<=>

template<typename derived_type , typename... component_types>

template<std::same_as< derived_type > derived_type_t, typename indirect_component_type >
requires (detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> && (meta::weakly_ordered_with<indirect_component_type, component_types> || ...))

constexpr auto operator<=>	(	derived_type_t const	lhs,
		indirect_component_type const	rhs
	)

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

◆ operator==

template<typename derived_type , typename... component_types>

template<std::same_as< derived_type > derived_type_t, typename indirect_component_type >
requires (detail::tuple_concept_guard<derived_type, indirect_component_type, component_types...> && (meta::weakly_equality_comparable_with<indirect_component_type, component_types> || ...))

constexpr bool operator==	(	derived_type_t const	lhs,
		indirect_component_type const	rhs
	)

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

The documentation for this class was generated from the following files:

bio/alphabet/composite/detail.hpp
bio/alphabet/composite/tuple_base.hpp

Public Member Functions

Static Public Attributes

Protected Types

Friends

Constructors, destructor and assignment

Read functions

Detailed Description

Constructor & Destructor Documentation

◆ tuple_base() [1/2]

◆ tuple_base() [2/2]

Member Function Documentation

◆ assign_char()

Complexity

Exceptions

◆ assign_rank()

Complexity

Exceptions

◆ operator type()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ to_char()

Complexity

Exceptions

◆ to_rank()

Complexity

Exceptions

Friends And Related Function Documentation

◆ get [1/4]

◆ get [2/4]

◆ get [3/4]

◆ get [4/4]

◆ operator<=>

◆ operator==