Loading...
Searching...
No Matches
seqan3::alphabet_variant< alternative_types > Class Template Reference
Alphabet » Composite

A combined alphabet that can hold values of either of its alternatives.. More...

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

Inheritance diagram for seqan3::alphabet_variant< alternative_types >:
[legend]

## Public Member Functions

constexpr alphabet_variant< alternative_types... > & | assign_rank (rank_type const c) noexcept
| Assign from a numeric value.
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).
Constructors, destructor and assignment
constexpr | alphabet_variant () noexcept=default
| Defaulted.
constexpr | alphabet_variant (alphabet_variant const &) noexcept=default
| Defaulted.
constexpr | alphabet_variant (alphabet_variant &&) noexcept=default
| Defaulted.
constexpr alphabet_variant & | operator= (alphabet_variant const &) noexcept=default
| Defaulted.
constexpr alphabet_variant & | operator= (alphabet_variant &&) noexcept=default
| Defaulted.
| ~alphabet_variant () noexcept=default
| Defaulted.
template<typename alternative_t> requires (!std::same_as<alternative_t, alphabet_variant>) && (!detail::is_span<alternative_t>::value) && (!std::is_base_of_v<alphabet_variant, alternative_t>) && (!list_traits::contains< alphabet_variant, detail::transformation_trait_or_t<detail::recursive_required_types<alternative_t>, type_list<>>>) && (is_alternative<alternative_t>())
constexpr | alphabet_variant (alternative_t const alternative) noexcept
| Construction via the value of an alternative.
template<typename indirect_alternative_t> requires (!detail::is_span<indirect_alternative_t>::value) && (( detail::instantiate_if_v<detail::lazy<std::is_convertible, indirect_alternative_t, alternative_types>, detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...))
constexpr | alphabet_variant (indirect_alternative_t const rhs) noexcept
| Constructor for arguments implicitly convertible to an alternative.

template<typename indirect_alternative_t>
requires ( (!(detail::instantiate_if_v<detail::lazy<std::is_convertible, indirect_alternative_t, alternative_types>, detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...)) && (detail::instantiate_if_v<detail::lazy<std::is_constructible, alternative_types, indirect_alternative_t>, detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...))

constexpr | alphabet_variant (indirect_alternative_t const rhs) noexcept
| Constructor for arguments explicitly (but not implicitly) convertible to an alternative.
template<typename indirect_alternative_t> requires (detail::variant_general_guard<indirect_alternative_t, alternative_types...> && (weakly_assignable_from<alternative_types, indirect_alternative_t> || ...))
constexpr alphabet_variant & | operator= (indirect_alternative_t const &rhs) noexcept
| Assignment for arguments assignable to an alternative.
Conversion (by index)
template<size_t index>
constexpr bool | holds_alternative () const noexcept
| Whether the variant alphabet currently holds a value of the given alternative.
template<size_t index>
constexpr auto | convert_to () const
| Convert to the specified alphabet (throws if holds_alternative() would be false).
template<size_t index>
constexpr auto | convert_unsafely_to () const noexcept
| Convert to the specified alphabet (undefined behaviour if holds_alternative() would be false).
Conversion (by type)
template<typename alternative_t> requires (is_alternative<alternative_t>())
constexpr bool | holds_alternative () const noexcept
| Whether the variant alphabet currently holds a value of the given alternative.
template<typename alternative_t> requires (is_alternative<alternative_t>())
constexpr alternative_t | convert_to () const
| Convert to the specified alphabet (throws if holds_alternative() would be false).
template<typename alternative_t> requires (is_alternative<alternative_t>())
constexpr alternative_t | convert_unsafely_to () const noexcept
| Convert to the specified alphabet (undefined behaviour if holds_alternative() would be false).
Public Member Functions inherited from seqan3::alphabet_base< alphabet_variant< alternative_types... >,(static_cast< size_t >(alphabet_size< alternative_types >)+...), char >
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 alphabet_variant< alternative_types... > & | assign_char (char_type const chr) noexcept
| Assign from a character, implicitly converts invalid characters.
constexpr alphabet_variant< alternative_types... > & | assign_rank (rank_type const c) noexcept
| Assign from a numeric value.

