SeqAn3  3.0.2
The Modern C++ library for sequence analysis.
seqan3::semialphabet_any< size > Class Template Reference

A semi-alphabet that type erases all other semi-alphabets of the same size. More...

#include <seqan3/alphabet/composite/semialphabet_any.hpp>

+ Inheritance diagram for seqan3::semialphabet_any< size >:

Public Member Functions

template<semialphabet other_alph_t>
 operator other_alph_t () const
 Enable conversion of semialphabet_any into other (semi-)alphabet of the same size.
 
Constructors, destructor and assignment
constexpr semialphabet_any () noexcept=default
 Defaulted.
 
constexpr semialphabet_any (semialphabet_any const &) noexcept=default
 Defaulted.
 
constexpr semialphabet_any (semialphabet_any &&) noexcept=default
 Defaulted.
 
constexpr semialphabet_anyoperator= (semialphabet_any const &) noexcept=default
 Defaulted.
 
constexpr semialphabet_anyoperator= (semialphabet_any &&) noexcept=default
 Defaulted.
 
 ~semialphabet_any () noexcept=default
 Defaulted.
 
template<semialphabet other_alph_t>
 semialphabet_any (other_alph_t const other)
 Construct semialphabet_any from alphabet of the same size.
 
Read functions
constexpr char_type to_char () const noexcept
 Return the letter as a character of char_type. More...
 
constexpr rank_type to_rank () const noexcept
 Return the letter's numeric value (rank in the alphabet). More...
 
Write functions
constexpr semialphabet_any< size > & assign_char (char_type const c) noexcept
 Assign from a character, implicitly converts invalid characters. More...
 
constexpr semialphabet_any< size > & assign_rank (rank_type const c) noexcept
 Assign from a numeric value. More...
 

Static Public Attributes

static detail::min_viable_uint_t< size > constexpr 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 = detail::min_viable_uint_t< size - 1 >
 The type of the alphabet when represented as a number (e.g. via to_rank()).
 

Related Functions

(Note that these are not member functions.)

Requirements for std::totally_ordered

You can expect these functions on all types that implement std::totally_ordered.

bool operator< (type const &lhs, type const &rhs)
 Less-than, greater-than and -or-equal comparisons. More...
 
bool operator<= (type const &lhs, type const &rhs)
 Less-than, greater-than and -or-equal comparisons. More...
 
bool operator> (type const &lhs, type const &rhs)
 Less-than, greater-than and -or-equal comparisons. More...
 
bool operator>= (type const &lhs, type const &rhs)
 Less-than, greater-than and -or-equal comparisons. More...
 
Requirements for std::equality_comparable

You can expect these functions on all types that implement std::Equality_comparable.

bool operator== (type const &lhs, type const &rhs)
 (In-)Equality comparison. More...
 
bool operator!= (type const &lhs, type const &rhs)
 (In-)Equality comparison. More...
 
Requirements for std::swappable

You can expect these functions on all types that implement std::swappable.

void swap (t &lhs, t &rhs)
 Swaps the contents of two objects. More...
 

Detailed Description

template<size_t size>
class seqan3::semialphabet_any< size >

A semi-alphabet that type erases all other semi-alphabets of the same size.

This alphabet provides a generic representation for different alphabets of the same size by erasing the type of the alphabet it is constructed from. This enables the usage of a single type although assigning different alphabets. The semialphabet_any can also be converted to any other (semi-)alphabet of the same size. It is therefore possible to convert the semialphabet_any into an alphabet type that is not the original alphabet type. However, this should either be avoided or used with care as no warnings are given when attempting to convert the semialphabet_any into a type that is not comparable to the original alphabet type. The main advantage of using this data structure is to reduce instantiation of templates when using multiple alphabets of the same size and either their character representation is not important or they are reified at a later point in the program.

See also
https://en.wikipedia.org/wiki/Type_erasure
https://en.wikipedia.org/wiki/Reification_(computer_science)

Example

// This example illustrates how we can reduce the usage of templates (or the amount of different instantiations) via
// type erasure. Having only one function generated for `algorithm()` is the only benefit of using `semialphabet_any`
// here. Of course this only makes sense for your application if the part of the program that is agnostic of the
// character representation (your equivalent of `algorithm()`) is substantially larger than the specific parts – and
// if compile-time and/or size of the exectuble are a concern.
#include <iostream>
using seqan3::operator""_aa10murphy;
using seqan3::operator""_aa10li;
// Print is a template and gets instantiated two times because the behaviour is different for both types
template <typename rng_t>
void print(rng_t && r)
{
seqan3::debug_stream << r << '\n';
}
// Algorithm is not a template, only one instance is generated by the compiler
// Type information is encoded via a run-time parameter
void algorithm(std::vector<seqan3::semialphabet_any<10> > & r, bool is_murphy)
{
// Algorithm example that replaces rank 0 with rank 1
for (auto & v : r)
if (seqan3::to_rank(v) == 0)
// Here we reify the type for printing
if (is_murphy)
print(r | seqan3::views::convert<seqan3::aa10murphy>);
else
print(r | seqan3::views::convert<seqan3::aa10li>);
}
// Two instances of algo_pre exist
// They type erase the different arguments to the same type and encode the type information as a run-time parameter
void algo_pre(seqan3::aa10li_vector const & v)
{
std::vector<seqan3::semialphabet_any<10> > tmp = v | seqan3::views::convert<seqan3::semialphabet_any<10>>
| seqan3::views::to<std::vector>;
algorithm(tmp, false);
}
void algo_pre(seqan3::aa10murphy_vector const & v)
{
std::vector<seqan3::semialphabet_any<10> > tmp = v | seqan3::views::convert<seqan3::semialphabet_any<10>>
| seqan3::views::to<std::vector>;
algorithm(tmp, true);
}
int main()
{
seqan3::aa10li_vector v1{"AVRSTXOUB"_aa10li};
algo_pre(v1); // BIKBBBKCB
seqan3::aa10murphy_vector v2{"AVRSTXOUB"_aa10murphy};
algo_pre(v2); // BIKSSSKCB
}

Member Function Documentation

◆ assign_char()

constexpr semialphabet_any< size > & seqan3::alphabet_base< semialphabet_any< size > , size, void >::assign_char ( char_type const  c)
inlinenoexceptinherited

Assign from a character, implicitly converts invalid characters.

Parameters
cThe character to be assigned.

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

Complexity

Constant.

Exceptions

Guaranteed not to throw.

◆ assign_rank()

constexpr semialphabet_any< size > & seqan3::alphabet_base< semialphabet_any< size > , size, void >::assign_rank ( rank_type const  c)
inlinenoexceptinherited

Assign from a numeric value.

Parameters
cThe rank to be assigned.

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

Complexity

Constant.

Exceptions

Guaranteed not to throw.

◆ to_char()

constexpr char_type seqan3::alphabet_base< semialphabet_any< size > , size, void >::to_char ( ) const
inlinenoexceptinherited

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.

◆ to_rank()

constexpr rank_type seqan3::alphabet_base< semialphabet_any< size > , size, void >::to_rank ( ) const
inlinenoexceptinherited

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.


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