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

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

Inheritance diagram for seqan3::alphabet_tuple_base< derived_type, component_types >:

Friends
Comparison operators (against indirect component_list)
These overloads enable comparison for all types that a component type is comparable with.
template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator== (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator== (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator!= (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator!= (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_eq_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator< (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator< (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator<= (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator<= (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator> (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator> (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator>= (derived_type_t const lhs, indirect_component_type const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

template<typename derived_type_t , typename indirect_component_type >
constexpr auto	operator>= (indirect_component_type const lhs, derived_type_t const rhs) noexcept -> std::enable_if_t< detail::tuple_order_guard< derived_type_t, derived_type, indirect_component_type, component_types... >, bool >
	Comparison against types comparable with components.

Comparison operators

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	alphabet_tuple_base (component_types... components) noexcept
	Construction from initialiser-list.

template<typename component_type > requires (!std::is_base_of_v<alphabet_tuple_base, component_type>) && is_unique_component<component_type>
constexpr	alphabet_tuple_base (component_type const alph) noexcept
	Construction via a value of one of the components.

template<typename indirect_component_type > requires ((detail::instantiate_if_v< detail::lazy<std::is_convertible, indirect_component_type, component_types>, detail::tuple_general_guard<derived_type, indirect_component_type, component_types...>> \|\| ...))
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.

template<typename component_type > requires (!std::derived_from<component_type, alphabet_tuple_base>) && is_unique_component<component_type>
constexpr derived_type &	operator= (component_type const alph) noexcept
	Assignment via a value of one of the components.

template<typename indirect_component_type > requires ((!std::derived_from<indirect_component_type, alphabet_tuple_base>) && (!is_unique_component<indirect_component_type>) && (std::assignable_from<component_types, indirect_component_type> \|\| ...))
constexpr derived_type &	operator= (indirect_component_type const alph) noexcept
	Assignment via a value of a subtype that is assignable to one of the components.

Read functions
All read operations are constant complexity.
template<typename type > requires is_unique_component<type>
constexpr	operator type () const noexcept
	Implicit cast to a single letter. Works only if the type is unique in the type list.

template<size_t index>
constexpr auto	get (alphabet_tuple_base &l) noexcept
	Tuple-like access to the contained components.

template<typename type > requires is_unique_component<type>
constexpr auto	get (alphabet_tuple_base &l) noexcept
	Tuple-like access to the contained components.

template<size_t index>
constexpr auto	get (alphabet_tuple_base const &l) noexcept
	Tuple-like access to the contained components.

template<typename type > requires is_unique_component<type>
constexpr type	get (alphabet_tuple_base const &l) noexcept
	Tuple-like access to the contained components.

Additional Inherited Members
Public Member Functions inherited from seqan3::alphabet_base< derived_type,(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.

constexpr rank_type	to_rank () const noexcept
	Return the letter's numeric value (rank in the alphabet).

constexpr derived_type &	assign_char (char_type const chr) noexcept
	Assign from a character, implicitly converts invalid characters.

constexpr derived_type &	assign_rank (rank_type const c) noexcept
	Assign from a numeric value.

Static Public Attributes inherited from seqan3::alphabet_base< derived_type,(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.

Protected Types inherited from seqan3::alphabet_base< derived_type,(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.

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

Detailed Description

template<typename derived_type, typename... component_types>
requires (detail::writable_constexpr_semialphabet<component_types> && ...) && (std::regular<component_types> && ...)
class seqan3::alphabet_tuple_base< derived_type, component_types >

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

.

Template Parameters

component_types Types of letters; must model std::regular and seqan3::writable_semialphabet and all required function calls need to be callable in constexpr-context.

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

Short description:

combines multiple alphabets as independent components, similar to a tuple;
models seqan3::tuple_like, i.e. provides a get interface to its component_list;
is itself a seqan3::writable_semialphabet, but most derived types implement the full seqan3::writable_alphabet;
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

This entity is stable. Since version 3.1.

Constructor & Destructor Documentation

◆ alphabet_tuple_base() [1/2]

template<typename derived_type , typename... component_types>

template<typename component_type >
requires (!std::is_base_of_v<alphabet_tuple_base, component_type>) && is_unique_component<component_type>

constexpr seqan3::alphabet_tuple_base< derived_type, component_types >::alphabet_tuple_base ( component_type const alph )

inlineexplicitconstexprnoexcept

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

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#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 namespace seqan3::literals;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'C'_dna4};    // creates {'C'_dna4, '!'_phred42}
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter2{'"'_phred42}; // creates {'A'_dna4, '"'_phred42}
 
    if (letter1 == letter2)
        seqan3::debug_stream << "yeah\n"; // yeah
}

This entity is stable. Since version 3.1.

◆ alphabet_tuple_base() [2/2]

template<typename derived_type , typename... component_types>

template<typename indirect_component_type >
requires ((detail::instantiate_if_v< detail::lazy<std::is_convertible, indirect_component_type, component_types>, detail::tuple_general_guard<derived_type, indirect_component_type, component_types...>> || ...))

constexpr seqan3::alphabet_tuple_base< derived_type, component_types >::alphabet_tuple_base ( indirect_component_type const alph )

inlineexplicitconstexprnoexcept

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

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#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 namespace seqan3::literals;
 
    // The following creates {'C'_dna4, '!'_phred42}
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'C'_dna4};
    // The following also creates {'C'_dna4, '!'_phred42}, 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

◆ operator type()

template<typename derived_type , typename... component_types>

template<typename type >
requires is_unique_component<type>

constexpr seqan3::alphabet_tuple_base< derived_type, component_types >::operator type ( ) const

inlineconstexprnoexcept

Implicit cast to a single letter. Works only if the type is unique in the type list.

This entity is stable. Since version 3.1.

◆ operator=() [1/2]

template<typename derived_type , typename... component_types>

template<typename component_type >
requires (!std::derived_from<component_type, alphabet_tuple_base>) && is_unique_component<component_type>

constexpr derived_type & seqan3::alphabet_tuple_base< derived_type, component_types >::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).

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'T'_dna4, '"'_phred42};
 
    letter1 = 'C'_dna4;    // yields {'C'_dna4, '"'_phred42}
    letter1 = '#'_phred42; // yields {'C'_dna4, '#'_phred42}
}

This entity is stable. Since version 3.1.

◆ operator=() [2/2]

template<typename derived_type , typename... component_types>

template<typename indirect_component_type >
requires ((!std::derived_from<indirect_component_type, alphabet_tuple_base>) && (!is_unique_component<indirect_component_type>) && (std::assignable_from<component_types, indirect_component_type> || ...))

constexpr derived_type & seqan3::alphabet_tuple_base< derived_type, component_types >::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).

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#include <seqan3/alphabet/nucleotide/all.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/alphabet/quality/qualified.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::qualified<seqan3::dna4, seqan3::phred42> letter1{'T'_dna4, '"'_phred42};
 
    letter1 = 'C'_rna4; // yields {'C'_dna4, '"'_phred42}
}

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

Friends And Related Symbol Documentation

◆ get [1/4]

template<typename derived_type , typename... component_types>

template<size_t index>

constexpr auto get ( alphabet_tuple_base< derived_type, component_types > & l )

friend

Tuple-like access to the contained components.

Template Parameters

index Return the i-th element.

Returns: A proxy to the contained element that models the same alphabets concepts and supports assignment.

This entity is stable. Since version 3.1.

◆ get [2/4]

template<typename derived_type , typename... component_types>

template<typename type >
requires is_unique_component<type>

constexpr auto get ( alphabet_tuple_base< derived_type, component_types > & l )

friend

Tuple-like access to the contained components.

Template Parameters

type	Return 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.

This entity is stable. Since version 3.1.

◆ get [3/4]

template<typename derived_type , typename... component_types>

template<size_t index>

constexpr auto get ( alphabet_tuple_base< derived_type, component_types > const & l )

friend

Tuple-like access to the contained components.

Template Parameters

index Return the i-th element.

Returns: A copy of the contained element.

This entity is stable. Since version 3.1.

◆ get [4/4]

template<typename derived_type , typename... component_types>

template<typename type >
requires is_unique_component<type>

constexpr type get ( alphabet_tuple_base< derived_type, component_types > const & l )

friend

Tuple-like access to the contained components.

Template Parameters

type	Return the element of specified type; only available if the type is unique in the set of components.

Returns: A copy of the contained element.

This entity is stable. Since version 3.1.

◆ operator!= [1/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator!=	(	derived_type_t const	lhs,
		indirect_component_type const	rhs
	)		-> std::enable_if_t< detail::tuple_eq_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator!= [2/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator!=	(	indirect_component_type const	lhs,
		derived_type_t const	rhs
	)		-> std::enable_if_t< detail::tuple_eq_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator< [1/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator<	(	derived_type_t const	lhs,
		indirect_component_type const	rhs
	)		-> std::enable_if_t< detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator< [2/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator<	(	indirect_component_type const	lhs,
		derived_type_t const	rhs
	)		-> std::enable_if_t< detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator<= [1/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator<=	(	derived_type_t const	lhs,
		indirect_component_type const	rhs
	)		-> std::enable_if_t< detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator<= [2/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator<=	(	indirect_component_type const	lhs,
		derived_type_t const	rhs
	)		-> std::enable_if_t< detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator== [1/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator==	(	derived_type_t const	lhs,
		indirect_component_type const	rhs
	)		-> std::enable_if_t< detail::tuple_eq_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator== [2/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator==	(	indirect_component_type const	lhs,
		derived_type_t const	rhs
	)		-> std::enable_if_t< detail::tuple_eq_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator> [1/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator>	(	derived_type_t const	lhs,
		indirect_component_type const	rhs
	)		-> std::enable_if_t< detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator> [2/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator>	(	indirect_component_type const	lhs,
		derived_type_t const	rhs
	)		-> std::enable_if_t< detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator>= [1/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator>=	(	derived_type_t const	lhs,
		indirect_component_type const	rhs
	)		-> std::enable_if_t< detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

◆ operator>= [2/2]

template<typename derived_type , typename... component_types>

template<typename derived_type_t , typename indirect_component_type >

constexpr auto operator>=	(	indirect_component_type const	lhs,
		derived_type_t const	rhs
	)		-> std::enable_if_t< detail::tuple_order_guard<derived_type_t, derived_type, indirect_component_type, component_types...>, bool>

friend

Comparison against types comparable with components.

Template Parameters

indirect_component_type Must be comparable with a component's type.

Parameters

lhs	Left-hand-side of comparison.
rhs	Right-hand-side of comparison.

Returns: true or false.

To determine (in-)equality/order, it is first deduced which component the argument is comparable with. The tuple is then cast to that type and the resulting value compared with the argument.

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

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

alphabet_tuple_base.hpp

Friends

Constructors, destructor and assignment

Read functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ alphabet_tuple_base() [1/2]

◆ alphabet_tuple_base() [2/2]

Member Function Documentation

◆ operator type()

◆ operator=() [1/2]

◆ operator=() [2/2]

Friends And Related Symbol Documentation

◆ get [1/4]

◆ get [2/4]

◆ get [3/4]

◆ get [4/4]

◆ operator!= [1/2]

◆ operator!= [2/2]

◆ operator< [1/2]

◆ operator< [2/2]

◆ operator<= [1/2]

◆ operator<= [2/2]

◆ operator== [1/2]

◆ operator== [2/2]

◆ operator> [1/2]

◆ operator> [2/2]

◆ operator>= [1/2]

◆ operator>= [2/2]