## Static Public Member Functions

static constexpr bool | char_is_valid (char_type const chr) noexcept
| Validate whether a character is valid in the combined alphabet.
template<typename alternative_t>
static constexpr bool | is_alternative () noexcept
| Returns true if alternative_t is one of the given alternative types.

## 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< alphabet_variant< alternative_types... >,(static_cast< size_t >(alphabet_size< alternative_types >)+...), char >
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 alternatives)
Defines comparison against types that are not subject to implicit construction/conversion but are comparable against alternatives, e.g. alphabet_variant<seqan3::rna4, seqan3::gap> vs alphabet_variant<seqan3::dna4, seqan3::gap>. Only (in-)equality comparison is defined as reasoning about order of variants is inherently difficult.
template<typename alphabet_variant_t, typename indirect_alternative_type> requires (!detail::is_span<alphabet_variant_t>::value) && (detail::variant_comparison_guard<alphabet_variant_t, indirect_alternative_type, false, alternative_types...>)
constexpr bool | operator== (alphabet_variant_t const lhs, indirect_alternative_type const rhs) noexcept
| (In-)Equality comparison against types comparable with alternatives but not convertible to the variant.
template<typename alphabet_variant_t, typename indirect_alternative_type> requires (!detail::is_span<alphabet_variant_t>::value) && (detail::variant_comparison_guard<alphabet_variant_t, indirect_alternative_type, false, alternative_types...>)
constexpr bool | operator!= (alphabet_variant_t const lhs, indirect_alternative_type const rhs) noexcept
| (In-)Equality comparison against types comparable with alternatives but not convertible to the variant.
template<typename alphabet_variant_t, typename indirect_alternative_type, typename = void> requires (!detail::is_span<alphabet_variant_t>::value) && (detail::variant_comparison_guard<alphabet_variant_t, indirect_alternative_type, true, alternative_types...>)
constexpr bool | operator== (indirect_alternative_type const lhs, alphabet_variant_t const rhs) noexcept
| (In-)Equality comparison against types comparable with alternatives but not convertible to the variant.
template<typename alphabet_variant_t, typename indirect_alternative_type, typename = void> requires (!detail::is_span<alphabet_variant_t>::value) && (detail::variant_comparison_guard<alphabet_variant_t, indirect_alternative_type, true, alternative_types...>)
constexpr bool | operator!= (indirect_alternative_type const lhs, alphabet_variant_t const rhs) noexcept
| (In-)Equality comparison against types comparable with alternatives but not convertible to the variant.
Friends inherited from seqan3::alphabet_base< alphabet_variant< alternative_types... >,(static_cast< size_t >(alphabet_size< alternative_types >)+...), char >

## Additional Inherited Members

Protected Types inherited from seqan3::alphabet_base< alphabet_variant< alternative_types... >,(static_cast< size_t >(alphabet_size< alternative_types >)+...), char >
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... alternative_types>
requires (detail::writable_constexpr_alphabet<alternative_types> && ...) && (std::regular<alternative_types> && ...) && (sizeof...(alternative_types) >= 2)
class seqan3::alphabet_variant< alternative_types >

A combined alphabet that can hold values of either of its alternatives.

.

Template Parameters

  ...alternative_types | Types of possible values (at least 2); all must model seqan3::writable_alphabet, std::regular and must be unique; all required functions for seqan3::writable_alphabet need to be callable in a constexpr-context.

The alphabet_variant represents the union of two or more alternative alphabets (e.g. the four letter DNA alternative + the gap alternative). It behaves similar to a variant or std::variant, but it preserves the seqan3::alphabet.

Short description:

- combines multiple different alphabets in an "either-or"-fashion;
- is itself a seqan3::alphabet;
- its alphabet size is the sum of the individual sizes;
- default initialises to the the first alternative's default (no empty state like std::variant);
- constructible, assignable and (in-)equality-comparable with each alternative type and also all types that these are constructible/assignable/equality-comparable with;
- only convertible to its alternatives through the member function convert_to() (which can throw!)

