seqan3::structured_aa< sequence_alphabet_t, structure_alphabet_t > Class Template Reference

A seqan3::alphabet_tuple_base that joins an aminoacid alphabet with a protein structure alphabet. More...

#include <seqan3/alphabet/structure/structured_aa.hpp>

Inheritance diagram for seqan3::structured_aa< sequence_alphabet_t, structure_alphabet_t >:

Public Types
using	char_type = alphabet_char_t< sequence_alphabet_type >
	Equals the char_type of sequence_alphabet_type.
using	sequence_alphabet_type = sequence_alphabet_t
	First template parameter as member type.
using	structure_alphabet_type = structure_alphabet_t
	Second template parameter as member type.

Public Member Functions
Constructors, destructor and assignment
constexpr	structured_aa () noexcept=default
	Defaulted.
constexpr	structured_aa (structured_aa const &) noexcept=default
	Defaulted.
constexpr	structured_aa (structured_aa &&) noexcept=default
	Defaulted.
constexpr structured_aa &	operator= (structured_aa const &) noexcept=default
	Defaulted.
constexpr structured_aa &	operator= (structured_aa &&) noexcept=default
	Defaulted.
	~structured_aa () noexcept=default
	Defaulted.
template<typename component_type >
constexpr	structured_aa (component_type const alph)
	Construction via a value of one of the components. More...
template<typename indirect_component_type >
constexpr	structured_aa (indirect_component_type const alph)
	Construction via a value of a subtype that is assignable to one of the components. More...
template<typename component_type >
constexpr structured_aa &	operator= (component_type const alph)
	Assignment via a value of one of the components. More...
template<typename indirect_component_type >
constexpr structured_aa &	operator= (indirect_component_type const alph)
	Assignment via a value of a subtype that is assignable to one of the components. More...
template<typename component_type >
constexpr derived_type &	operator= (component_type const alph) noexcept
	Inherit operators from base.
template<typename indirect_component_type >
constexpr derived_type &	operator= (indirect_component_type const alph) noexcept
	Inherit operators from base.
Write functions
constexpr structured_aa &	assign_char (char_type const c) noexcept
	Assign from a nucleotide character. This modifies the internal sequence letter.
Read functions
constexpr char_type	to_char () const noexcept
	Return a character. This reads the internal sequence letter.
Read functions
All read operations are constant complexity.
constexpr	operator type () const noexcept
	Implicit cast to a single letter. Works only if the type is unique in the type list.
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 structured_aa< aa27, dssp9 > &	assign_char (char_type const c) noexcept
	Assign from a character, implicitly converts invalid characters. More...
constexpr structured_aa< aa27, dssp9 > &	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.

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.

Protected Types
Member types
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.)
template<typename sequence_alphabet_type , typename structure_alphabet_type >
	structured_aa (sequence_alphabet_type &&, structure_alphabet_type &&) -> structured_aa< std::decay_t< sequence_alphabet_type >, std::decay_t< structure_alphabet_type >>
	Type deduction guide enables usage of structured_aa without specifying template args.

Detailed Description

template<writable_alphabet sequence_alphabet_t = aa27, writable_alphabet structure_alphabet_t = dssp9>
class seqan3::structured_aa< sequence_alphabet_t, structure_alphabet_t >

A seqan3::alphabet_tuple_base that joins an aminoacid alphabet with a protein structure alphabet.

Template Parameters

sequence_alphabet_t	Type of the first aminoacid letter; must model seqan3::writable_alphabet, seqan3::aminoacid_alphabet and satisfy the requirements on arguments by seqan3::alphabet_tuple_base.
structure_alphabet_t	Types of further structure letters; must model seqan3::writable_alphabet and satisfy the requirements on arguments by seqan3::alphabet_tuple_base.

This composite pairs an aminoacid alphabet with a structure alphabet. The rank values correpsond to numeric values in the size of the composite, while the character values are taken from the sequence alphabet and the structure annotation is taken from the structure 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-initialized with the individual members.

#include <seqan3/alphabet/structure/structured_aa.hpp>
#include <seqan3/alphabet/aminoacid/aa27.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using seqan3::operator""_aa27;
    using seqan3::operator""_dssp9;
    using seqan3::get;
 
    seqan3::structured_aa<seqan3::aa27, seqan3::dssp9> letter{'W'_aa27, 'B'_dssp9};
 
    seqan3::debug_stream << seqan3::to_rank(letter) << ' '
                         << seqan3::to_rank(get<0>(letter)) << ' '
                         << seqan3::to_rank(get<1>(letter)) << '\n';
    // 49 22 1
 
    seqan3::debug_stream << seqan3::to_char(letter) << ' '
                         << seqan3::to_char(get<0>(letter)) << ' '
                         << seqan3::to_char(get<1>(letter)) << '\n';
    // W W B
 
    // modify via structured bindings and references:
    auto & [ seq_l, structure_l ] = letter;
    seq_l = 'V'_aa27;
    seqan3::debug_stream << seqan3::to_char(letter) << '\n';
    // V
}

This seqan3::alphabet_tuple_base itself fulfills seqan3::alphabet.

Constructor & Destructor Documentation

structured_aa() [1/2]

template<writable_alphabet sequence_alphabet_t = aa27, writable_alphabet structure_alphabet_t = dssp9>

template<typename component_type >

constexpr seqan3::structured_aa< sequence_alphabet_t, structure_alphabet_t >::structured_aa ( component_type const  alph )

inlineconstexpr

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
}

structured_aa() [2/2]

template<writable_alphabet sequence_alphabet_t = aa27, writable_alphabet structure_alphabet_t = dssp9>

template<typename indirect_component_type >

constexpr seqan3::structured_aa< sequence_alphabet_t, structure_alphabet_t >::structured_aa ( indirect_component_type const  alph )

inlineconstexpr

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
}

Member Function Documentation

assign_char()

constexpr structured_aa< aa27, dssp9 > & seqan3::alphabet_base< structured_aa< aa27, dssp9 > , 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 seqan3::assign_char_to, required to model seqan3::alphabet.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

assign_rank()

constexpr structured_aa< aa27, dssp9 > & seqan3::alphabet_base< structured_aa< aa27, dssp9 > , 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 seqan3::assign_rank_to, required to model seqan3::semialphabet.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

operator=() [1/2]

template<writable_alphabet sequence_alphabet_t = aa27, writable_alphabet structure_alphabet_t = dssp9>

template<typename component_type >

constexpr structured_aa& seqan3::structured_aa< sequence_alphabet_t, structure_alphabet_t >::operator= ( component_type const  alph )

inlineconstexpr

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}}
}

operator=() [2/2]

template<writable_alphabet sequence_alphabet_t = aa27, writable_alphabet structure_alphabet_t = dssp9>

template<typename indirect_component_type >

constexpr structured_aa& seqan3::structured_aa< sequence_alphabet_t, structure_alphabet_t >::operator= ( indirect_component_type const  alph )

inlineconstexpr

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}}
}

to_char()

constexpr char_type seqan3::alphabet_base< structured_aa< aa27, dssp9 > , size, void >::to_char

inlineconstexprnoexceptinherited

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< structured_aa< aa27, dssp9 > , size, void >::to_rank

inlineconstexprnoexceptinherited

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:

• seqan3/alphabet/structure/structured_aa.hpp