Loading...
Searching...
No Matches
seqan3::alphabet_tuple_base< derived_type, component_types > Class Template Reference
Alphabet » Composite

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

`#include <seqan3/alphabet/composite/alphabet_tuple_base.hpp>`

Inheritance diagram for seqan3::alphabet_tuple_base< derived_type, component_types >:
[legend]

## Public Member Functions

constexpr derived_type & | assign_rank (rank_type const c) noexcept
| Assign from a numeric value.
constexpr rank_type | to_rank () const noexcept
| Return the letter's numeric value (rank in the alphabet).
Public Member Functions inherited from seqan3::alphabet_base< derived_type,(1 *... *alphabet_size< component_types >), void >
constexpr | alphabet_base () noexcept=default
| Defaulted.
constexpr | alphabet_base (alphabet_base const &) noexcept=default
| Defaulted.
constexpr | alphabet_base (alphabet_base &&) noexcept=default
| Defaulted.
constexpr alphabet_base & | operator= (alphabet_base const &) noexcept=default
| Defaulted.
constexpr alphabet_base & | operator= (alphabet_base &&) noexcept=default
| Defaulted.
| ~alphabet_base () noexcept=default
| Defaulted.
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).
constexpr derived_type & | assign_char (char_type const chr) 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 detail::min_viable_uint_t< size > | alphabet_size
| The size of the alphabet, i.e. the number of different values it can take.
Static Public Attributes inherited from seqan3::alphabet_base< derived_type,(1 *... *alphabet_size< component_types >), void >
static constexpr detail::min_viable_uint_t< size > | alphabet_size
| The size of the alphabet, i.e. the number of different values it can take.

## Friends

