Core

Provides core functionality used by multiple modules. More...

Collaboration diagram for Core:

Modules
	Algorithm
	Provides core functionality used for algorithms.
	Concept
	Provides core concepts.
	Configuration
	Provides core functionality used to configure configurations.
	Debug Stream
	Provides core functionality used to print seqan3 and std types.
	Range
	Provides seqan3 general purpose range functionality.

Classes
struct	seqan3::detail::customisation_point_object< derived_t, max_priority >
	A CRTP base-class that defines a customisation_point_object (CPO). More...
struct	seqan3::detail::deferred_crtp_base< crtp_base, args_t >
	An invocable wrapper that defers the instantiation of a crtp_base class. More...
struct	seqan3::detail::deferred_crtp_base_vargs< crtp_base, args >
	An invocable wrapper that defers the instantiation of a crtp_base class. More...
interface	derived_from_strong_type
	Defines the requirements of a seqan::detail::strong_type specialisation. More...
struct	seqan3::detail::empty_type
	An empty class type used in meta programming. More...
struct	seqan3::detail::is_class_template_declarable_with< query_t, args_t >
	An unary type trait that tests whether a template class can be declared with the given template type parameters. More...
struct	seqan3::detail::is_type_specialisation_of< source_t, target_template >
	Determines whether a source_type is a specialisation of another template. More...
struct	seqan3::detail::is_value_specialisation_of< source_t, target_template >
	Determines whether a source_type is a specialisation of another template. More...
struct	seqan3::detail::iter_pointer< it_t >
	This is like std::iter_value_t, but for the pointer type. More...
struct	seqan3::detail::maybe_inherited_iterator_category< underling_iterator_t >
	This handles more cases than maybe_iterator_category if you inherit the underling_iterator_t. More...
struct	seqan3::detail::maybe_iterator_category< underlying_iterator_t >
	Defines iterator_category member if underlying_iterator_t has a valid std::iterator_traits::iterator_category overload. More...
class	seqan3::detail::persist_fn
	[adaptor_def] More...
struct	seqan3::pod_tuple< type0 >
	Recursion anchor for pod_tuple. More...
struct	seqan3::detail::priority_tag< I >
	A tag that allows controlled overload resolution via implicit base conversion rules. More...
class	seqan3::detail::strong_type< value_t, derived_t, skills_ >
	CRTP base class to declare a strong typedef for a regular type to avoid ambiguous parameter settings in function calls. More...
interface	template_specialisation_of
	Provides concept seqan3::template_specialisation_of<mytype, [...]> for checking the type specialisation of some type with a given template, for example a specialized type_list<float> with the type_list template. More...
struct	seqan3::detail::transfer_template_args_onto< source_template< source_arg_types... >, target_template >
	Extracts a type template's type arguments and specialises another template with them. More...
struct	seqan3::detail::transfer_template_vargs_onto< source_template< source_varg_types... >, target_template >
	Extracts a type template's non-type arguments and specialises another template with them. More...
struct	seqan3::detail::transfer_type_modifier_onto< source_t, target_t >
	Transfers the type modifier &, && and const (and any combination) to the target type. More...
struct	seqan3::detail::type_list_expander< type_list_t< args_t... > >
	Helper class to invoke a meta algorithm on the types contained in a seqan3::type_list. More...
struct	seqan3::detail::valid_template_spec_or< fallback_t, templ_t, spec_t >
	Exposes templ_t<spec_t...> if that is valid, otherwise fallback_t. More...
class	seqan3::detail::view_persist< urng_t >
	The type returned by seqan3::detail::persist. More...

Macros
#define	SEQAN3_CPO_OVERLOAD(...)
	A macro that helps to define a seqan3::detail::customisation_point_object. More...
#define	SEQAN3_CPO_OVERLOAD_BODY(...)   noexcept(auto) { return __VA_ARGS__; }
	A macro helper for SEQAN3_CPO_OVERLOAD. More...
#define	SEQAN3_WITH_CEREAL   0
	Whether CEREAL support is available or not.
#define	SEQAN3_WITH_LEMON   0
	Whether Lemon support is available or not.

Typedefs
template<typename deferred_crtp_base_t , typename derived_t >
using	seqan3::detail::invoke_deferred_crtp_base = typename deferred_crtp_base_t::template invoke< derived_t >
	Template alias to instantiate the deferred crtp base with the derived class. More...
template<typename it_t >
using	seqan3::detail::iter_pointer_t = typename iter_pointer< it_t >::type
	Return the pointer type of the input type (transformation_trait shortcut). More...
