67 class constexpr_pseudo_bitset :
public std::array<bool, N>
71 using base_t = std::array<bool, N>;
77 constexpr constexpr_pseudo_bitset
operator|(constexpr_pseudo_bitset rhs)
const noexcept
79 for (
size_t i = 0; i < N; ++i)
80 rhs[i] = rhs[i] || base_t::operator[](i);
82 return std::move(rhs);
85 constexpr constexpr_pseudo_bitset operator~() const noexcept
87 constexpr_pseudo_bitset ret{};
88 for (
size_t i = 0; i < N; ++i)
89 ret[i] = !base_t::operator[](i);
107 template <
char op,
typename condition_head_t,
typename ...condition_ts>
110 constexpr_string{
"("} +
111 (condition_head_t::msg + ... +
112 (constexpr_string{
" "} + constexpr_string{{op, op,
'\0'}} + constexpr_string{
" "} + condition_ts::msg)) +
113 constexpr_string{
")"}
121 template <
typename condition_t>
122 class parse_condition_base;
134 template <
typename condition_t>
136 concept parse_condition_concept = requires
139 requires std::is_base_of_v<parse_condition_base<remove_cvref_t<condition_t>>,
140 remove_cvref_t<condition_t>>;
142 std::remove_reference_t<condition_t>::msg;
145 { constexpr_string<0>{} + std::remove_reference_t<condition_t>::msg } ->
146 decltype(std::remove_reference_t<condition_t>::msg);
196 template <
typename char_type>
197 inline std::string make_printable(char_type
const c)
201 case '\0':
return "'\\0'";
202 case '\t':
return "'\\t'";
203 case '\n':
return "'\\n'";
204 case '\v':
return "'\\v'";
205 case '\f':
return "'\\f'";
206 case '\r':
return "'\\r'";
207 case static_cast<char>(127):
return "'DEL'";
210 if ((c >= static_cast<char>(1) && c <= static_cast<char>(8)) ||
211 (c >=
static_cast<char>(14) && c <= static_cast<char>(31)))
214 return {
'\'', c,
'\''};
224 template <parse_condition_concept... condition_ts>
225 requires
sizeof...(condition_ts) >= 2
226 struct parse_condition_combiner;
228 template <parse_condition_concept condition_t>
229 struct parse_condition_negator;
238 template <
typename derived_t>
239 class parse_condition_base
250 constexpr parse_condition_base() =
default;
251 constexpr parse_condition_base(parse_condition_base
const &) =
default;
252 constexpr parse_condition_base(parse_condition_base &&) =
default;
253 constexpr parse_condition_base & operator=(parse_condition_base
const &) =
default;
254 constexpr parse_condition_base & operator=(parse_condition_base &&) =
default;
255 ~parse_condition_base() =
default;
259 using data_t = constexpr_pseudo_bitset<257>;
265 template <parse_condition_concept rhs_t>
267 constexpr
auto operator||(rhs_t
const &)
const 269 return parse_condition_combiner<derived_t, rhs_t>{};
273 constexpr
auto operator!()
const 275 return parse_condition_negator<derived_t>{};
282 template <std::Integral value_t>
284 constexpr
bool operator()(value_t
const val)
const noexcept
285 requires
sizeof(value_t) == 1
287 return derived_t::data[
static_cast<unsigned char>(val)];
289 template <std::Integral value_t>
290 constexpr
bool operator()(value_t
const val)
const noexcept
291 requires
sizeof(value_t) != 1
293 return (
static_cast<std::make_unsigned_t<value_t>
>(val) < 256) ?
operator()(
static_cast<uint8_t
>(val)) :
294 (
static_cast<decltype(EOF)
>(val) == EOF) ? derived_t::data[256] :
false;
301 std::string message()
const 304 return derived_t::msg.string();
319 template <parse_condition_concept... condition_ts>
321 requires
sizeof...(condition_ts) >= 2
323 struct parse_condition_combiner :
public parse_condition_base<parse_condition_combiner<condition_ts...>>
329 using base_t = parse_condition_base<parse_condition_combiner<condition_ts...>>;
332 using typename base_t::data_t;
334 static constexpr data_t data = (condition_ts::data | ...);
343 template <parse_condition_concept condition_t>
344 struct parse_condition_negator :
public parse_condition_base<parse_condition_negator<condition_t>>
347 static constexpr
auto msg = constexpr_string{
'!'} + condition_t::msg;
350 using base_t = parse_condition_base<parse_condition_negator<condition_t>>;
353 using typename base_t::data_t;
355 static constexpr data_t data = ~condition_t::data;
370 template <u
int8_t
interval_first, u
int8_t
interval_last>
372 requires interval_first <= interval_last
374 struct is_in_interval_type :
public parse_condition_base<is_in_interval_type<interval_first, interval_last>>
377 static constexpr constexpr_string msg = constexpr_string{
"is_in_interval<'"} +
378 constexpr_string{interval_first} +
379 constexpr_string{
"', '"} +
380 constexpr_string{interval_last} +
381 constexpr_string{
"'>"};
384 using base_t = parse_condition_base<is_in_interval_type<interval_first, interval_last>>;
387 using typename base_t::data_t;
389 static constexpr data_t data = [] () constexpr
393 for (uint8_t i = interval_first; i <= interval_last; ++i)
409 template <alphabet_concept alphabet_t>
410 struct is_in_alphabet_type :
public parse_condition_base<is_in_alphabet_type<alphabet_t>>
414 static constexpr std::array<unsigned char, 256>
to_upper = [] () constexpr
416 std::array<unsigned char, 256> ret{};
418 for (
size_t i = 0; i < 256; ++i)
421 for (
size_t i =
'a'; i <=
'z'; ++i)
422 ret[i] = i -
'a' +
'A';
429 static constexpr
auto msg = constexpr_string{
"is_in_alphabet<"} +
430 constexpr_string{detail::get_display_name_v<alphabet_t>} +
431 constexpr_string{
">"};
434 using base_t = parse_condition_base<is_in_alphabet_type<alphabet_t>>;
437 using typename base_t::data_t;
439 static constexpr data_t data = [] () constexpr
443 for (
unsigned char i = 0; i < 255; ++i)
459 template <
int char_v>
460 struct is_char_type :
public parse_condition_base<is_char_type<char_v>>
462 static_assert(char_v == EOF || static_cast<uint64_t>(char_v) < 256,
"TODO");
465 static constexpr
auto msg = constexpr_string{
"is_char<'"} +
466 constexpr_string{char_v} +
467 constexpr_string(
"'>");
472 using base_t = parse_condition_base<is_char_type<char_v>>;
475 using typename base_t::data_t;
477 static constexpr data_t data = [] () constexpr
484 ret[
static_cast<uint8_t
>(char_v)] =
true;
A constexpr string implementation to manipulate string literals at compile time.
Provides exceptions used in the I/O module.
Specifies whether the given callable is std::RegularInvocable and returns bool.
Meta-header for the alphabet module.
Definition: aligned_sequence_concept.hpp:288
Provides various metafunctions on generic types.
auto operator|(validator1_type &&vali1, validator2_type &&vali2)
Enables the chaining of validators. !
Definition: validators.hpp:671
constexpr char_type to_upper(char_type const c) noexcept
Converts 'a'-'z' to 'A'-'Z' respectively; other characters are returned as is.
Definition: char_operations.hpp:123
constexpr alphabet_type & assign_char(alphabet_type &alph, underlying_char_t< alphabet_type > const chr) requires requires(alphabet_type alph)
Implementation of seqan3::alphabet_concept::assign_char() that delegates to a member function...
Definition: member_exposure.hpp:178
constexpr_string constexpr condition_message_v
Defines a compound seqan3::constexpr_string consisting of all given conditions separated by the opera...
Definition: parse_condition_detail.hpp:109
Static reflection for arbitrary types.
constexpr underlying_char_t< alphabet_type > to_char(alphabet_type const alph) requires requires(alphabet_type alph)
Implementation of seqan3::alphabet_concept::to_char() that delegates to a member function.
Definition: member_exposure.hpp:165