SeqAn3
seqan3::cartesian_composition< derived_type, component_types > Class Template Reference

The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time. More...

#include <seqan3/alphabet/composition/cartesian_composition.hpp>

Inheritance diagram for seqan3::cartesian_composition< derived_type, component_types >:
[legend]

Public 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()).
 
Member types
using char_type = void
 The type of the alphabet when converted to char (e.g. via to_char()).
 

Public Member Functions

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

template<typename indirect_component_type >
constexpr bool operator== (indirect_component_type const &rhs) const noexcept
 
template<typename indirect_component_type >
constexpr bool operator!= (indirect_component_type const &rhs) const noexcept
 
template<typename indirect_component_type >
constexpr bool operator< (indirect_component_type const &rhs) const noexcept
 
template<typename indirect_component_type >
constexpr bool operator> (indirect_component_type const &rhs) const noexcept
 
template<typename indirect_component_type >
constexpr bool operator<= (indirect_component_type const &rhs) const noexcept
 
template<typename indirect_component_type >
constexpr bool operator>= (indirect_component_type const &rhs) const noexcept
 
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 derived_type & assign_char (std::conditional_t< std::Same< char_type, void >, char, char_type > const c) noexcept
 Assign from a character. More...
 
constexpr derived_type & assign_rank (rank_type const c) noexcept
 Assign from a numeric value. More...
 

Static Public Attributes

static detail::min_viable_uint_t< size > constexpr value_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.)

Comparison operators

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

template<typename indirect_component_type , typename derived_type , typename ... component_types>
constexpr bool operator== (indirect_component_type const &lhs, cartesian_composition< derived_type, component_types... > const &rhs)
 
template<typename indirect_component_type , typename derived_type , typename ... indirect_component_types>
constexpr bool operator!= (indirect_component_type const &lhs, cartesian_composition< derived_type, indirect_component_types... > const &rhs)
 
template<typename indirect_component_type , typename derived_type , typename ... indirect_component_types>
constexpr bool operator< (indirect_component_type const &lhs, cartesian_composition< derived_type, indirect_component_types... > const &rhs)
 
template<typename indirect_component_type , typename derived_type , typename ... indirect_component_types>
constexpr bool operator> (indirect_component_type const &lhs, cartesian_composition< derived_type, indirect_component_types... > const &rhs)
 
template<typename indirect_component_type , typename derived_type , typename ... indirect_component_types>
constexpr bool operator<= (indirect_component_type const &lhs, cartesian_composition< derived_type, indirect_component_types... > const &rhs)
 
template<typename indirect_component_type , typename derived_type , typename ... indirect_component_types>
constexpr bool operator>= (indirect_component_type const &lhs, cartesian_composition< derived_type, indirect_component_types... > const &rhs)
 
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...
 

Constructors, destructor and assignment

Attention
Please do not directly use the CRTP base class. The functions are only public for the usage in their derived classes (e.g. seqan3::qualified, seqan3::masked, seqan3::structure_rna and seqan3::structure_aa).
constexpr cartesian_composition (component_types ... components)
 Construction from initialiser-list.
 
template<typename component_type >
constexpr cartesian_composition (component_type const alph)
 Construction via a value of one of the components. More...
 