### Example

// 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/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
int main()
{
using namespace seqan3::literals;
seqan3::alphabet_variant<seqan3::dna5, seqan3::gap> letter{}; // implicitly 'A'_dna5
seqan3::alphabet_variant<seqan3::dna5, seqan3::gap> letter2{'C'_dna5}; // constructed from alternative (== 'C'_dna5)
seqan3::alphabet_variant<seqan3::dna5, seqan3::gap> letter3{
'U'_rna5}; // constructed from type that alternative is constructible from (== 'T'_dna5)
letter2.assign_char('T'); // == 'T'_dna5
letter2.assign_char('-'); // == gap{}
letter2.assign_char('K'); // unknown characters map to the default/unknown
// character of the first alternative type (== 'N'_dna5)
letter2 = seqan3::gap{}; // assigned from alternative (== gap{})
letter2 = 'U'_rna5; // assigned from type that alternative is assignable from (== 'T'_dna5)
seqan3::dna5 letter4 = letter2.convert_to<seqan3::dna5>();
}
all.hpp
Meta-header for the Alphabet / Nucleotide submodule .
alphabet_variant.hpp
Provides seqan3::alphabet_variant.
seqan3::alphabet_base::assign_char
constexpr derived_type & assign_char(char_type const chr) noexcept
Assign from a character, implicitly converts invalid characters.
Definition alphabet_base.hpp:160
seqan3::alphabet_variant
A combined alphabet that can hold values of either of its alternatives..
Definition alphabet_variant.hpp:127
seqan3::alphabet_variant::convert_to
constexpr auto convert_to() const
Convert to the specified alphabet (throws if holds_alternative() would be false).
Definition alphabet_variant.hpp:330
seqan3::dna5
The five letter DNA alphabet of A,C,G,T and the unknown character N.
Definition dna5.hpp:48
seqan3::gap
The alphabet of a gap character '-'.
Definition gap.hpp:36
gap.hpp
Provides seqan3::gap.
seqan3::literals
The SeqAn namespace for literals.

### The char representation of an alphabet_variant

Part of the seqan3::alphabet concept requires that the alphabet_variant provides a char representation in addition to the rank representation. For an object of seqan3::alphabet_variant, the to_char() member function will always return the same character as if invoked on the respective alternative. In contrast, the assign_char() member function might be ambiguous between the alternative alphabets in a variant.

For example, assigning a '!' to seqan3::dna15 resolves to an object of rank 8 with char representation 'N' while assigning '!' to seqan3::gap always resolves to rank 0, the gap symbol itself ('-'_gap). We tackle this ambiguousness by defaulting unknown characters to the representation of the first alternative (e.g. alphabet_variant<dna15, gap>{}.assign_char('!') resolves to rank 8, representing N_dna15).

On the other hand, two alternative alphabets might have the same char representation (e.g if you combine dna4 with dna5, 'A', 'C', 'G' and 'T' are ambiguous). We tackle this ambiguousness by always choosing the first valid char representation (e.g. alphabet_variant<dna4, dna5>{}.assign_char('A') resolves to rank 0, representing an A_dna4).

To explicitly assign via the character representation of a specific alphabet, assign to that type first and then assign to the variant, e.g.

// 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/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
int main()
{
using namespace seqan3::literals;
seqan3::alphabet_variant<seqan3::dna4, seqan3::dna5> var;
var.assign_char('A'); // will be in the "dna4-state"
var = 'A'_dna5; // will be in the "dna5-state"
}

This entity is stable. Since version 3.1.

## Constructor & Destructor Documentation

## alphabet_variant() [1/3]

template<typename... alternative_types>
template<typename alternative_t>
requires (!std::same_as<alternative_t, alphabet_variant>) && (!detail::is_span<alternative_t>::value) && (!std::is_base_of_v<alphabet_variant, alternative_t>) && (!list_traits::contains< alphabet_variant, detail::transformation_trait_or_t<detail::recursive_required_types<alternative_t>, type_list<>>>) && (is_alternative<alternative_t>())

