Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/replace__impl_8hpp_source.html below:

NCBI C++ ToolKit: include/util/regexp/ctre/replace_impl.hpp Source File

<

_CharType,

N>

<

_CharType,

N>

<

_CharType,

N>

<

_CharType,

N>

<

len>

constexpr

(

begin, std::integral_constant<size_t, len>)

<

...Is>

std::array<_CharType,

...(Is)>

= {_CharType(

[begin + Is].detail) ... };

pos_output = 0;

pos_input = 0;

( pos_input <

.size() )

_CharType next_c =

[pos_input++];

(pos_input ==

.size() && (next_c ==

next_c ==

)) {

(next_c ==

) {

(next_c ==

) {

(

= 0;

<

; ++

) {

next_c =

[pos_input +

- 1];

_CharType current =

[dollar_pos];

_CharType need_braces = 0;

(current < '0' || current >

)

_begin = dollar_pos;

_end = _begin;

(_end <

.size() &&

[_end] != need_braces)

(_end <

.size() &&

[_end]>=

&&

[_end]<=

)

((_end ==

.size() && need_braces) || _begin == _end)

group_number = -1;

(need_braces == 0 || need_braces ==

)

(need_braces && group_number < 0) {

_len = _end - _begin;

(need_braces == 0)

(_end - _begin > 4)

(_begin != _end) {

c =

[_begin++];

(c < '0' || c >

)

<

_CharType,

N>

<

_CharType,

N>

<

_CharType,

N>

<

_CharType,

N, const compiled_regex<_CharType, N>& compiled>

constexpr (compiled.real_size() == 0) {

x_build_next_action<0>(std::make_tuple());

<

begin,

...TArgs>

constexpr (begin >= compiled.real_size()) {

constexpr

=

.detail;

newcode = std::make_tuple(op);

res = std::tuple_cat(tup, newcode);

x_build_next_action<begin+1+len>(res);

static_assert(__cpp_nontype_template_args <= 201411L,

);

constexpr

next_end = compiled.find_end_string(begin);

newcode = std::make_tuple(compiled.extract_string(begin, std::integral_constant<size_t, next_end-begin>{}));

res = std::tuple_cat(tup, newcode);

x_build_next_action<next_end>(res);

res = std::tuple_cat(tup, newcode);

x_build_next_action<begin+1>(res);

constexpr (ct::inline_bitset<

newcode = std::make_tuple(

.cmd);

res = std::tuple_cat(tup, newcode);

x_build_next_action<begin+1>(res);

<ct_fixed_

_input_param input>

static_assert (

.error_pos() == 0);

<ct_fixed_

_input_param input>

<ct_fixed_

_input_param input>

constexpr

= build_replace_runtime_actions<input>();

static_assert(

>0);

build_replace_runtime_actions<input>();

<

_Context,

...TArgs>

x_apply_all<0>(

,

);

<

_Context,

N = 0>

std::basic_string_view subst = x_get_substitute<N>(

,

);

<

,

_Context,

...TArgs>

constexpr (

<

)

constexpr

& op = std::get<N>(

);

std::basic_string_view<char_type> subst = x_get_substitute<N>(

, op);

x_apply_all<N+1>(

,

);

<

pos,

_Context,

...TArgs>

constexpr

&

= std::get<pos>(

);

x_get_substitute<pos>(

,

);

<

pos,

N,

_Context>

<

pos,

N,

_Context>

constexpr

&

= std::get<pos>(

);

.template get<

.m_name>();

<

pos,

_Context>

.template get<

.m_number>();

<

pos,

_Context>

std::basic_string_view<char_type>(

.begin,

.matched.begin());

std::basic_string_view<char_type>(

.matched.end(),

.end);

std::basic_string_view<char_type>(

.begin,

.end);

std::basic_string_view<char_type>{};

std::basic_string_view<char_type>{};

<

_Input,

= _Input>

<

...TArgs>

<

_T>

<

...TArgs>

<

_Input>

= std::basic_string_view<typename output_type::value_type, typename output_type::traits_type>;

static_assert(std::is_same_v<_Input, output_type> || std::is_constructible_v<output_type, _Input>);

<

_T=_Input,

= std::enable_if_t<std::is_constructible_v<output_type, const _T&>, _T>>

<

_Change,

= std::enable_if_t<std::is_assignable_v<output_type, _Change>>>

= std::forward<_Change>(new_value);

<

...TArgs>

<

...TArgs>

<

...TArgs>

<

_CharType>

typename std::decay_t< decltype(input)>::char_type char_type

static void apply_all(_Context &ctx, std::basic_string< char_type, TArgs... > &out)

static auto x_get_substitute(_Context &, const ct::fixed_string< char_type, N > &s)

static auto x_get_substitute(const _Context &ctx, const e_action &)

static auto x_get_substitute(_Context &ctx, const std::tuple< TArgs... > &)

static void x_apply_all(_Context &ctx, std::basic_string< char_type, TArgs... > &out)

static auto x_get_substitute(_Context &ctx, const group_name_op< char_type, N > &)

static constexpr size_t size

static auto x_get_substitute(const _Context &ctx, const group_number_op &)

static auto get_substitute(_Context &ctx)

static constexpr auto runtime

static constexpr bool is_single_action

constexpr const parsed_str_type & parsed() const

static constexpr int x_try_parse_number(const input_array_type &input, size_t _begin, size_t _end)

constexpr size_t error_pos() const

constexpr size_t find_end_string(size_t begin) const

constexpr size_t real_size() const

static constexpr action_type x_parse_slash(_CharType c)

constexpr const action_type & operator[](size_t i) const

std::array< action_type, N > parsed_str_type

constexpr compiled_regex()=default

constexpr compiled_regex(const input_array_type &input)

constexpr auto x_extract_string(size_t begin, std::index_sequence< Is... >) const -> ct::fixed_string< _CharType, sizeof...(Is)>

constexpr void x_parse(const input_array_type &input)

static constexpr action_type x_parse_dollar(const input_array_type &input, size_t &dollar_pos)

constexpr auto extract_string(size_t begin, std::integral_constant< size_t, len >) const -> ct::fixed_string< _CharType, len >

compiled_regex(int, const _CharType(&input)[N+1])

const output_type & cref_type

mutable_string(mutable_string &&)=default

std::optional< output_type > m_modified

typename DeduceMutableString< _Input >::output_type output_type

mutable_string & operator=(mutable_string &&)=default

bool operator==(const _T &v) const

std::basic_string_view< typename output_type::value_type, typename output_type::traits_type > view_type

mutable_string(const mutable_string &)=default

mutable_string & operator=(const mutable_string &)=default

view_type to_view() const

mutable_string(input_type orig)

mutable_string & operator=(_Change &&new_value)

static vector< string > arr

std::ofstream out("events_result.xml")

main entry point for tests

#define test(a, b, c, d, e)

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

where boath are integers</td > n< td ></td > n</tr > n< tr > n< td > tse</td > n< td > optional</td > n< td > String</td > n< td class=\"description\"> TSE option controls what blob is orig

constexpr auto build_replace_runtime_actions()

mutable_string(const std::basic_string_view< TArgs... > &) -> mutable_string< std::basic_string_view< TArgs... >>

group_name_op(ct::fixed_string< _CharType, N >) -> group_name_op< _CharType, N >

compiled_regex(const _CharType(&)[N]) -> compiled_regex< _CharType, N-1 >

string_type::value_type char_type

The character type used by the parser.

const GenericPointer< typename T::ValueType > T2 value

static SLJIT_INLINE sljit_ins or(sljit_gpr dst, sljit_gpr src)

constexpr auto to_view() const -> std::basic_string_view< _CharType >

std::basic_string< TArgs... > output_type

std::basic_string< TArgs... > output_type

static constexpr auto build()

static constexpr auto x_build_next_action(const std::tuple< TArgs... > &tup)

static constexpr auto compiled

ct::fixed_string< _CharType, N > m_name

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4