Loading...
Searching...
No Matches
seqan3::configuration< configs_t > Class Template Reference
Core » Configuration

Collection of elements to configure an algorithm. More...

`#include <seqan3/core/configuration/configuration.hpp>`

Inheritance diagram for seqan3::configuration< configs_t >:
[legend]

## Public Member Functions

Constructor, destructor and assignment
constexpr | configuration ()=default
| Defaulted.
constexpr | configuration (configuration const &)=default
| Defaulted.
constexpr | configuration (configuration &&)=default
| Defaulted.
constexpr configuration & | operator= (configuration const &)=default
| Defaulted.
constexpr configuration & | operator= (configuration &&)=default
| Defaulted.
| ~configuration ()=default
| Defaulted.
template<typename config_element_t> requires (!std::same_as<std::remove_cvref_t<config_element_t>, configuration>) && detail::config_element<std::remove_cvref_t<config_element_t>>
constexpr | configuration (config_element_t &&config_element)
| Constructs a configuration from a single configuration element.
Capacity
constexpr size_t | size () const noexcept
| Returns the number of contained config elements.
Public Member Functions inherited from std::tuple< configs_t... >
T | operator= (T... args)
T | swap (T... args)
T | tuple (T... args)

## Friends

template<detail::config_element... _configs_t>
class | configuration
| Friend declaration for other instances of the configuration.

## Related Symbols

(Note that these are not member symbols.)
template<typename lhs_config_t, typename rhs_config_t>
constexpr auto | operator| (lhs_config_t &&lhs, rhs_config_t &&rhs)
| Combines two configurations and/or configuration elements forming a new seqan3::configuration.
Type deduction guides
template<detail::config_element config_t>
| configuration (config_t) -> configuration< config_t >
| Deduces the correct configuration element type from the passed seqan3::pipeable_config_element.
Tuple interface
template<template< typename... > class query_t, typename... configs_t>
constexpr auto & | get (configuration< configs_t... > &config) noexcept
| Returns the stored element.

## Observers

template<typename alternative_t>
constexpr decltype(auto) | get_or (alternative_t &&alternative) &noexcept
| Returns the stored configuration element if present otherwise the given alternative.
template<typename alternative_t>
constexpr decltype(auto) | get_or (alternative_t &&alternative) const &noexcept
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename alternative_t>
constexpr decltype(auto) | get_or (alternative_t &&alternative) &&noexcept
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename alternative_t>
constexpr decltype(auto) | get_or (alternative_t &&alternative) const &&noexcept
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename query_t>
static constexpr bool | exists () noexcept
| Checks if the given type exists in the tuple.
template<template< typename... > typename query_t>
static constexpr bool | exists () noexcept
| Checks if the given type exists in the tuple.

## Modifiers

Note that modifications return new configurations and do not modify this.
template<typename other_configuration_t> requires (is_config_element_combineable_v<configs_t, std::remove_cvref_t<other_configuration_t>> && ...)
constexpr auto | append (other_configuration_t &&other_config) const
| Returns a new configuration by appending the given configuration to the current one.
template<typename query_t> requires (exists<query_t>())
constexpr auto | remove () const
| Remove a config element from the configuration.
template<template< typename... > typename query_t> requires (exists<query_t>())
constexpr auto | remove () const
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## Detailed Description

template<detail::config_element... configs_t>
class seqan3::configuration< configs_t >

Collection of elements to configure an algorithm.

Template Parameters

  configs_t | Template parameter pack containing all configuration elements; Must model seqan3::detail::config_element

This class provides a unified interface to create and query such configurations for a specific algorithm. It extends the standard tuple interface with some useful functions to modify and query the user configurations.

## Constructor & Destructor Documentation

## configuration()

template<detail::config_element... configs_t>
template<typename config_element_t>
requires (!std::same_as<std::remove_cvref_t<config_element_t>, configuration>) && detail::config_element<std::remove_cvref_t<config_element_t>>

seqan3::configuration< configs_t >::configuration | ( | config_element_t && | config_element | ) |

inline constexpr

Constructs a configuration from a single configuration element.

Template Parameters

  config_element_t | The configuration element to add; must model seqan3::detail::config_element.

Parameters

  [in] | config_element | The configuration element to construct the configuration from.

## Member Function Documentation

## append()

template<detail::config_element... configs_t>
template<typename other_configuration_t>
requires (is_config_element_combineable_v<configs_t, std::remove_cvref_t<other_configuration_t>> && ...)

auto seqan3::configuration< configs_t >::append | ( | other_configuration_t && | other_config | ) | const

inline constexpr

Returns a new configuration by appending the given configuration to the current one.