template<typename indirect_component_type >
constexpr cartesian_composition (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 derived_type & operator= (component_type const alph)
 Assignment via a value of one of the components. More...
 
template<typename indirect_component_type >
constexpr derived_type & operator= (indirect_component_type const alph)
 Assignment via a value of a subtype that is assignable to one of the components. More...
 
constexpr derived_type & operator= (indirect_component_type const alph)
 

Read functions

All read operations are constant complexity.

template<typename type >
constexpr operator type () const
 Implicit cast to a single letter. Works only if the type is unique in the type list.
 
template<size_t index>
constexpr auto get (cartesian_composition &l)
 Tuple-like access to the contained components. More...
 
template<typename type >
constexpr auto get (cartesian_composition &l)
 Tuple-like access to the contained components. More...
 
template<size_t index>
constexpr auto get (cartesian_composition const &l)
 Tuple-like access to the contained components. More...
 
template<typename type >
constexpr type get (cartesian_composition const &l)
 Tuple-like access to the contained components. More...
 

Detailed Description

template<typename derived_type, typename ... component_types>
class seqan3::cartesian_composition< derived_type, component_types >

The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time.

Template Parameters
first_component_typeType of the first letter; must model seqan3::semi_alphabet_concept.
component_typesTypes of further letters (up to 4); must model seqan3::semi_alphabet_concept.

This data structure is CRTP base class for combined alphabets, where the different alphabet letters exist independently as component_list, similar to a tuple.

Short description:

  • combines multiple alphabets as independent component_list, similar to a tuple;
  • models seqan3::tuple_like_concept, i.e. provides a get interface to its component_list;
  • is itself a seqan3::semi_alphabet_concept, but most derived types implement the full seqan3::alphabet_concept;
  • its alphabet size is the product of the individual sizes;
  • constructible, assignable and comparable with each component type and also all types that these are constructible/assignable/comparable with;
  • explicitly convertible to each of its component types
Attention
This is a "pure base class", you cannot instantiate it, you can only inherit from it. Most likely you are interested in using one of it's descendants like seqan3::qualified or seqan3::masked.
See also
qualified
masked

Constructor & Destructor Documentation

◆ cartesian_composition() [1/2]

template<typename derived_type, typename ... component_types>
template<typename component_type >
constexpr seqan3::cartesian_composition< derived_type, component_types >::cartesian_composition ( component_type const  alph)
inlineexplicit

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

◆ cartesian_composition() [2/2]

template<typename derived_type, typename ... component_types>
template<typename indirect_component_type >
constexpr seqan3::cartesian_composition< derived_type, component_types >::cartesian_composition ( indirect_component_type const  alph)
inlineexplicit

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

constexpr derived_type& seqan3::alphabet_base< derived_type, size, void >::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()

constexpr derived_type& seqan3::alphabet_base< derived_type, size, void >::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 derived_type, typename ... component_types>
template<typename component_type >
constexpr derived_type& seqan3::cartesian_composition< derived_type, component_types >::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 derived_type, typename ... component_types>
template<typename indirect_component_type >
constexpr derived_type& seqan3::cartesian_composition< derived_type, component_types >::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_char()

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

Return the letter as a character of char_type.

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

Complexity

Constant.

Exceptions

Guaranteed not to throw.

◆ to_rank()

constexpr rank_type seqan3::alphabet_base< derived_type, size, void >::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

◆ get [1/4]

template<typename derived_type, typename ... component_types>
template<size_t index>
constexpr auto get ( cartesian_composition< derived_type, component_types > &  l)
friend

Tuple-like access to the contained components.

Template Parameters
indexReturn the i-th element.
Returns
A proxy to the contained element that models the same alphabets concepts and supports assignment.

◆ get [2/4]

template<typename derived_type, typename ... component_types>
template<typename type >
constexpr auto get ( cartesian_composition< derived_type, component_types > &  l)
friend

Tuple-like access to the contained components.

Template Parameters
typeReturn the element of specified type; only available if the type is unique in the set of components.
Returns
A proxy to the contained element that models the same alphabets concepts and supports assignment.

◆ get [3/4]

template<typename derived_type, typename ... component_types>
template<size_t index>
constexpr auto get ( cartesian_composition< derived_type, component_types > const &  l)
friend

Tuple-like access to the contained components.

Template Parameters
indexReturn the i-th element.
Returns
A copy of the contained element.

◆ get [4/4]

template<typename derived_type, typename ... component_types>
template<typename type >
constexpr type get ( cartesian_composition< derived_type, component_types > const &  l)
friend

Tuple-like access to the contained components.

Template Parameters
typeReturn the element of specified type; only available if the type is unique in the set of components.
Returns
A copy of the contained element.

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