template<typename it_t >
using	seqan3::detail::iterator_concept_tag_t = std::conditional_t< std::contiguous_iterator< it_t >, std::contiguous_iterator_tag, std::conditional_t< std::random_access_iterator< it_t >, std::random_access_iterator_tag, std::conditional_t< std::bidirectional_iterator< it_t >, std::bidirectional_iterator_tag, std::conditional_t< std::forward_iterator< it_t >, std::forward_iterator_tag, std::conditional_t< std::input_iterator< it_t >, std::input_iterator_tag, std::output_iterator_tag > >> >>
	Exposes the iterator_concept from the modelled concept. More...
using	seqan3::semiregular_box = ::ranges::semiregular_box
	Utility wrapper that behaves like std::optional but makes the type conform with the std::semiregular concept. Imported from ranges::semiregular_box. More...
using	seqan3::semiregular_box_t = ::ranges::semiregular_box_t
	Utility transformation trait to get a wrapper type that models std::semiregular. Imported from ranges::semiregular_box_t. More...
template<typename t >
using	seqan3::detail::strip_type_identity_t = std::conditional_t< is_type_specialisation_of_v< t, std::type_identity >, transformation_trait_or_t< t, void >, t >
	A transformation trait shortcut that returns the type inside a std::type_identity or the type itself. More...
template<typename source_type , template< typename ... > typename target_template>
using	seqan3::detail::transfer_template_args_onto_t = typename transfer_template_args_onto< source_type, target_template >::type
	Shortcut for seqan3::detail::transfer_template_args_onto (transformation_trait shortcut). More...
template<typename source_type , template< auto ... > typename target_template>
using	seqan3::detail::transfer_template_vargs_onto_t = typename transfer_template_vargs_onto< source_type, target_template >::type
	Shortcut for seqan3::detail::transfer_template_vargs_onto (transformation_trait shortcut). More...
template<typename fallback_t , template< typename ... > typename templ_t, typename ... spec_t>
using	seqan3::detail::valid_template_spec_or_t = typename valid_template_spec_or< fallback_t, templ_t, spec_t... >::type
	Helper for seqan3::detail::valid_template_spec_or (transformation_trait shortcut). More...

Enumerations
enum class	seqan3::detail::strong_type_skill {   none = 0 , add = 1 << 0 , subtract = 1 << 1 , multiply = 1 << 2 ,   divide = 1 << 3 , modulo = 1 << 4 , bitwise_and = 1 << 5 , bitwise_or = 1 << 6 ,   bitwise_xor = 1 << 7 , bitwise_not = 1 << 8 , bitwise_lshift = 1 << 9 , bitwise_rshift = 1 << 10 ,   logical_and = 1 << 11 , logical_or = 1 << 12 , logical_not = 1 << 13 , increment = 1 << 14 ,   decrement = 1 << 15 , convert = 1 << 16 , comparable = 1 << 17 , additive = add | subtract ,   multiplicative = multiply | divide | modulo , bitwise_logic = bitwise_and | bitwise_or | bitwise_xor | bitwise_not , bitwise_shift = bitwise_lshift | bitwise_rshift , logic = logical_and | logical_or | logical_not }
	Enum class for all supported operations that can be added to a seqan3::detail::strong_type. More...

Functions
template<typename type_list_t , typename unary_predicate_t >
constexpr bool	seqan3::detail::all_of (unary_predicate_t &&fn)
	Tests whether a given predicate evaluates to true for each type in a seqan3::type_list. More...
template<typename unary_predicate_t , typename ... pack_t>
constexpr bool	seqan3::detail::all_of (unary_predicate_t &&fn, pack_t &&...args)
	Tests whether a given predicate evaluates to true for each element in the function parameter pack. More...
template<std::unsigned_integral unsigned_t>
constexpr unsigned_t	seqan3::detail::ceil_log2 (unsigned_t const n) noexcept
	Computes the ceil of the logarithm to the base of two for unsigned integers. More...
template<std::unsigned_integral unsigned_t>
constexpr unsigned_t	seqan3::detail::floor_log2 (unsigned_t const n) noexcept
	Computes the floor of the logarithm to the base of two for unsigned integers. More...
template<typename type_list_t , typename unary_function_t >
constexpr void	seqan3::detail::for_each (unary_function_t &&fn)
	Applies a function element wise to all types of a type list. More...
template<typename unary_function_t , typename ... pack_t>
constexpr void	seqan3::detail::for_each (unary_function_t &&fn, pack_t &&...args)
	Applies a function to each element of the given function parameter pack. More...
template<typename base_t , std::unsigned_integral exp_t>
base_t	seqan3::pow (base_t base, exp_t exp)
	Computes the value of base raised to the power exp. More...

Variables
template<typename t >
constexpr bool	seqan3::add_enum_bitwise_operators = false
	Set to true for a scoped enum to have binary operators overloaded. More...
template<typename t >
constexpr bool	seqan3::detail::is_type_list_of_sequence_file_input_formats_v = false
	Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_input_format [default is false]. More...