Template Parameters

  other_configuration_t | Another configuration type or configuration element type; each configuration element must model seqan3::detail::config_element_pipeable_with each of the configurations elements of the current configuration.

Parameters

  [in] | other_config | The other configuration to append to the current one.

Returns
  A new configuration containing the appended configuration elements.

This function generates a new configuration object containing the appended configuration elements. The current configuration will not be modified.

## get_or()

template<detail::config_element... configs_t>
template<typename alternative_t>

decltype(auto) seqan3::configuration< configs_t >::get_or | ( | alternative_t && | alternative | ) | &

inline constexpr noexcept

Returns the stored configuration element if present otherwise the given alternative.

Template Parameters

  alternative_t | The type of the configuration element that is queried.

Parameters

  [in] | alternative | The alternative whose type is used to check for an existing configuration element.

Uses the type alternative_t of the given alternative to check if such an configuration element was already stored inside of the configuration. If no suitable candidate can be found the passed value alternative will be returned. If alternative_t is a class template, then any specialisation of this alternative type will be searched and returned if present.

Returns
  The stored configuration element identified by alternative_t or the alternative if not present.

### Example

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
#include <seqan3/core/configuration/configuration.hpp>
#include <seqan3/core/configuration/pipeable_config_element.hpp>
#include <seqan3/core/debug_stream.hpp>
// Initial setup used in the actual example:
enum struct my_id : int
{
bar_id,
foo_id
};
struct bar : private seqan3::pipeable_config_element
{
public:
float value{};
bar() = default;
bar(bar const &) = default;
bar(bar &&) = default;
bar & operator=(bar const &) = default;
bar & operator=(bar &&) = default;
~bar() = default;
bar(float v) : value{v}
{}
static constexpr my_id id{my_id::bar_id};
};
template <typename t>
class foo : private seqan3::pipeable_config_element
{
public:
t value{};
foo() = default;
foo(foo const &) = default;
foo(foo &&) = default;
foo & operator=(foo const &) = default;
foo & operator=(foo &&) = default;
~foo() = default;
foo(t v) : value{std::move(v)}
{}
static constexpr my_id id{my_id::foo_id};
};
template <typename t>
foo(t) -> foo<t>;
int main()
{
seqan3::configuration my_cfg{foo{1}}; // Only foo<int> is present.
seqan3::debug_stream << my_cfg.get_or(foo{std::string{"hello"}}).value << '\n'; // finds foo<int> -> prints: 1
seqan3::debug_stream << my_cfg.get_or(bar{2.4}).value << '\n'; // bar not present -> prints: 2.4
}
std::string
seqan3::configuration
Collection of elements to configure an algorithm.
Definition configuration.hpp:42
seqan3::configuration::get_or
constexpr decltype(auto) get_or(alternative_t &&alternative) &noexcept
Returns the stored configuration element if present otherwise the given alternative.
Definition configuration.hpp:117
configuration.hpp
Provides seqan3::configuration and utility functions.
debug_stream.hpp
Provides seqan3::debug_stream and related types.
seqan3::debug_stream
debug_stream_type debug_stream
A global instance of seqan3::debug_stream_type.
Definition debug_stream.hpp:38
pipeable_config_element.hpp
Provides seqan3::pipeable_config_element.
seqan3::pipeable_config_element
Adds pipe interface to configuration elements.
Definition pipeable_config_element.hpp:29

### Exception

no-throw guarantee.

### Complexity

Constant time.

## remove()

template<detail::config_element... configs_t>
template<typename query_t>
requires (exists<query_t>())

auto seqan3::configuration< configs_t >::remove | ( |  | ) | const

inline nodiscard constexpr

Remove a config element from the configuration.

Template Parameters

  query_t | The config element type to remove from the configuration.

Returns
  A new configuration object without the config element identified by query_t.

## Friends And Related Symbol Documentation

## operator|()

template<typename lhs_config_t, typename rhs_config_t>

auto operator| | ( | lhs_config_t && | lhs,
|  | rhs_config_t && | rhs )

related

Combines two configurations and/or configuration elements forming a new seqan3::configuration.

Template Parameters

  lhs_config_t | The type of the left hand side operand; the seqan3::is_config_element_combineable_v variable template must evaluate to true for both operand types.
  rhs_config_t | The type of the right hand side operand; the seqan3::is_config_element_combineable_v variable template must evaluate to true for both operand types.

Parameters

  [in] | lhs | The left hand operand.
  [in] | rhs | The right hand operand.

Returns
  A new seqan3::configuration containing lhs and rhs.

The two operands can be either a seqan3::configuration object or a seqan3::detail::config_element. The right hand side operand is then appended to the left hand side operand by creating a new seqan3::configuration object. Neither lhs nor rhs will be modified.

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

- configuration.hpp

Hide me