Comparison operators (against indirect component_list)
These overloads enable comparison for all types that a component type is comparable with.
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator== (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
| Comparison against types comparable with components.
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator== (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator!= (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator!= (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator< (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator< (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator<= (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator<= (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator> (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator> (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator>= (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
template<typename derived_type_t, typename indirect_component_type>
constexpr auto | operator>= (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
Friends inherited from seqan3::alphabet_base< derived_type,(1 *... *alphabet_size< component_types >), void >

## 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. seqan3::qualified, seqan3::masked, seqan3::structure_rna and seqan3::structure_aa).

constexpr | alphabet_tuple_base (component_types... components) noexcept
| Construction from initialiser-list.
template<typename component_type> requires (!std::is_base_of_v<alphabet_tuple_base, component_type>) && is_unique_component<component_type>
constexpr | alphabet_tuple_base (component_type const alph) noexcept
| Construction via a value of one of the components.
template<typename indirect_component_type> requires ((detail::instantiate_if_v< detail::lazy<std::is_convertible, indirect_component_type, component_types>, detail::tuple_general_guard<derived_type, indirect_component_type, component_types...>> || ...))
constexpr | alphabet_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, alphabet_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, alphabet_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 (alphabet_tuple_base &l) noexcept
| Tuple-like access to the contained components.
template<typename type> requires is_unique_component<type>
constexpr auto | get (alphabet_tuple_base &l) noexcept
| Tuple-like access to the contained components.
template<size_t index>
constexpr auto | get (alphabet_tuple_base const &l) noexcept
| Tuple-like access to the contained components.
template<typename type> requires is_unique_component<type>
constexpr type | get (alphabet_tuple_base const &l) noexcept
| Tuple-like access to the contained components.

## Additional Inherited Members

Protected Types inherited from seqan3::alphabet_base< derived_type,(1 *... *alphabet_size< component_types >), void >
using | char_type
| The char representation; conditional needed to make semi alphabet definitions legal.
using | rank_type
| The type of the alphabet when represented as a number (e.g. via to_rank()).

## Detailed Description

template<typename derived_type, typename... component_types>
requires (detail::writable_constexpr_semialphabet<component_types> && ...) && (std::regular<component_types> && ...)
class seqan3::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 seqan3::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 seqan3::tuple_like, i.e. provides a get interface to its component_list;
- is itself a seqan3::writable_semialphabet, but most derived types implement the full seqan3::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 seqan3::qualified or seqan3::masked.

See also
  qualified
  masked

This entity is stable. Since version 3.1.

## Constructor & Destructor Documentation

## alphabet_tuple_base() [1/2]

template<typename derived_type, typename... component_types>
template<typename component_type>
requires (!std::is_base_of_v<alphabet_tuple_base, component_type>) && is_unique_component<component_type>

seqan3::alphabet_tuple_base< derived_type, component_types >::alphabet_tuple_base | ( | component_type const | alph | ) |

inline explicit constexpr noexcept

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 alphabet_tuple_base is a CRTP base class, we show the working examples with one of its derived classes (seqan3::qualified).

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/core/debug_stream.hpp>
int main()
{
using namespace seqan3::literals;
seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'C'_dna4}; // creates {'C'_dna4, '!'_phred42}
seqan3::qualified<seqan3::dna4, seqan3::phred42> letter2{'"'_phred42}; // creates {'A'_dna4, '"'_phred42}
if (letter1 == letter2)
seqan3::debug_stream << "yeah\n"; // yeah
}
seqan3::qualified
Joins an arbitrary alphabet with a quality alphabet.
Definition qualified.hpp:59
debug_stream.hpp
Provides seqan3::debug_stream and related types.
dna4.hpp
Provides seqan3::dna4, container aliases and string literals.
seqan3::debug_stream
debug_stream_type debug_stream
A global instance of seqan3::debug_stream_type.
Definition debug_stream.hpp:38
seqan3::literals
The SeqAn namespace for literals.
phred42.hpp
Provides seqan3::phred42 quality scores.
qualified.hpp
Provides quality alphabet composites.

This entity is stable. Since version 3.1.

## alphabet_tuple_base() [2/2]

template<typename derived_type, typename... component_types>
template<typename indirect_component_type>
requires ((detail::instantiate_if_v< detail::lazy<std::is_convertible, indirect_component_type, component_types>, detail::tuple_general_guard<derived_type, indirect_component_type, component_types...>> || ...))

seqan3::alphabet_tuple_base< derived_type, component_types >::alphabet_tuple_base | ( | indirect_component_type const | alph | ) |

inline explicit constexpr noexcept

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

Template Parameters

  indirect_component_type | Type that models seqan3::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 alphabet_tuple_base is a CRTP base class, we show the working examples with one of its derived classes (seqan3::qualified).

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <seqan3/alphabet/nucleotide/all.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/core/debug_stream.hpp>
int main()
{
using namespace seqan3::literals;
// The following creates {'C'_dna4, '!'_phred42}
seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'C'_dna4};
// The following also creates {'C'_dna4, '!'_phred42}, since rna4 assignable to dna4
seqan3::qualified<seqan3::dna4, seqan3::phred42> letter2{'C'_rna4};
if (letter1 == letter2)
seqan3::debug_stream << "yeah\n"; // yeah
}
all.hpp
Meta-header for the Alphabet / Nucleotide submodule .

This entity is experimental and subject to change in the future. Experimental since version 3.1.

## Member Function Documentation

## assign_rank()

template<typename derived_type, typename... component_types>

derived_type & seqan3::alphabet_base< derived_type, size, void >::assign_rank | ( | rank_type const | c | ) |

inline constexpr noexcept

Assign from a numeric value.

Parameters

  c | The rank to be assigned.

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

### Complexity

Constant.

### Exceptions

Guaranteed not to throw.

This entity is stable. Since version 3.1.

## operator type()

template<typename derived_type, typename... component_types>
template<typename type>
requires is_unique_component<type>

seqan3::alphabet_tuple_base< derived_type, component_types >::operator type | ( |  | ) | const

inline constexpr noexcept

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

This entity is stable. Since version 3.1.

## operator=() [1/2]

template<typename derived_type, typename... component_types>
template<typename component_type>
requires (!std::derived_from<component_type, alphabet_tuple_base>) && is_unique_component<component_type>

derived_type & seqan3::alphabet_tuple_base< derived_type, component_types >::operator= | ( | component_type const | alph | ) |

inline constexpr noexcept

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 alphabet_tuple_base is a CRTP base class, we show the working examples with one of its derived classes (seqan3::qualified).

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
int main()
{
using namespace seqan3::literals;
seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'T'_dna4, '"'_phred42};
letter1 = 'C'_dna4; // yields {'C'_dna4, '"'_phred42}
letter1 = '#'_phred42; // yields {'C'_dna4, '#'_phred42}
}

This entity is stable. Since version 3.1.

## operator=() [2/2]

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

derived_type & seqan3::alphabet_tuple_base< derived_type, component_types >::operator= | ( | indirect_component_type const | alph | ) |

inline constexpr noexcept

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

Template Parameters

  indirect_component_type | Type that models seqan3::weakly_assignable_from for one of the component types.

Parameters

  alph | The value of a component that should be assigned.

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

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <seqan3/alphabet/nucleotide/all.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
int main()
{
using namespace seqan3::literals;
seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'T'_dna4, '"'_phred42};
letter1 = 'C'_rna4; // yields {'C'_dna4, '"'_phred42}
}

This entity is experimental and subject to change in the future. Experimental since version 3.1.

## to_rank()

template<typename derived_type, typename... component_types>

rank_type seqan3::alphabet_base< derived_type, size, void >::to_rank | ( |  | ) | const

inline constexpr noexcept

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

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

### Complexity

Constant.

### Exceptions

Guaranteed not to throw.

This entity is stable. Since version 3.1.

## Friends And Related Symbol Documentation

## get [1/4]

template<typename derived_type, typename... component_types>
template<typename type>
requires is_unique_component<type>

auto get | ( | alphabet_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.

This entity is stable. Since version 3.1.

## get [2/4]

template<typename derived_type, typename... component_types>
template<size_t index>

auto get | ( | alphabet_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.

This entity is stable. Since version 3.1.

## get [3/4]

template<typename derived_type, typename... component_types>
template<typename type>
requires is_unique_component<type>

type get | ( | alphabet_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.

This entity is stable. Since version 3.1.

## get [4/4]

template<typename derived_type, typename... component_types>
template<size_t index>

auto get | ( | alphabet_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.

This entity is stable. Since version 3.1.

## operator!= [1/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator!= | ( | derived_type_t const | lhs,
|  | indirect_component_type const | rhs )->std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator!= [2/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator!= | ( | indirect_component_type const | lhs,
|  | derived_type_t const | rhs )->std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator< [1/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator< | ( | derived_type_t const | lhs,
|  | indirect_component_type const | rhs )->std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator< [2/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator< | ( | indirect_component_type const | lhs,
|  | derived_type_t const | rhs )->std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator<= [1/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator<= | ( | derived_type_t const | lhs,
|  | indirect_component_type const | rhs )->std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator<= [2/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator<= | ( | indirect_component_type const | lhs,
|  | derived_type_t const | rhs )->std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator== [1/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator== | ( | derived_type_t const | lhs,
|  | indirect_component_type const | rhs )->std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

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.

This entity is experimental and subject to change in the future. Experimental since version 3.1.

## operator== [2/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator== | ( | indirect_component_type const | lhs,
|  | derived_type_t const | rhs )->std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator> [1/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator> | ( | derived_type_t const | lhs,
|  | indirect_component_type const | rhs )->std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator> [2/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator> | ( | indirect_component_type const | lhs,
|  | derived_type_t const | rhs )->std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator>= [1/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator>= | ( | derived_type_t const | lhs,
|  | indirect_component_type const | rhs )->std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## operator>= [2/2]

template<typename derived_type, typename... component_types>
template<typename derived_type_t, typename indirect_component_type>

auto operator>= | ( | indirect_component_type const | lhs,
|  | derived_type_t const | rhs )->std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >

friend

## Member Data Documentation

## alphabet_size

template<typename derived_type, typename... component_types>

detail::min_viable_uint_t<size> seqan3::alphabet_base< derived_type, size, void >::alphabet_size

static constexpr

The size of the alphabet, i.e. the number of different values it can take.

This entity is stable. Since version 3.1.

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

- alphabet_tuple_base.hpp

Hide me