template<typename ... ts>
constexpr bool	seqan3::detail::is_type_list_of_sequence_file_input_formats_v< type_list< ts... > >
	Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_input_format [overload]. More...
template<typename t >
constexpr bool	seqan3::detail::is_type_list_of_structure_file_input_formats_v = false
	Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_input_format [default is false]. More...
template<typename ... ts>
constexpr bool	seqan3::detail::is_type_list_of_structure_file_input_formats_v< type_list< ts... > > = (structure_file_input_format<ts> && ...)
	Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_input_format [overload]. More...
template<typename t >
constexpr bool	seqan3::detail::is_type_list_of_structure_file_output_formats_v = false
	Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_output_format [default is false]. More...
template<typename ... ts>
constexpr bool	seqan3::detail::is_type_list_of_structure_file_output_formats_v< type_list< ts... > > = (structure_file_output_format<ts> && ...)
	Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_output_format [overload]. More...
constexpr auto	seqan3::detail::persist
	[adaptor_def] More...
template<typename t >
SEQAN3_CONCEPT	seqan3::detail::type_list_of_sequence_file_input_formats = is_type_list_of_sequence_file_input_formats_v<t>
	Auxiliary concept that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_input_format. More...
template<typename t >
SEQAN3_CONCEPT	seqan3::detail::type_list_of_structure_file_input_formats = is_type_list_of_structure_file_input_formats_v<t>
	Auxiliary concept that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_input_format. More...
template<typename t >
SEQAN3_CONCEPT	seqan3::detail::type_list_of_structure_file_output_formats = is_type_list_of_structure_file_output_formats_v<t>
	Auxiliary concept that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_output_format. More...
template<typename type >
std::string const	seqan3::detail::type_name_as_string
	Defines the human-readable name of the given type using the typeid operator. More...

Detailed Description

Provides core functionality used by multiple modules.

The core module contains concepts, functions and some classes that are used by multiple other modules, but that usually are not relevant to most users of the library.

Macro Definition Documentation

SEQAN3_CPO_OVERLOAD

#define SEQAN3_CPO_OVERLOAD

(

...

)

Value:

    cpo_overload(__VA_ARGS__) \
    SEQAN3_CPO_OVERLOAD_BODY

A macro that helps to define a seqan3::detail::customisation_point_object.

DEV

Expands to a function definition with the name cpo_overload.

It puts the given expression via SEQAN3_CPO_OVERLOAD_BODY as a single return statement in the function body, the noexcept declaration and requires declaration.

    template <typename range_t>
        requires true // further constraints
    static constexpr auto SEQAN3_CPO_OVERLOAD(seqan3::detail::priority_tag<1>, range_t && range)
    (
        /*return*/ std::forward<range_t>(range).begin() /*;*/
    );

expands to something similar to

template <typename range_t>
    requires true // further constraints
static constexpr auto cpo_overload(seqan3::detail::priority_tag<1>, range_t && range)
 
    noexcept(noexcept(std::forward<range_t>(range).begin()))
 
    requires requires()
    {
        {std::forward<range_t>(range).begin()};
    }
 
{
    return std::forward<range_t>(range).begin();
}

SEQAN3_CPO_OVERLOAD_BODY

#define SEQAN3_CPO_OVERLOAD_BODY

(

...

)

noexcept(auto) { return __VA_ARGS__; }

A macro helper for SEQAN3_CPO_OVERLOAD.

DEV

Please note that in order to allow a semicolon at the end when using this macro, i.e.

SEQAN3_CPO_OVERLOAD_BODY
(
    ...
);

we need some expression at the end of the macro that can have a semicolon appended. We chose static_assert(true) for that reason.

Typedef Documentation

invoke_deferred_crtp_base

template<typename deferred_crtp_base_t , typename derived_t >

using seqan3::detail::invoke_deferred_crtp_base = typedef typename deferred_crtp_base_t::template invoke<derived_t>

Template alias to instantiate the deferred crtp base with the derived class.

Template Parameters

deferred_crtp_base_t	The deferred crtp base class.
derived_t	The derived type to instantiate the crtp base class with.

Effectively declares the type resulting from deferred_crtp_base_t::template invoke<derived_t>.

See also

seqan3::detail::deferred_crtp_base

iter_pointer_t

template<typename it_t >

using seqan3::detail::iter_pointer_t = typedef typename iter_pointer<it_t>::type

Return the pointer type of the input type (transformation_trait shortcut).

Template Parameters

it_t	The type to operate on.

See also

seqan3::detail::iter_pointer

iterator_concept_tag_t

template<typename it_t >