seqan3::alphabet_variant< alternative_types >::alphabet_variant | ( | alternative_t const | alternative | ) |

inline constexpr noexcept

Construction via the value of an alternative.

Template Parameters

  alternative_t | One of the alternative types.

Parameters

  alternative | The value of a alternative that should be assigned.

// 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/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
int main()
{
using namespace seqan3::literals;
seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter1{'C'_dna4}; // or
seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter2 = seqan3::gap{};
}

This entity is stable. Since version 3.1.

## alphabet_variant() [2/3]

template<typename... alternative_types>
template<typename indirect_alternative_t>
requires (!detail::is_span<indirect_alternative_t>::value) && (( detail::instantiate_if_v<detail::lazy<std::is_convertible, indirect_alternative_t, alternative_types>, detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...))

seqan3::alphabet_variant< alternative_types >::alphabet_variant | ( | indirect_alternative_t const | rhs | ) |

inline constexpr noexcept

Constructor for arguments implicitly convertible to an alternative.

Template Parameters

  indirect_alternative_t | A type that is implicitly convertible to an alternative type.

Parameters

  rhs | The value that should be assigned.

This constructor is preferred over the explicit version.

### Example

// 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/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
int main()
{
using namespace seqan3::literals;
seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter1{'C'_rna4};
seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter2 = 'C'_rna4;
}

- seqan3::dna4 and seqan3::rna4 are implicitly convertible to each other so the variant accepts either.
- Construction via {} considers implicit and explicit conversions.
- Construction via = considers only implicit conversions (but that is sufficient here).

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

## alphabet_variant() [3/3]

template<typename... alternative_types>
template<typename indirect_alternative_t>
requires ( (!(detail::instantiate_if_v<detail::lazy<std::is_convertible, indirect_alternative_t, alternative_types>, detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...)) && (detail::instantiate_if_v<detail::lazy<std::is_constructible, alternative_types, indirect_alternative_t>, detail::variant_general_guard<indirect_alternative_t, alternative_types...>> || ...))

seqan3::alphabet_variant< alternative_types >::alphabet_variant | ( | indirect_alternative_t const | rhs | ) |

inline explicit constexpr noexcept

Constructor for arguments explicitly (but not implicitly) convertible to an alternative.

Template Parameters

  indirect_alternative_t | A type that is explicitly (but not implicitly) convertible to an alternative type.

Parameters

  rhs | The value that should be assigned.

### Example

// 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/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
int main()
{
using namespace seqan3::literals;
// possible:
seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter1{'C'_dna5};
// not possible:
// seqan3::alphabet_variant<seqan3::dna4, seqan3::gap> letter2 = 'C'_dna5;
}

- seqan3::dna4 and seqan3::dna5 are not implicitly convertible to each other, only explicitly.
- Construction via {} considers implicit and explicit conversions so this works.
- Construction via = considers only implicit conversions so it does not work.

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

## Member Function Documentation

## assign_rank()

template<typename... alternative_types>

alphabet_variant< alternative_types... > & seqan3::alphabet_base< alphabet_variant< alternative_types... >, size, char >::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.

## char_is_valid()

template<typename... alternative_types>

constexpr bool seqan3::alphabet_variant< alternative_types >::char_is_valid | ( | char_type const | chr | ) |

inline static constexpr noexcept

Validate whether a character is valid in the combined alphabet.

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

## convert_to() [1/2]

template<typename... alternative_types>
template<typename alternative_t>
requires (is_alternative<alternative_t>())

alternative_t seqan3::alphabet_variant< alternative_types >::convert_to | ( |  | ) | const

inline constexpr

Convert to the specified alphabet (throws if holds_alternative() would be false).

Template Parameters

  alternative_t | The type of the alternative that you wish to check for.

Exceptions

  std::bad_variant_access | If the variant_alphabet currently holds the value of a different alternative.

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

## convert_to() [2/2]

template<typename... alternative_types>
template<size_t index>

