seqan3::qualified< sequence_alphabet_t, quality_alphabet_t > Class Template Reference

Joins an arbitrary alphabet with a quality alphabet. More...

#include <seqan3/alphabet/quality/qualified.hpp>

Inheritance diagram for seqan3::qualified< sequence_alphabet_t, quality_alphabet_t >:

Public Types
using	char_type = alphabet_char_t< sequence_alphabet_type >
	Equals the char_type of sequence_alphabet_type.
using	phred_type = alphabet_phred_t< quality_alphabet_type >
	Equals the phred_type of the quality_alphabet_type.
using	quality_alphabet_type = quality_alphabet_t
	Second template parameter as member type.
using	sequence_alphabet_type = sequence_alphabet_t
	First template parameter as member type.

Public Member Functions
Constructors, destructor and assignment
constexpr	qualified () noexcept=default
	Defaulted.
constexpr	qualified (qualified const &) noexcept=default
	Defaulted.
constexpr	qualified (qualified &&) noexcept=default
	Defaulted.
constexpr qualified &	operator= (qualified const &) noexcept=default
	Defaulted.
constexpr qualified &	operator= (qualified &&) noexcept=default
	Defaulted.
	~qualified () noexcept=default
	Defaulted.
constexpr	qualified (component_type const alph) noexcept
	Construction via a value of one of the components. More...
constexpr	qualified (indirect_component_type const alph) noexcept
	Construction via a value of a subtype that is assignable to one of the components. More...
constexpr qualified &	operator= (component_type const alph) noexcept
	Assignment via a value of one of the components. More...
constexpr qualified &	operator= (indirect_component_type const alph) noexcept
	Assignment via a value of a subtype that is assignable to one of the components. More...
Write functions
constexpr qualified &	assign_char (char_type const c) noexcept
	Assign from a character. This modifies the internal sequence letter.
constexpr qualified &	assign_phred (phred_type const c) noexcept
	Assign from a Phred score value. This modifies the internal quality letter.
Read functions
constexpr phred_type	to_phred () const noexcept
	Return the Phred score value. This reads the internal quality letter.
constexpr char_type	to_char () const noexcept
	Return a character. This reads the internal sequence letter.
constexpr qualified	complement () const noexcept requires nucleotide_alphabet< sequence_alphabet_t >
	Return a qualified where the quality is preserved, but the sequence letter is complemented. More...
Public Member Functions inherited from seqan3::alphabet_tuple_base< qualified< sequence_alphabet_t, quality_alphabet_t >, sequence_alphabet_t, quality_alphabet_t >
constexpr	alphabet_tuple_base (component_types ... components) noexcept
	Construction from initialiser-list.
constexpr	alphabet_tuple_base (component_type const alph) noexcept
	Construction via a value of one of the components. More...
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. More...
constexpr qualified< sequence_alphabet_t, quality_alphabet_t > &	operator= (component_type const alph) noexcept
	Assignment via a value of one of the components. More...
constexpr qualified< sequence_alphabet_t, quality_alphabet_t > &	operator= (indirect_component_type const alph) noexcept
	Assignment via a value of a subtype that is assignable to one of the components. More...
constexpr	operator type () const noexcept
	Implicit cast to a single letter. Works only if the type is unique in the type list. More...
Public Member Functions inherited from seqan3::alphabet_base< qualified< sequence_alphabet_t, quality_alphabet_t >,(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. More...
constexpr rank_type	to_rank () const noexcept
	Return the letter's numeric value (rank in the alphabet). More...
constexpr qualified< sequence_alphabet_t, quality_alphabet_t > &	assign_char (char_type const c) noexcept
	Assign from a character, implicitly converts invalid characters. More...
constexpr qualified< sequence_alphabet_t, quality_alphabet_t > &	assign_rank (rank_type const c) noexcept
	Assign from a numeric value. More...

Static Public Member Functions
static constexpr bool	char_is_valid (char_type const c) noexcept
	Validate whether a character is valid in the sequence alphabet.

Private Types
using	base_type = alphabet_tuple_base< qualified< sequence_alphabet_t, quality_alphabet_t >, sequence_alphabet_t, quality_alphabet_t >
	The base type.

Static Private Attributes
static constexpr std::array< char_type, alphabet_size >	rank_to_char
	Rank to char conversion table. More...
static constexpr std::array< char_type, alphabet_size >	rank_to_phred
	Rank to Phred conversion table. More...

Related Functions
(Note that these are not member functions.)
template<typename sequence_alphabet_type , typename quality_alphabet_type >
	qualified (sequence_alphabet_type &&, quality_alphabet_type &&) -> qualified< std::decay_t< sequence_alphabet_type >, std::decay_t< quality_alphabet_type >>
	Type deduction guide enables usage of qualified without specifying template args.
Related Functions inherited from semialphabet
template<cereal_output_archive archive_t, semialphabet alphabet_t>
alphabet_rank_t< alphabet_t >	save_minimal (archive_t const &, alphabet_t const &l)
	Save an alphabet letter to stream. More...

Additional Inherited Members
Static Public Attributes inherited from seqan3::alphabet_base< qualified< sequence_alphabet_t, quality_alphabet_t >,(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. More...
Protected Types inherited from seqan3::alphabet_base< qualified< sequence_alphabet_t, quality_alphabet_t >,(1 *... *alphabet_size< component_types >), void >
using	char_type = std::conditional_t< std::same_as< void, void >, char, void >
	The char representation; conditional needed to make semi alphabet definitions legal. More...
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()). More...

Detailed Description

template<writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>
class seqan3::qualified< sequence_alphabet_t, quality_alphabet_t >

Joins an arbitrary alphabet with a quality alphabet.

Template Parameters

sequence_alphabet_t	Type of the alphabet; must satisfy seqan3::writable_alphabet.
quality_alphabet_t	Type of the quality; must satisfy seqan3::writable_quality_alphabet.

This composite pairs an arbitrary alphabet with a quality alphabet, where each alphabet character is stored together with its quality score in a single value. That way, you can can conveniently access the character and score information at each position of the qualified-sequence. The use case that this was designed for is a nucleotide sequence with corresponding quality scores, e.g. obtained when reading in a FASTQ file of Illumina reads. The composite also allows to store quality scores for different or extended alphabets like a qualified<char, phred42> or a qualified<gapped<dna4>, phred42> sequence. The rank values correspond to numeric values in the size of the composite, while the character values are taken from the sequence alphabet and the Phred score values are taken from the quality alphabet.

As with all seqan3::alphabet_tuple_base s you may access the individual alphabet letters in regular c++ tuple notation, i.e. get<0>(t) and objects can be brace-initialised with the individual members.

#include <seqan3/alphabet/quality/qualified.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using seqan3::operator""_dna4;
    using seqan3::get;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter{'A'_dna4, seqan3::phred42{7}};
    seqan3::debug_stream << int(seqan3::to_rank(letter)) << ' '
                         << int(seqan3::to_rank(get<0>(letter))) << ' '
                         << int(seqan3::to_rank(get<1>(letter))) << '\n';
    // 28 0 7
 
    seqan3::debug_stream << seqan3::to_char(letter) << ' '
                         << seqan3::to_char(get<0>(letter)) << ' '
                         << seqan3::to_char(get<1>(letter)) << '\n';
    // A A (
 
    seqan3::debug_stream << seqan3::to_phred(letter) << ' '
                         << seqan3::to_phred(get<1>(letter)) << '\n';
    // 7 7
 
    // modify via structured bindings and references:
    auto & [ seq_l, qual_l ] = letter;
    seq_l = 'G'_dna4;
    seqan3::debug_stream << seqan3::to_char(letter) << '\n';
    // G
}