using seqan3::detail::iterator_concept_tag_t = typedef std::conditional_t< std::contiguous_iterator<it_t>, std::contiguous_iterator_tag, std::conditional_t< std::random_access_iterator<it_t>, std::random_access_iterator_tag, std::conditional_t< std::bidirectional_iterator<it_t>, std::bidirectional_iterator_tag, std::conditional_t< std::forward_iterator<it_t>, std::forward_iterator_tag, std::conditional_t< std::input_iterator<it_t>, std::input_iterator_tag, std::output_iterator_tag> >> >>

Exposes the iterator_concept from the modelled concept.

Template Parameters

it_t	The type to operate on.

semiregular_box

using seqan3::semiregular_box = typedef ::ranges::semiregular_box

Utility wrapper that behaves like std::optional but makes the type conform with the std::semiregular concept. Imported from ranges::semiregular_box.

See also

https://en.cppreference.com/w/cpp/ranges/semiregular_wrapper

semiregular_box_t

using seqan3::semiregular_box_t = typedef ::ranges::semiregular_box_t

Utility transformation trait to get a wrapper type that models std::semiregular. Imported from ranges::semiregular_box_t.

See also

https://en.cppreference.com/w/cpp/ranges/semiregular_wrapper

strip_type_identity_t

template<typename t >

using seqan3::detail::strip_type_identity_t = typedef std::conditional_t<is_type_specialisation_of_v<t, std::type_identity>, transformation_trait_or_t<t, void>, t>

A transformation trait shortcut that returns the type inside a std::type_identity or the type itself.

Template Parameters

t	The type to operate on.

transfer_template_args_onto_t

template<typename source_type , template< typename ... > typename target_template>

using seqan3::detail::transfer_template_args_onto_t = typedef typename transfer_template_args_onto<source_type, target_template>::type

Shortcut for seqan3::detail::transfer_template_args_onto (transformation_trait shortcut).

See also

seqan3::detail::transfer_template_args_onto

transfer_template_vargs_onto_t

template<typename source_type , template< auto ... > typename target_template>

using seqan3::detail::transfer_template_vargs_onto_t = typedef typename transfer_template_vargs_onto<source_type, target_template>::type

Shortcut for seqan3::detail::transfer_template_vargs_onto (transformation_trait shortcut).

See also

seqan3::detail::transfer_template_vargs_onto

valid_template_spec_or_t

template<typename fallback_t , template< typename ... > typename templ_t, typename ... spec_t>

using seqan3::detail::valid_template_spec_or_t = typedef typename valid_template_spec_or<fallback_t, templ_t, spec_t...>::type

Helper for seqan3::detail::valid_template_spec_or (transformation_trait shortcut).

See also

seqan3::detail::valid_template_spec_or

Template Parameters

fallback_t	The fallback type.
templ_t	The type template that should be specialised.
spec_t	The specialisation for the type template.

Enumeration Type Documentation

strong_type_skill

enum seqan3::detail::strong_type_skill

strong

Enum class for all supported operations that can be added to a seqan3::detail::strong_type.

See also

seqan3::enum_bitwise_operators enables combining enum values.

Function Documentation

all_of() [1/2]

template<typename type_list_t , typename unary_predicate_t >

constexpr bool seqan3::detail::all_of ( unary_predicate_t &&  fn )

constexpr

Tests whether a given predicate evaluates to true for each type in a seqan3::type_list.

Template Parameters

list_t	A type list; must model seqan3::detail::template_specialisation_of a seqan3::type_list
unary_predicate_t	The function type, like function pointers, functors and lambdas; must model std::predicate expanded on each argument type wrapped in std::type_identity.

Parameters

[in]

fn

The predicate called for every type in the seqan3::type_list.

Returns

true if the predicate returns true for each type in the type list, false otherwise.

This function operates on types instead of values. The following steps are performed to call the passed predicate on the types contained in the type list:

• expand the types within the type list
• wrap each type in std::identity and instantiate it (i.e. transform a type into a value)
• call the parameter pack version of seqan3::detail::all_of with the instances of std::identity (as a pack).

Note that wrapping the types in std::type_identity is a technical trick to make a type representable as a value. Instantiating a type might not work because they might not be std::default_initializable. In addition it is possible, to invoke the predicate on incomplete types.

Example

#include <type_traits>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/core/detail/pack_algorithm.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
namespace incomplete
{
 
struct type;
 
} // namespace incomplete
 
// With c++20 you could also write it like this
// auto fn = []<typename type>(std::type_identity<type>)
// {
// ...
// };
auto fn = [](auto id)
{
    // id is of type std::type_identity<type>
    using id_t = decltype(id);
    using type = typename id_t::type;
 
    static_assert(std::is_same_v<id_t, std::type_identity<type>>, "id is of type std::type_identity<type>");
 
    if constexpr(std::is_same_v<type, bool>)
        return true;
    else if constexpr(std::is_same_v<type, int>)
        return true;
    else if constexpr(std::is_same_v<type, float>)
        return true;
    else if constexpr(std::is_same_v<type, incomplete::type>)
        return false;
};
 