auto seqan3::alphabet_variant< alternative_types >::convert_to | ( |  | ) | const

inline constexpr

Convert to the specified alphabet (throws if holds_alternative() would be false).

Template Parameters

  index | Index of the alternative to check for.

Exceptions

  std::bad_variant_access | If the variant_alphabet currently holds the value of a different alternative.

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

## convert_unsafely_to() [1/2]

template<typename... alternative_types>
template<typename alternative_t>
requires (is_alternative<alternative_t>())

alternative_t seqan3::alphabet_variant< alternative_types >::convert_unsafely_to | ( |  | ) | const

inline constexpr noexcept

Convert to the specified alphabet (undefined behaviour if holds_alternative() would be false).

Template Parameters

  alternative_t | The type of the alternative that you wish to check for.

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

## convert_unsafely_to() [2/2]

template<typename... alternative_types>
template<size_t index>

auto seqan3::alphabet_variant< alternative_types >::convert_unsafely_to | ( |  | ) | const

inline constexpr noexcept

Convert to the specified alphabet (undefined behaviour if holds_alternative() would be false).

Template Parameters

  index | Index of the alternative to check for.

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

## holds_alternative() [1/2]

template<typename... alternative_types>
template<typename alternative_t>
requires (is_alternative<alternative_t>())

bool seqan3::alphabet_variant< alternative_types >::holds_alternative | ( |  | ) | const

inline constexpr noexcept

Whether the variant alphabet currently holds a value of the given alternative.

Template Parameters

  alternative_t | The type of the alternative that you wish to check for.

This entity is stable. Since version 3.1.

## holds_alternative() [2/2]

template<typename... alternative_types>
template<size_t index>

bool seqan3::alphabet_variant< alternative_types >::holds_alternative | ( |  | ) | const

inline constexpr noexcept

Whether the variant alphabet currently holds a value of the given alternative.

Template Parameters

  index | Index of the alternative to check for.

See also
  std::variant::holds_alternative

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

## is_alternative()

template<typename... alternative_types>
template<typename alternative_t>

constexpr bool seqan3::alphabet_variant< alternative_types >::is_alternative | ( |  | ) |

inline static constexpr noexcept

Returns true if alternative_t is one of the given alternative types.

Template Parameters

  alternative_t | The type to check.

// 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 <gtest/gtest.h>
#include <seqan3/alphabet/composite/alphabet_variant.hpp>
#include <seqan3/alphabet/gap/gap.hpp>
#include <seqan3/alphabet/nucleotide/all.hpp>
int main()
{
using variant_t = seqan3::alphabet_variant<seqan3::dna5, seqan3::gap>;
static_assert(variant_t::is_alternative<seqan3::dna5>(), "dna5 is an alternative of variant_t");
static_assert(!variant_t::is_alternative<seqan3::dna4>(), "dna4 is not an alternative of variant_t");
static_assert(variant_t::is_alternative<seqan3::gap>(), "gap is an alternative of variant_t");
}

This entity is stable. Since version 3.1.

## operator=()

template<typename... alternative_types>
template<typename indirect_alternative_t>
requires (detail::variant_general_guard<indirect_alternative_t, alternative_types...> && (weakly_assignable_from<alternative_types, indirect_alternative_t> || ...))

alphabet_variant & seqan3::alphabet_variant< alternative_types >::operator= | ( | indirect_alternative_t const & | rhs | ) |

inline constexpr noexcept

Assignment for arguments assignable to an alternative.

Template Parameters

  indirect_alternative_t | A type that one of the alternatives is assignable from.

Parameters

  rhs | The value of an alternative.

Most assignments happen through implicit conversion and the default assignment operator. This assignment operator is for the rest.

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

## to_char()

template<typename... alternative_types>

char_type seqan3::alphabet_base< alphabet_variant< alternative_types... >, size, char >::to_char | ( |  | ) | const

inline constexpr noexcept

Return the letter as a character of char_type.

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

### Complexity

Constant.

### Exceptions

Guaranteed not to throw.

This entity is stable. Since version 3.1.

## to_rank()

