SeqAn3
seqan3::masked< sequence_alphabet_t > Class Template Reference

Implementation of a masked composition, which extends a given alphabet with a mask. More...

#include <seqan3/alphabet/mask/masked.hpp>

Inheritance diagram for seqan3::masked< sequence_alphabet_t >:
[legend]

Public Types

using char_type = underlying_char_t< sequence_alphabet_type >
 Equals the char_type of sequence_alphabet_type.
 
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()).
 
using sequence_alphabet_type = sequence_alphabet_t
 First template parameter as member type.
 

Public Member Functions

Constructors, destructor and assignment
constexpr masked ()
 
constexpr masked (masked const &)=default
 
constexpr masked (masked &&)=default
 
constexpr maskedoperator= (masked const &)=default
 
constexpr maskedoperator= (masked &&)=default
 
 ~masked ()=default
 
constexpr masked (component_type const alph)
 Construction via a value of one of the components. More...
 
constexpr masked (indirect_component_type const alph)
 Construction via a value of a subtype that is assignable to one of the components. More...
 
constexpr maskedoperator= (component_type const alph)
 Assignment via a value of one of the components. More...
 
constexpr maskedoperator= (indirect_component_type const alph)
 Assignment via a value of a subtype that is assignable to one of the components. More...
 
Write functions
constexpr maskedassign_char (char_type const c)
 Assign from a character.
 
Read functions
constexpr char_type to_char () const noexcept
 Return a character.
 
Read functions

All read operations are constant complexity.

constexpr operator type () const
 Implicit cast to a single letter. Works only if the type is unique in the type list.
 
Comparison operators (against indirect component_list)

*this is cast to the component type before comparison. (These overloads enable comparison for all types that a component type is comparable with).

constexpr bool operator== (indirect_component_type const &rhs) const noexcept
 
constexpr bool operator!= (indirect_component_type const &rhs) const noexcept
 
constexpr bool operator< (indirect_component_type const &rhs) const noexcept
 
constexpr bool operator> (indirect_component_type const &rhs) const noexcept
 
constexpr bool operator<= (indirect_component_type const &rhs) const noexcept
 
constexpr bool operator>= (indirect_component_type const &rhs) const noexcept
 
Read functions
constexpr rank_type to_rank () const noexcept
 Return the letter's numeric value (rank in the alphabet). More...
 
Write functions
constexpr derived_type & assign_rank (rank_type const c) noexcept
 Assign from a numeric value. More...
 
constexpr derived_type & assign_char (std::conditional_t< std::Same< char_type, void >, char, char_type > const c) noexcept
 Assign from a character. More...
 

Static Public Attributes

static detail::min_viable_uint_t< size > constexpr value_size = size
 The size of the alphabet, i.e. the number of different values it can take.
 

Related Functions

(Note that these are not member functions.)

template<typename sequence_alphabet_type >
 masked (sequence_alphabet_type &&, mask const &) -> masked< std::decay_t< sequence_alphabet_type >>
 Type deduction guide enables usage of masked without specifying template args. More...
 
Requirements for seqan3::alphabet_concept

You can expect these functions on all types that implement seqan3::alphabet_concept.

template<typename alphabet_type >
using underlying_char_t = typename underlying_char< alphabet_type >::type
 The char_type of the alphabet. [type metafunction shortcut]. More...
 
char_type to_char (alphabet_concept const alph)
 Returns the alphabet letter's value in character representation. More...
 
alphabet_concept && assign_char (alphabet_concept &&alph, char_type const chr)
 Returns the alphabet letter's value in character representation. More...
 
Requirements for seqan3::semi_alphabet_concept

You can expect these functions on all types that implement seqan3::semi_alphabet_concept.

template<typename semi_alphabet_type >
using underlying_rank_t = typename underlying_rank< semi_alphabet_type >::type
 The rank_type of the semi_alphabet. [type metafunction shortcut]. More...
 
template<typename alphabet_type >
constexpr auto alphabet_size_v = alphabet_size<alphabet_type>::value
 The size of the alphabet. [value metafunction shortcut]. More...
 
rank_type to_rank (semi_alphabet_concept const alph)
 Returns the alphabet letter's value in rank representation. More...
 
semi_alphabet_concept && assign_rank (semi_alphabet_concept &&alph, rank_type const rank)
 Returns the alphabet letter's value in rank representation. 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...
 
Requirements for std::EqualityComparable

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::StrictTotallyOrdered

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

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...
 
Comparison operators

Free function (in-)equality comparison operators that forward to member operators (for types != self).

constexpr bool operator== (indirect_component_type const &lhs, cartesian_composition< masked< sequence_alphabet_t >, component_types... > const &rhs)
 
constexpr bool operator!= (indirect_component_type const &lhs, cartesian_composition< masked< sequence_alphabet_t >, indirect_component_types... > const &rhs)
 
constexpr bool operator< (indirect_component_type const &lhs, cartesian_composition< masked< sequence_alphabet_t >, indirect_component_types... > const &rhs)
 
constexpr bool operator> (indirect_component_type const &lhs, cartesian_composition< masked< sequence_alphabet_t >, indirect_component_types... > const &rhs)
 
constexpr bool operator<= (indirect_component_type const &lhs, cartesian_composition< masked< sequence_alphabet_t >, indirect_component_types... > const &rhs)
 