static_assert(seqan3::detail::all_of<seqan3::type_list<int, float, bool>>(fn)); // evalates to true
static_assert(!seqan3::detail::all_of<seqan3::type_list<int, float, bool, incomplete::type>>(fn)); // evalates to false

Complexity

Linear in the number of types in the seqan3::type_list.

[Compile-time complexity: Linear number of template instantiations.]

all_of() [2/2]

template<typename unary_predicate_t , typename ... pack_t>

constexpr bool seqan3::detail::all_of ( unary_predicate_t &&  fn, pack_t &&...  args  )

constexpr

Tests whether a given predicate evaluates to true for each element in the function parameter pack.

Template Parameters

unary_predicate_t	The function type, like function pointers, functors and lambdas; must model std::predicate expanded on each argument type.
pack_t	The parameter pack of the arguments (each argument type can be different).

Parameters

[in]	fn	The predicate to evaluate for every argument.
[in]	args	The parameter pack.

Returns

true if the predicate returns true for each type in the type list, false otherwise.

This function behaves like std::all_of but on parameter packs. The invocation(s) will be done without any loop.

Example

#include <type_traits>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/core/detail/pack_algorithm.hpp>
 
// With c++20 you could also write it like this
// auto fn = []<typename value_t>(value_t && value)
// {
// ...
// };
auto fn = [](auto value)
{
    // id is the original type not wrapped in std::type_identity.
    using value_t = decltype(value);
 
    if constexpr(std::is_same_v<value_t, bool>)
        return value == false;
    else if constexpr(std::is_same_v<value_t, int>)
        return value == 3;
    else if constexpr(std::is_same_v<value_t, double>)
        return std::abs(value - 1.2) < 0.00001;
    else
        return false;
};
 
static_assert(seqan3::detail::all_of(fn, 3, 1.2, false)); // evalates to true
static_assert(!seqan3::detail::all_of(fn, 3, 1.2, false, "something else")); // evalates to false

Complexity

Linear in the number of elements in the pack.

Attention

Opposed to the std::all_of the argument order is changed, such that the first argument is the unary predicate to invoke on each argument followed by the arguments. This is due to a constraint in the c++ language regarding parameter packs.

See also

https://en.cppreference.com/w/cpp/language/parameter_pack

ceil_log2()

template<std::unsigned_integral unsigned_t>

constexpr unsigned_t seqan3::detail::ceil_log2 ( unsigned_t const  n )

constexprnoexcept

Computes the ceil of the logarithm to the base of two for unsigned integers.

Parameters

[in]

n

An unsigned integer.

Attention

n = 0 is a special case and is undefined.

Returns

\( \lceil log_2(n) \rceil \).

The difference to std::ceil(std::log2(n)) is that everything is computed exactly (without precision loss due to promoting to double)

Example

#include <seqan3/utility/math.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    // the same as std::ceil(std::log2(x)), but exact for unsigned integers
    seqan3::debug_stream << "ceil_log2(2^0 + 0): " << seqan3::detail::ceil_log2(1u) << '\n'; // 0u
    seqan3::debug_stream << "ceil_log2(2^1 + 0): " << seqan3::detail::ceil_log2(2u) << '\n'; // 1u
    seqan3::debug_stream << "ceil_log2(2^1 + 1): " << seqan3::detail::ceil_log2(3u) << '\n'; // 2u
    seqan3::debug_stream << "ceil_log2(2^2 + 0): " << seqan3::detail::ceil_log2(4u) << '\n'; // 2u
    seqan3::debug_stream << "ceil_log2(2^2 + 1): " << seqan3::detail::ceil_log2(5u) << '\n'; // 3u
    seqan3::debug_stream << "ceil_log2(2^2 + 2): " << seqan3::detail::ceil_log2(6u) << '\n'; // 3u
    seqan3::debug_stream << "ceil_log2(2^2 + 3): " << seqan3::detail::ceil_log2(7u) << '\n'; // 3u
    seqan3::debug_stream << "ceil_log2(2^3 + 0): " << seqan3::detail::ceil_log2(8u) << '\n'; // 3u
    seqan3::debug_stream << "ceil_log2(2^3 + 1): " << seqan3::detail::ceil_log2(9u) << '\n'; // 4u
 
    return 0;
}

Exception

No-throw guarantee.

Thread-safety

Thread safe.

Complexity

Constant.

floor_log2()

template<std::unsigned_integral unsigned_t>

constexpr unsigned_t seqan3::detail::floor_log2 ( unsigned_t const  n )

constexprnoexcept

Computes the floor of the logarithm to the base of two for unsigned integers.

Parameters

[in]

n

An unsigned integer.

Attention