template<typename... alternative_types>

rank_type seqan3::alphabet_base< alphabet_variant< alternative_types... >, size, char >::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

## operator!= [1/2]

template<typename... alternative_types>
template<typename alphabet_variant_t, typename indirect_alternative_type>
requires (!detail::is_span<alphabet_variant_t>::value) && (detail::variant_comparison_guard<alphabet_variant_t, indirect_alternative_type, false, alternative_types...>)

bool operator!= | ( | alphabet_variant_t const | lhs,
|  | indirect_alternative_type const | rhs )

friend

(In-)Equality comparison against types comparable with alternatives but not convertible to the variant.

Template Parameters

  alphabet_variant_t | The type of the variant; given as template parameter to prevent conversion.
  indirect_alternative_type | Must be comparable with an alternative's type.

Parameters

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

Returns
  true or false.

To determine (in-)equality, it is first deduced which alternative the argument is comparable with. It is then checked if the variant currently is in that alternative's state and if yes whether the values compare to true; else false is returned.

This entity is stable. Since version 3.1.

## operator!= [2/2]

template<typename... alternative_types>
template<typename alphabet_variant_t, typename indirect_alternative_type, typename = void>
requires (!detail::is_span<alphabet_variant_t>::value) && (detail::variant_comparison_guard<alphabet_variant_t, indirect_alternative_type, true, alternative_types...>)

bool operator!= | ( | indirect_alternative_type const | lhs,
|  | alphabet_variant_t const | rhs )

friend

(In-)Equality comparison against types comparable with alternatives but not convertible to the variant.

Template Parameters

  alphabet_variant_t | The type of the variant; given as template parameter to prevent conversion.
  indirect_alternative_type | Must be comparable with an alternative's type.

Parameters

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

Returns
  true or false.

To determine (in-)equality, it is first deduced which alternative the argument is comparable with. It is then checked if the variant currently is in that alternative's state and if yes whether the values compare to true; else false is returned.

This entity is stable. Since version 3.1.

## operator== [1/2]

template<typename... alternative_types>
template<typename alphabet_variant_t, typename indirect_alternative_type>
requires (!detail::is_span<alphabet_variant_t>::value) && (detail::variant_comparison_guard<alphabet_variant_t, indirect_alternative_type, false, alternative_types...>)

bool operator== | ( | alphabet_variant_t const | lhs,
|  | indirect_alternative_type const | rhs )

friend

(In-)Equality comparison against types comparable with alternatives but not convertible to the variant.

Template Parameters

  alphabet_variant_t | The type of the variant; given as template parameter to prevent conversion.
  indirect_alternative_type | Must be comparable with an alternative's type.

Parameters

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

Returns
  true or false.

To determine (in-)equality, it is first deduced which alternative the argument is comparable with. It is then checked if the variant currently is in that alternative's state and if yes whether the values compare to true; else false is returned.

This entity is stable. Since version 3.1.

## operator== [2/2]

template<typename... alternative_types>
template<typename alphabet_variant_t, typename indirect_alternative_type, typename = void>
requires (!detail::is_span<alphabet_variant_t>::value) && (detail::variant_comparison_guard<alphabet_variant_t, indirect_alternative_type, true, alternative_types...>)

bool operator== | ( | indirect_alternative_type const | lhs,
|  | alphabet_variant_t const | rhs )

friend

(In-)Equality comparison against types comparable with alternatives but not convertible to the variant.

Template Parameters

  alphabet_variant_t | The type of the variant; given as template parameter to prevent conversion.
  indirect_alternative_type | Must be comparable with an alternative's type.

Parameters

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

Returns
  true or false.

To determine (in-)equality, it is first deduced which alternative the argument is comparable with. It is then checked if the variant currently is in that alternative's state and if yes whether the values compare to true; else false is returned.

This entity is stable. Since version 3.1.

## Member Data Documentation

## alphabet_size

template<typename... alternative_types>

detail::min_viable_uint_t<size> seqan3::alphabet_base< alphabet_variant< alternative_types... >, size, char >::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_variant.hpp

Hide me