This seqan3::alphabet_tuple_base itself fulfils both seqan3::writable_alphabet and seqan3::writable_quality_alphabet.

Constructor & Destructor Documentation

qualified() [1/2]

template<writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>

constexpr seqan3::qualified< sequence_alphabet_t, quality_alphabet_t >::qualified ( component_type const  alph )

inlineconstexprnoexcept

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

#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 seqan3::operator""_dna4;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'C'_dna4};
    // creates {'C'_dna4, seqan3::phred42{0}}
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter2{seqan3::phred42{1}};
    // creates {'A'_dna4, seqan3::phred42{1}}
 
    if (letter1 == letter2)
        seqan3::debug_stream << "yeah\n"; // yeah
}

This entity is stable. Since version 3.1.

qualified() [2/2]

template<writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>

constexpr seqan3::qualified< sequence_alphabet_t, quality_alphabet_t >::qualified ( indirect_component_type const  alph )

inlineconstexprnoexcept

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

#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 seqan3::operator""_dna4;
    using seqan3::operator""_rna4;
 
    // The following creates {'C'_dna4, phred42{0}}
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'C'_dna4};
    // The following also creates {'C'_dna4, seqan3::phred42{0}}, since rna4 assignable to dna4
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter2{'C'_rna4};
 
    if (letter1 == letter2)
        seqan3::debug_stream << "yeah\n"; // yeah
}

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

Member Function Documentation

complement()

template<writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>

constexpr qualified seqan3::qualified< sequence_alphabet_t, quality_alphabet_t >::complement ( ) const

inlineconstexprnoexcept

Return a qualified where the quality is preserved, but the sequence letter is complemented.

See also

seqan3::complement

seqan3::nucleotide_alphabet::complement

operator=() [1/2]

template<writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>

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

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

This entity is stable. Since version 3.1.

operator=() [2/2]

template<writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>

constexpr qualified& seqan3::qualified< sequence_alphabet_t, quality_alphabet_t >::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 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).

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

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

Member Data Documentation

rank_to_char

template<writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>

constexpr std::array<char_type, alphabet_size> seqan3::qualified< sequence_alphabet_t, quality_alphabet_t >::rank_to_char

staticconstexprprivate

Initial value:

{
        [] () constexpr
        {
            std::array<char_type, alphabet_size> ret{};
 
            for (size_t i = 0; i < alphabet_size; ++i)
            {
                size_t seq_rank = (i / base_type::cummulative_alph_sizes[0]) %
                                  seqan3::alphabet_size<quality_alphabet_type>;
 
                ret[i] = seqan3::to_char(seqan3::assign_rank_to(seq_rank, sequence_alphabet_type{}));
            }
 
            return ret;
        }()
    }

Rank to char conversion table.

rank_to_phred

template<writable_alphabet sequence_alphabet_t, writable_quality_alphabet quality_alphabet_t>

constexpr std::array<char_type, alphabet_size> seqan3::qualified< sequence_alphabet_t, quality_alphabet_t >::rank_to_phred

staticconstexprprivate

Initial value:

{
        [] () constexpr
        {
            std::array<char_type, alphabet_size> ret{};
 
            for (size_t i = 0; i < alphabet_size; ++i)
            {
                size_t qual_rank = (i / base_type::cummulative_alph_sizes[1]) %
                                    seqan3::alphabet_size<quality_alphabet_type>;
 
                ret[i] = seqan3::to_phred(seqan3::assign_rank_to(qual_rank, quality_alphabet_type{}));
            }
 
            return ret;
        }()
    }

Rank to Phred conversion table.

---

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

• seqan3/alphabet/quality/qualified.hpp