n = 0 is a special case and is undefined.

Returns

\( \lfloor log_2(n) \rfloor \).

The difference to std::floor(std::log2(n)) is that everything is computed exactly (without precision loss due to promoting to double)

Example

#include <seqan3/utility/math.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    // the same as std::floor(std::log2(x)), but exact for unsigned integers
    seqan3::debug_stream << "floor_log2(2^0 + 0): " << seqan3::detail::floor_log2(1u) << '\n'; // 0u
    seqan3::debug_stream << "floor_log2(2^1 + 0): " << seqan3::detail::floor_log2(2u) << '\n'; // 1u
    seqan3::debug_stream << "floor_log2(2^1 + 1): " << seqan3::detail::floor_log2(3u) << '\n'; // 1u
    seqan3::debug_stream << "floor_log2(2^2 + 0): " << seqan3::detail::floor_log2(4u) << '\n'; // 2u
    seqan3::debug_stream << "floor_log2(2^2 + 1): " << seqan3::detail::floor_log2(5u) << '\n'; // 2u
    seqan3::debug_stream << "floor_log2(2^2 + 2): " << seqan3::detail::floor_log2(6u) << '\n'; // 2u
    seqan3::debug_stream << "floor_log2(2^2 + 3): " << seqan3::detail::floor_log2(7u) << '\n'; // 2u
    seqan3::debug_stream << "floor_log2(2^3 + 0): " << seqan3::detail::floor_log2(8u) << '\n'; // 3u
    seqan3::debug_stream << "floor_log2(2^3 + 1): " << seqan3::detail::floor_log2(9u) << '\n'; // 3u
 
    return 0;
}

Exception

No-throw guarantee.

Thread-safety

Thread safe.

Complexity

Constant.

for_each() [1/2]

template<typename type_list_t , typename unary_function_t >

constexpr void seqan3::detail::for_each ( unary_function_t &&  fn )

constexpr

Applies a function element wise to all types of a type list.

Template Parameters

list_t	A type list; must model seqan3::detail::template_specialisation_of a seqan3::type_list.
unary_function_t	The function type, like function pointers, functors and lambdas; must model std::invocable on each type of the type list wrapped in std::type_identity.

Parameters

[in]

fn

The function to call on every type contained in the list.

This function operates on types instead of values. The following steps are performed to call the passed unary function on the types contained in the type list:

• expand the types within the type list
• wrap each type in std::identity and instantiate it (i.e. transform a type into a value)
• call the parameter pack version of seqan3::detail::for_each with the instances of std::identity (as a pack).

Note that wrapping the types in std::type_identity is a technical trick to make a type representable as a value. Instantiating a type might not work because they might not be std::default_initializable. In addition, it is possible to invoke the unary function on incomplete types.

Example

#include <string>
 
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/core/detail/pack_algorithm.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
 
namespace incomplete
{
 
struct type;
 
} // namespace incomplete
 
int main()
{
    // With c++20 you could also write it like this
    // auto fn = []<typename type>(std::type_identity<type>)
    // {
    // ...
    // };
    auto fn = [](auto id)
    {
        // id is of type std::type_identity<type>
        using id_t = decltype(id);
        using type = typename id_t::type;
 
        static_assert(std::is_same_v<id_t, std::type_identity<type>>, "id is of type std::type_identity<type>");
 
        if constexpr(std::is_same_v<type, bool>)
            seqan3::debug_stream << "bool";
        else if constexpr(std::is_same_v<type, int>)
            seqan3::debug_stream << "int";
        else if constexpr(std::is_same_v<type, float>)
            seqan3::debug_stream << "float";
        else if constexpr(std::is_same_v<type, incomplete::type>)
            seqan3::debug_stream << "incomplete::type";
 
        seqan3::debug_stream << ", ";
    };
 
    // prints each type name, i.e. "int, float, bool, incomplete::type, \n"
    using types = seqan3::type_list<int, float, bool, incomplete::type>;
    seqan3::detail::for_each<types>(fn);
    seqan3::debug_stream << "\n";
 
    // is the same as explicitly writing
    fn(std::type_identity<int>{});
    fn(std::type_identity<float>{});
    fn(std::type_identity<bool>{});
    fn(std::type_identity<incomplete::type>{});
    seqan3::debug_stream << "\n";
    return 0;
}

Complexity

Linear in the number of types in the seqan3::type_list.

[Compile-time complexity: Linear number of template instantiations.]

See also

seqan3::detail::for_each

for_each() [2/2]

template<typename unary_function_t , typename ... pack_t>

constexpr void seqan3::detail::for_each ( unary_function_t &&  fn, pack_t &&...  args  )

constexpr

Applies a function to each element of the given function parameter pack.

Template Parameters

unary_function_t	The function type, like function pointers, functors and lambdas.
pack_t	The parameter pack of the arguments (each argument type can be different).

