Provides additional utility functionality used by multiple modules.
More...
|
Helper functions for tuple like objects.
|
template<size_t pivot_c, template< typename ... > typename tuple_t, typename ... ts> |
constexpr auto | seqan3::tuple_split (tuple_t< ts... > const &t) |
| Splits a tuple like data structure at the given position. More...
|
|
template<typename pivot_t , tuple_like tuple_t> |
constexpr auto | seqan3::tuple_split (tuple_t &&t) |
| Splits a tuple like data structure at the first position of the given type. More...
|
|
template<tuple_like tuple_t> |
constexpr auto | seqan3::tuple_pop_front (tuple_t &&t) |
| Removes the first element of a tuple. More...
|
|
template<size_t pivot_c, template< typename ... > typename tuple_t, typename ... ts> |
constexpr auto | seqan3::tuple_split (tuple_t< ts... > &&t) |
| Splits a tuple like data structure at the given position. More...
|
|
Provides additional utility functionality used by multiple modules.
The utility module contains concepts, functions, traits and classes that are independent of the remaining modules in SeqAn. These implementations are considered external functionality, i.e. they could have been outsourced into their own libraries.
The utility module has no dependency to any other module except the Core module.
◆ tuple_type_list_t
template<detail::tuple_size tuple_t>
◆ to_little_endian()
template<std::integral type>
constexpr type seqan3::detail::to_little_endian |
( |
type const |
in | ) |
|
|
constexprnoexcept |
Convert the byte encoding of integer values to little-endian byte order.
- Template Parameters
-
type | The type of the value to convert; must model std::integral. |
- Parameters
-
in | The input value to convert. |
- Returns
- the converted value in little-endian byte-order.
This function swaps the bytes if the host system uses big endian. In this case only 1, 2, 4, or 8 byte big integral types are allowed as input. On host systems with little endian this function is a no-op and returns the unchanged input value. Other systems with mixed endianness are not supported.
◆ tuple_pop_front()
template<tuple_like tuple_t>
constexpr auto seqan3::tuple_pop_front |
( |
tuple_t && |
t | ) |
|
|
constexpr |
Removes the first element of a tuple.
- Parameters
-
- Returns
- A new tuple without the first element of
t
.
Note, that the tuple must contain at least one element and must support empty tuple types, i.e. std::pair cannot be used.
Complexity
Linear in the number of elements.
Thread safety
Concurrent invocations of this functions are thread safe.
◆ tuple_split() [1/4]
template<typename pivot_t , tuple_like tuple_t>
constexpr auto seqan3::tuple_split |
( |
tuple_t && |
t | ) |
|
|
constexpr |
Splits a tuple like data structure at the first position of the given type.
- Template Parameters
-
pivot_t | A template type specifying the split position. |
- Parameters
-
[in] | t | The original tuple to split. |
- Returns
- A new tuple of tuples with the left side of the split and the right side of the split.
Splits a tuple into two tuples, while the element at the split position will be contained in the second tuple. Note, that the returned tuples can be empty. For this reason it is not possible to use tuple like objects, that cannot be empty, i.e. std::pair. Using such an object will emit an compiler error.
example
int main()
{
auto [
left,
right] = seqan3::tuple_split<2>(t);
auto [left1, right1] = seqan3::tuple_split<0>(t);
auto [left2, right2] = seqan3::tuple_split<4>(t);
}
Provides utility functions for tuple like interfaces.
Complexity
Linear in the number of elements.
Thread safety
Concurrent invocations of this functions are thread safe.
◆ tuple_split() [2/4]
template<size_t pivot_c, template< typename ... > typename tuple_t, typename ... ts>
constexpr auto seqan3::tuple_split |
( |
tuple_t< ts... > && |
t | ) |
|
|
constexpr |
Splits a tuple like data structure at the given position.
- Template Parameters
-
pivot_c | A template value specifying the split position. |
tuple_t | A template alias for a tuple like object. |
...ts | Types tuple_t is specified with. |
- Parameters
-
[in] | t | The original tuple to split. |
- Returns
- A new tuple of tuples with the left side of the split and the right side of the split.
Splits a tuple into two tuples, while the element at the split position will be contained in the second tuple. Note, that the returned tuples can be empty. For this reason it is not possible to use tuple like objects, that cannot be empty, i.e. std::pair. Using such an object will emit an compiler error.
example
int main()
{
auto [
left,
right] = seqan3::tuple_split<2>(t);
auto [left1, right1] = seqan3::tuple_split<0>(t);
auto [left2, right2] = seqan3::tuple_split<4>(t);
}
Complexity
Linear in the number of elements.
Thread safety
Concurrent invocations of this functions are thread safe.
◆ tuple_split() [3/4]
template<size_t pivot_c, template< typename ... > typename tuple_t, typename ... ts>
constexpr auto seqan3::tuple_split |
( |
tuple_t< ts... > const & |
t | ) |
|
|
constexpr |
Splits a tuple like data structure at the given position.
- Template Parameters
-
pivot_c | A template value specifying the split position. |
tuple_t | A template alias for a tuple like object. |
...ts | Types tuple_t is specified with. |
- Parameters
-
[in] | t | The original tuple to split. |
- Returns
- A new tuple of tuples with the left side of the split and the right side of the split.
Splits a tuple into two tuples, while the element at the split position will be contained in the second tuple. Note, that the returned tuples can be empty. For this reason it is not possible to use tuple like objects, that cannot be empty, i.e. std::pair. Using such an object will emit an compiler error.
example
int main()
{
auto [
left,
right] = seqan3::tuple_split<2>(t);
auto [left1, right1] = seqan3::tuple_split<0>(t);
auto [left2, right2] = seqan3::tuple_split<4>(t);
}
Complexity
Linear in the number of elements.
Thread safety
Concurrent invocations of this functions are thread safe.
◆ tuple_split() [4/4]
template<size_t beg, template< typename ... > typename tuple_t, size_t ... Is, typename ... ts>
constexpr auto seqan3::detail::tuple_split |
( |
tuple_t< ts... > const & |
t, |
|
|
std::index_sequence< Is... > const & |
idx |
|
) |
| |
|
constexpr |
Helper function for seqan3::tuple_split.
- Template Parameters
-
beg | A template value containing the start position from where to extract the values. |
tuple_t | A template alias for a tuple like object. |
...ts | Types tuple_t is specified with. |
...Is | Indices of the tuple elements that should be extracted. |
- Parameters
-
[in] | t | The original tuple to split. |
[in] | idx | An std::index_sequence with all indices that should be extracted beginning at beg . |
- Returns
- A new tuple with the extracted elements.
◆ bits_of
template<typename type_t >
constexpr auto seqan3::detail::bits_of = min_viable_uint_v<CHAR_BIT * sizeof(type_t)> |
|
constexpr |
How many bits has a type?
- Template Parameters
-
type_t | The type to determine the number of bits. |