constexpr bool operator>= (indirect_component_type const &lhs, cartesian_composition< masked< sequence_alphabet_t >, indirect_component_types... > const &rhs)
 

Detailed Description

template<typename sequence_alphabet_t>
class seqan3::masked< sequence_alphabet_t >

Implementation of a masked composition, which extends a given alphabet with a mask.

Template Parameters
sequence_alphabet_tType of the first letter; must satisfy seqan3::semi_alphabet_concept.
mask_tTypes of masked letter; must satisfy seqan3::semi_alphabet_concept, defaults to seqan3::mask.

The masked composition represents a seqan3::cartesian_composition of any given alphabet with the masked alphabet. It allows one to specify which portions of a sequence should be masked, without losing additional information by replacing the sequence directly.

masked<dna4> dna4_masked{};
masked<dna4> dna4_another_masked{'A'_dna4, mask::UNMASKED}; // create a dna4 masked alphabet with an unmasked A
dna4_masked.assign_char('a'); // assigns a masked 'A'_dna4
if (dna4_masked.to_char() != dna4_another_masked.to_char())
debug_stream << dna4_masked.to_char() << " is not the same as " << dna4_another_masked.to_char() << "\n";

Constructor & Destructor Documentation

◆ masked() [1/2]

template<typename sequence_alphabet_t >
constexpr seqan3::masked< sequence_alphabet_t >::masked ( component_type const  alph)
inline

Construction via a value of one of the components.

Template Parameters
component_typeMust be one uniquely contained in the type list of the composition.
Parameters
alphThe value of a component that should be assigned.

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

qualified<dna4, phred42> letter1{'C'_dna4}; // creates {'C'_dna4, phred42{0}}
qualified<dna4, phred42> letter2{phred42{1}}; // creates {'A'_dna4, phred42{1}}

◆ masked() [2/2]

template<typename sequence_alphabet_t >
constexpr seqan3::masked< sequence_alphabet_t >::masked ( indirect_component_type const  alph)
inline

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

Template Parameters
indirect_component_typeType that models the seqan3::is_assignable_concept for one of the component types.
Parameters
alphThe value that should be assigned.

Note that the value will be assigned to the FIRST type T that fulfils the assignable_concept<T, indirect_component_type>, regardless if other types are also fit for assignment.

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

// The following creates {'C'_dna4, phre42{0}}
qualified<dna4, phred42> letter1{'C'_dna4};
// The following also creates {'C'_dna4, phred42{0}}, since rna4 assignable to dna4
qualified<dna4, phred42> letter2{'C'_rna4};
if (letter1 == letter2)
debug_stream << "yeah\n"; // yeah

Member Function Documentation

◆ assign_char()

template<typename derived_type, size_t size, typename char_t = char>
constexpr derived_type& seqan3::alphabet_base< derived_type, size, char_t >::assign_char ( std::conditional_t< std::Same< char_type, void >, char, char_type > const  c)
inlinenoexceptinherited

Assign from a character.

Satisfies the seqan3::alphabet_concept::assign_char() requirement via the seqan3::assign_char() wrapper.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

◆ assign_rank()

template<typename derived_type, size_t size, typename char_t = char>
constexpr derived_type& seqan3::alphabet_base< derived_type, size, char_t >::assign_rank ( rank_type const  c)
inlinenoexceptinherited

Assign from a numeric value.

Satisfies the seqan3::semi_alphabet_concept::assign_rank() requirement via the seqan3::assign_rank() wrapper.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

◆ operator=() [1/2]

template<typename sequence_alphabet_t >
constexpr masked& seqan3::masked< sequence_alphabet_t >::operator= ( component_type const  alph)
inline

Assignment via a value of one of the components.

Template Parameters
component_typeOne of the component types. Must be uniquely contained in the type list of the composition.
Parameters
alphThe value of a component that should be assigned.

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

qualified<dna4, phred42> letter1{'T'_dna4, phred42{1}};
letter1 = 'C'_dna4; // yields {'C'_dna4, phred42{1}}
letter1 = phred42{2}; // yields {'C'_dna4, phred42{2}}

◆ operator=() [2/2]

template<typename sequence_alphabet_t >
constexpr masked& seqan3::masked< sequence_alphabet_t >::operator= ( indirect_component_type const  alph)
inline

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

Template Parameters
indirect_component_typeType that models the seqan3::is_assignable_concept for one of the component types.
Parameters
alphThe value of a component that should be assigned.

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

qualified<dna4, phred42> letter1{'T'_dna4, phred42{1}};
letter1 = 'C'_rna4; // yields {'C'_dna4, phred42{1}}

◆ to_rank()

template<typename derived_type, size_t size, typename char_t = char>
constexpr rank_type seqan3::alphabet_base< derived_type, size, char_t >::to_rank ( ) const
inlinenoexceptinherited

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

Satisfies the seqan3::semi_alphabet_concept::to_rank() requirement via the to_rank() wrapper.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

Friends And Related Function Documentation

◆ masked()

template<typename sequence_alphabet_type >
masked ( sequence_alphabet_type &&  ,
mask const &   
) -> masked< std::decay_t< sequence_alphabet_type >>
related

Type deduction guide enables usage of masked without specifying template args.


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