Parameters

[in]	fn	The function to call on every argument.
[in]	args	The parameter pack.

This function behaves like std::for_each but on parameter packs. The invocation(s) will be done without any loop.

Example

#include <string>
 
#include <seqan3/core/detail/pack_algorithm.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    auto fn = [](auto && a)
    {
        seqan3::debug_stream << a;
    };
 
    // prints each argument, i.e. "0, 1, 2, 3\n"
    seqan3::detail::for_each(fn, 0, ", ", 1.0, ", ", std::string{"2, 3"}, '\n');
 
    // is the same as explicitly writing
    fn(0);
    fn(", ");
    fn(1.0);
    fn(", ");
    fn(std::string{"2, 3"});
    fn('\n');
    return 0;
}

Complexity

Linear in the number of elements in the pack.

Attention

Opposed to the std::for_each the argument order is changed, such that the first argument is the unary function to invoke on each argument followed by the arguments. This is due to a constraint in the c++ language regarding parameter packs.

See also

https://en.cppreference.com/w/cpp/language/parameter_pack

pow()

template<typename base_t , std::unsigned_integral exp_t>

base_t seqan3::pow	(	base_t	base,
		exp_t	exp
	)

Computes the value of base raised to the power exp.

Parameters

[in]	base	The base to compute the power for.
[in]	exp	The power to raise base to.

Returns

\( base^{exp} \).

Exceptions

std::overflow_error	if an overflow occurs (Only in Debug build).
std::underflow_error	if an underflow occurs (Only in Debug build).

See also

https://en.cppreference.com/w/cpp/numeric/math/pow

The difference to std::pow is that the powers of an integer base are computed exact (without precision loss due to promoting to double) iff exp_t models std::unsigned_integral and

• base_t models std::unsigned_integral (returns uint64_t)
• base_t models std::integral, but not std::unsigned_integral (returns int64_t)

In all other cases the return value and type is equivalent to that of std::pow.

Example

#include <seqan3/utility/math.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    // Uses specialisation for signed integers.
    seqan3::debug_stream << seqan3::pow(2, 3u) << '\n'; // Prints 8
    seqan3::debug_stream << seqan3::pow(-2, 3u) << '\n'; // Prints -8
 
    // Uses specialisation for unsigned integers.
    seqan3::debug_stream << seqan3::pow(2u, 3u) << '\n'; // Prints 8
 
    // Uses `std::pow`.
    seqan3::debug_stream << seqan3::pow(2, 3) << '\n'; // Prints 8
    seqan3::debug_stream << seqan3::pow(2u, 3) << '\n'; // Prints 8
    seqan3::debug_stream << seqan3::pow(2.0, 3) << '\n'; // Prints 8
 
    // 5^25 should be 298023223876953125.
    seqan3::debug_stream << seqan3::pow(5u, 25u) << '\n'; // Prints 298023223876953125
    seqan3::debug_stream << static_cast<uint64_t>(std::pow(5u, 25u)) << '\n'; // Prints 298023223876953152 (wrong!)
}

Variable Documentation

add_enum_bitwise_operators

template<typename t >

constexpr bool seqan3::add_enum_bitwise_operators = false

constexpr

Set to true for a scoped enum to have binary operators overloaded.

If this type trait is specialised for an enum, the binary operators &, |, ^, ~, &=, |=, ^= will be added and behave just like for ints or unscoped enums.

Example

#include <seqan3/core/add_enum_bitwise_operators.hpp>
 
enum class my_enum
{
    VAL1 = 1,
    VAL2 = 2,
    COMB = 3
};
 
template <>
constexpr bool seqan3::add_enum_bitwise_operators<my_enum> = true;
 
int main()
{
    using seqan3::operator|;
    
    my_enum e = my_enum::VAL1;
    my_enum e2 = e | my_enum::VAL2;
 
    // e2 == my_enum::COMB;
}

is_type_list_of_sequence_file_input_formats_v

template<typename t >

constexpr bool seqan3::detail::is_type_list_of_sequence_file_input_formats_v = false

constexpr

Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_input_format [default is false].

See also

seqan3::type_list_specialisationOfsequence_file_input_formats

is_type_list_of_sequence_file_input_formats_v< type_list< ts... > >

template<typename ... ts>

constexpr bool seqan3::detail::is_type_list_of_sequence_file_input_formats_v< type_list< ts... > >

constexpr

Initial value:

=
    (sequence_file_input_format<ts> && ...)

Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_input_format [overload].

See also

seqan3::type_list_specialisationOfsequence_file_input_formats

is_type_list_of_structure_file_input_formats_v

template<typename t >

constexpr bool seqan3::detail::is_type_list_of_structure_file_input_formats_v = false

constexpr

Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_input_format [default is false].

