Function parse_format_string

include/fmt/core.h:2262–2307

template <bool IS_CONSTEXPR, typename Char, typename Handler>
FMT_CONSTEXPR FMT_INLINE void parse_format_string(basic_string_view<Char> format_str, Handler&& handler) {
    auto begin = format_str.data();
    auto end = begin + format_str.size();
    if (end - begin < 32) {
        // Use a simple loop instead of memchr for small strings.
        const Char* p = begin;
        while (p != end) {
            auto c = *p++;
            if (c == '{') {
                handler.on_text(begin, p - 1);
                begin = p = parse_replacement_field(p - 1, end, handler);
            } else if (c == '}') {
                if (p == end || *p != '}') return handler.on_error("unmatched '}' in format string");
                handler.on_text(begin, p);
                begin = ++p;
            }
        }
        handler.on_text(begin, end);
        return;
    }

    struct writer {
            FMT_CONSTEXPR void operator()(const Char* from, const Char* to) {
                if (from == to) return;
                for (;;) {
                    const Char* p = nullptr;
                    if (!find<IS_CONSTEXPR>(from, to, Char('}'), p)) return handler_.on_text(from, to);
                    ++p;
                    if (p == to || *p != '}') return handler_.on_error("unmatched '}' in format string");
                    handler_.on_text(from, p);
                    from = p + 1;
                }
            }

            Handler& handler_;
    } write = {handler};

    while (begin != end) {
        // Doing two passes with memchr (one for '{' and another for '}') is up to
        // 2.5x faster than the naive one-pass implementation on big format strings.
        const Char* p = begin;
        if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p)) return write(begin, end);
        write(begin, p);
        begin = parse_replacement_field(p, end, handler);
    }
}

template <typename T, bool = is_named_arg<T>::value> struct strip_named_arg {
        using type = T;