See also

seqan3::type_list_specialisationOfstructure_file_input_formats

is_type_list_of_structure_file_input_formats_v< type_list< ts... > >

template<typename ... ts>

constexpr bool seqan3::detail::is_type_list_of_structure_file_input_formats_v< type_list< ts... > > = (structure_file_input_format<ts> && ...)

constexpr

Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_input_format [overload].

See also

seqan3::type_list_specialisationOfstructure_file_input_formats

is_type_list_of_structure_file_output_formats_v

template<typename t >

constexpr bool seqan3::detail::is_type_list_of_structure_file_output_formats_v = false

constexpr

Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_output_format [default is false].

See also

seqan3::type_list_specialisationOfstructure_file_output_formats

is_type_list_of_structure_file_output_formats_v< type_list< ts... > >

template<typename ... ts>

constexpr bool seqan3::detail::is_type_list_of_structure_file_output_formats_v< type_list< ts... > > = (structure_file_output_format<ts> && ...)

constexpr

Auxiliary value metafuncton that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_output_format [overload].

See also

seqan3::type_list_specialisationOfstructure_file_output_formats

persist

constexpr auto seqan3::detail::persist

inlineconstexpr

[adaptor_def]

A view adaptor that wraps rvalue references of non-views.

Template Parameters

urng_t

The type of the range being processed. See below for requirements. [template parameter is omitted in pipe notation]

Parameters

[in]

urange

The range being processed. [parameter is omitted in pipe notation]

Returns

A range wrapped in a view (even if it doesn't model std::ranges::viewable_range).

Header File

#include <seqan3/core/detail/persist_view.hpp>

For ranges that model std::ranges::viewable_range, this adaptor just returns std::views::all. However this adaptor can also take ranges that are not "viewable", e.g. temporaries of containers. It wraps them in a shared pointer internally so all view requirements like constant copy are satisfied. However construction and copying might be slightly slower, because of reference counting.

View properties

Concepts and traits	urng_t (underlying range type)	rrng_t (returned range type)
std::ranges::input_range	required	preserved
std::ranges::forward_range		preserved
std::ranges::bidirectional_range		preserved
std::ranges::random_access_range		preserved
std::ranges::contiguous_range		preserved
std::ranges::viewable_range	not required	guaranteed
std::ranges::view		guaranteed
std::ranges::sized_range		preserved
std::ranges::common_range		preserved
std::ranges::output_range		preserved
seqan3::const_iterable_range		preserved
std::ranges::range_reference_t		std::ranges::range_reference_t<urng_t>

See the views submodule documentation for detailed descriptions of the view properties.

Example

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/views/to_char.hpp>
#include <seqan3/core/detail/persist_view.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    // explicitly create an l-value of our dna vector:
    auto vec = "ACGT"_dna4;
    auto v = vec | seqan3::views::to_char;
 
    // using seqan3::detail::persist you can bind the temporary directly:
    auto v2 = "ACGT"_dna4 | seqan3::detail::persist | seqan3::views::to_char;
 
    // note that seqan3::detail::persist must follow immediately after the temporary,
    // thus the function notation might be more intuitive:
    auto v3 = seqan3::detail::persist("ACGT"_dna4) | seqan3::views::to_char;
}

type_list_of_sequence_file_input_formats

template<typename t >

SEQAN3_CONCEPT seqan3::detail::type_list_of_sequence_file_input_formats = is_type_list_of_sequence_file_input_formats_v<t>

Auxiliary concept that checks whether a type is a seqan3::type_list and all types meet seqan3::sequence_file_input_format.

See also

seqan3::is_type_list_of_sequence_file_formats_v

type_list_of_structure_file_input_formats

template<typename t >

SEQAN3_CONCEPT seqan3::detail::type_list_of_structure_file_input_formats = is_type_list_of_structure_file_input_formats_v<t>

Auxiliary concept that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_input_format.

See also

seqan3::is_type_list_of_structure_file_formats_v

type_list_of_structure_file_output_formats

template<typename t >

SEQAN3_CONCEPT seqan3::detail::type_list_of_structure_file_output_formats = is_type_list_of_structure_file_output_formats_v<t>

Auxiliary concept that checks whether a type is a seqan3::type_list and all types meet seqan3::structure_file_output_format.

See also

seqan3::is_type_list_of_structure_file_formats_v

type_name_as_string

template<typename type >

std::string const seqan3::detail::type_name_as_string

inline

Defines the human-readable name of the given type using the typeid operator.

Template Parameters

type	The type to get the human-readable name for.

On gcc and clang std::type_info only returns a mangled name. The mangled name can be converted to human-readable form using implementation-specific API such as abi::__cxa_demangle. In other implementations the name returned is already human-readable.

Note

The returned name is implementation defined and might change between different tool chains.