c4::basic_substring< C > Struct Template Reference

a non-owning string-view, consisting of a character pointer and a length. More...

#include <substr.hpp>

Classes
struct	first_of_any_result

Public Member Functions
Default construction and assignment
constexpr	basic_substring () noexcept
	basic_substring (basic_substring const &) noexcept=default
	basic_substring (basic_substring &&) noexcept=default
	basic_substring (std::nullptr_t) noexcept
basic_substring &	operator= (basic_substring const &) noexcept=default
basic_substring &	operator= (basic_substring &&) noexcept=default
basic_substring &	operator= (std::nullptr_t) noexcept
void	clear () noexcept
Construction and assignment from characters with the same type
template<size_t N>
constexpr	basic_substring (C(&s_)[N]) noexcept
	Construct from an array.
	basic_substring (C *s_, size_t len_) noexcept
	Construct from a pointer and length.
	basic_substring (C *beg_, C *end_) noexcept
	Construct from two pointers.
template<class CharPtr, typename std::enable_if< can_borrow_char_ptr< CharPtr, C >::value, int >::type = 0>
	basic_substring (CharPtr s_) noexcept
	Construct from a C-string (zero-terminated string).
template<size_t N>
void	assign (C(&s_)[N]) noexcept
	Assign from an array.
void	assign (C *s_, size_t len_) noexcept
	Assign from a pointer and length.
void	assign (C *beg_, C *end_) noexcept
	Assign from two pointers.
template<class CharPtr, typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type = 0>
void	assign (CharPtr s_) noexcept
	Assign from a C-string (zero-terminated string of type const C* or C*).
template<size_t N>
basic_substring &	operator= (C(&s_)[N]) noexcept
	Assign from an array.
template<class CharPtr, typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type = 0>
basic_substring &	operator= (CharPtr s_) noexcept
	Assign from a C-string (zero-terminated string of type const C* or C*).
Standard accessor methods
bool	has_str () const noexcept
bool	empty () const noexcept
bool	not_empty () const noexcept
size_t	size () const noexcept
iterator	begin () noexcept
iterator	end () noexcept
const_iterator	begin () const noexcept
const_iterator	end () const noexcept
C *	data () noexcept
C const *	data () const noexcept
C &	operator[] (size_t i) noexcept
C const &	operator[] (size_t i) const noexcept
C &	front () noexcept
C const &	front () const noexcept
C &	back () noexcept
C const &	back () const noexcept
Comparison methods
int	compare (C const c) const noexcept
int	compare (C const *that, size_t sz) const noexcept
template<class CharPtr>
auto	compare (CharPtr c_str) const noexcept -> typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type
template<class U>
int	compare (basic_substring< U > const that) const noexcept
bool	operator== (std::nullptr_t) const noexcept
bool	operator!= (std::nullptr_t) const noexcept
bool	operator== (C const c) const noexcept
bool	operator!= (C const c) const noexcept
bool	operator< (C const c) const noexcept
bool	operator> (C const c) const noexcept
bool	operator<= (C const c) const noexcept
bool	operator>= (C const c) const noexcept
template<class U>
bool	operator== (basic_substring< U > const that) const noexcept
template<class U>
bool	operator!= (basic_substring< U > const that) const noexcept
template<class U>
bool	operator< (basic_substring< U > const that) const noexcept
template<class U>
bool	operator> (basic_substring< U > const that) const noexcept
template<class U>
bool	operator<= (basic_substring< U > const that) const noexcept
template<class U>
bool	operator>= (basic_substring< U > const that) const noexcept
template<size_t N>
bool	operator== (const char(&arr)[N]) const noexcept
template<size_t N>
bool	operator!= (const char(&arr)[N]) const noexcept
template<size_t N>
bool	operator< (const char(&arr)[N]) const noexcept
template<size_t N>
bool	operator> (const char(&arr)[N]) const noexcept
template<size_t N>
bool	operator<= (const char(&arr)[N]) const noexcept
template<size_t N>
bool	operator>= (const char(&arr)[N]) const noexcept
template<class CharPtr>
auto	operator== (CharPtr c_str) const noexcept -> typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type
template<class CharPtr>
auto	operator!= (CharPtr c_str) const noexcept -> typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type
template<class CharPtr>
auto	operator< (CharPtr c_str) const noexcept -> typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type
template<class CharPtr>
auto	operator> (CharPtr c_str) const noexcept -> typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type
template<class CharPtr>
auto	operator<= (CharPtr c_str) const noexcept -> typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type
template<class CharPtr>
auto	operator>= (CharPtr c_str) const noexcept -> typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type
Sub-selection methods
bool	is_sub (ro_substr const that) const noexcept
	true if *this is a substring of that (ie, from the same buffer)
bool	is_super (ro_substr const that) const noexcept
	true if that is a substring of *this (ie, from the same buffer)
bool	overlaps (ro_substr const that) const noexcept
	true if there is overlap of at least one element between that and *this
basic_substring	sub (size_t first) const noexcept
	return [first,len[
basic_substring	sub (size_t first, size_t num) const noexcept
	return [first,first+num[.
basic_substring	range (size_t first, size_t last=npos) const noexcept
	return [first,last[.
basic_substring	first (size_t num) const noexcept
	return the first num elements: [0,num[
basic_substring	last (size_t num) const noexcept
	return the last num elements: [len-num,len[
basic_substring	offs (size_t left, size_t right) const noexcept
	offset from the ends: return [left,len-right[ ; ie, trim a number of characters from the left and right.
basic_substring	left_of (size_t pos) const noexcept
	return [0, pos[ .
basic_substring	left_of (size_t pos, bool include_pos) const noexcept
	return [0, pos+include_pos[ .
basic_substring	right_of (size_t pos) const noexcept
	return [pos+1, len[
basic_substring	right_of (size_t pos, bool include_pos) const noexcept
	return [pos+!include_pos, len[
basic_substring	left_of (ro_substr const subs) const noexcept
	given subs a substring of the current string, get the portion of the current string to the left of it
basic_substring	right_of (ro_substr const subs) const noexcept
	given subs a substring of the current string, get the portion of the current string to the right of it
Removing characters (trim()) / patterns (strip()) from the tips of the string
basic_substring	triml (const C c) const
	trim left
basic_substring	triml (ro_substr chars) const
	trim left ANY of the characters.
basic_substring	trimr (const C c) const
	trim the character c from the right
basic_substring	trimr (ro_substr chars) const
	trim right ANY of the characters
basic_substring	trim (const C c) const
	trim the character c left and right
basic_substring	trim (ro_substr const chars) const
	trim left and right ANY of the characters
basic_substring	stripl (ro_substr pattern) const
	remove a pattern from the left
basic_substring	stripr (ro_substr pattern) const
	remove a pattern from the right
Lookup methods
size_t	find (const C c, size_t start_pos=0) const
size_t	find (ro_substr pattern, size_t start_pos=0) const
size_t	count (const C c, size_t pos=0) const
	count the number of occurrences of c
size_t	count (ro_substr c, size_t pos=0) const
	count the number of occurrences of s
basic_substring	select (const C c, size_t pos=0) const
	get the substr consisting of the first occurrence of c after pos, or an empty substr if none occurs
basic_substring	select (ro_substr pattern, size_t pos=0) const
	get the substr consisting of the first occurrence of pattern after pos, or an empty substr if none occurs
first_of_any_result	first_of_any (ro_substr s0, ro_substr s1) const
first_of_any_result	first_of_any (ro_substr s0, ro_substr s1, ro_substr s2) const
first_of_any_result	first_of_any (ro_substr s0, ro_substr s1, ro_substr s2, ro_substr s3) const
first_of_any_result	first_of_any (ro_substr s0, ro_substr s1, ro_substr s2, ro_substr s3, ro_substr s4) const
template<class It>
first_of_any_result	first_of_any_iter (It first_span, It last_span) const
bool	begins_with (const C c) const noexcept
	true if the first character of the string is c
bool	begins_with (const C c, size_t num) const noexcept
	true if the first num characters of the string are c
bool	begins_with (ro_substr pattern) const noexcept
	true if the string begins with the given pattern
bool	begins_with_any (ro_substr chars) const noexcept
	true if the first character of the string is any of the given chars
bool	ends_with (const C c) const noexcept
	true if the last character of the string is c
bool	ends_with (const C c, const size_t num) const noexcept
	true if the last num characters of the string are c
bool	ends_with (ro_substr pattern) const noexcept
	true if the string ends with the given pattern
bool	ends_with_any (ro_substr chars) const noexcept
	true if the last character of the string is any of the given chars
size_t	first_of (const C c, size_t start=0) const
size_t	last_of (const C c, size_t start=npos) const
size_t	first_of (ro_substr chars, size_t start=0) const
size_t	last_of (ro_substr chars, size_t start=npos) const
size_t	first_not_of (const C c) const
size_t	first_not_of (const C c, size_t start) const
size_t	last_not_of (const C c) const
size_t	last_not_of (const C c, size_t start) const
size_t	first_not_of (ro_substr chars) const
size_t	first_not_of (ro_substr chars, size_t start) const
size_t	last_not_of (ro_substr chars) const
size_t	last_not_of (ro_substr chars, size_t start) const
Range lookup methods
basic_substring	pair_range (CC open, CC close) const
	get the range delimited by an open-close pair of characters.
basic_substring	pair_range_esc (CC open_close, CC escape=CC('\\'))
	get the range delimited by a single open-close character (eg, quotes).
basic_substring	pair_range_nested (CC open, CC close) const
	get the range delimited by an open-close pair of characters, with possibly nested occurrences.
basic_substring	unquoted () const
Path-like manipulation methods
basic_substring	basename (C sep=C('/')) const
basic_substring	dirname (C sep=C('/')) const
basic_substring	name_wo_extshort () const
basic_substring	name_wo_extlong () const
basic_substring	extshort () const
basic_substring	extlong () const
Content-modification methods (only for non-const C)
template<typename U = C>
auto	toupper () -> typename std::enable_if< ! std::is_const< U >::value, void >::type
	convert the string to upper-case
template<typename U = C>
auto	tolower () -> typename std::enable_if< !std::is_const< U >::value, void >::type
	convert the string to lower-case
template<typename U = C>
auto	fill (C val) -> typename std::enable_if< !std::is_const< U >::value, void >::type
	fill the entire contents with the given val
template<typename U = C>
auto	copy_from (ro_substr that) -> typename std::enable_if< !std::is_const< U >::value, void >::type
	copy a string to this substr, starting at 0
template<typename U = C>
auto	copy_from (ro_substr that, size_t ifirst, size_t num=npos) -> typename std::enable_if< !std::is_const< U >::value, void >::type
	copy a string to this substr, starting at a specified given position
template<typename U = C>
auto	reverse () -> typename std::enable_if< !std::is_const< U >::value, void >::type
	reverse in place
template<typename U = C>
auto	reverse_sub (size_t ifirst, size_t num) -> typename std::enable_if< !std::is_const< U >::value, void >::type
	revert a subpart in place
template<typename U = C>
auto	reverse_range (size_t ifirst, size_t ilast) -> typename std::enable_if< !std::is_const< U >::value, void >::type
	revert a range in place
template<typename U = C>
auto	erase (size_t pos, size_t num) -> typename std::enable_if< !std::is_const< U >::value, basic_substring >::type
	erase part of the string.
template<typename U = C>
auto	erase_range (size_t first, size_t last) -> typename std::enable_if< !std::is_const< U >::value, basic_substring >::type
template<typename U = C>
auto	erase (ro_substr sub) -> typename std::enable_if< !std::is_const< U >::value, basic_substring >::type
	erase a part of the string.
template<typename U = C>
auto	replace (C value, C repl, size_t pos=0) -> typename std::enable_if< ! std::is_const< U >::value, size_t >::type
	replace every occurrence of character value with the character repl
template<typename U = C>
auto	replace (ro_substr chars, C repl, size_t pos=0) -> typename std::enable_if< ! std::is_const< U >::value, size_t >::type
	replace every occurrence of each character in value with the character repl.
size_t	replace_all (rw_substr dst, ro_substr pattern, ro_substr repl, size_t pos=0) const
	replace pattern with repl, and write the result into dst.

Public Attributes
C *	str
	a restricted pointer to the first character of the substring
size_t	len
	the length of the substring

Types
enum	: size_t { npos = (size_t)-1 , NONE = (size_t)-1 }
using	CC = typename std::add_const<C>::type
	CC=const char.
using	NCC_ = typename std::remove_const<C>::type
	NCC_=non const char.
using	ro_substr = basic_substring<CC>
using	rw_substr = basic_substring<NCC_>
using	value_type = C
using	char_type = C
using	size_type = size_t
using	iterator = C*
using	const_iterator = CC*
template<class U = C>
	operator typename std::enable_if<!std::is_const< U >::value, ro_substr const & >::type () const noexcept
	convert automatically from substr (of C) to csubstr (of const C)

Splitting methods
using	split_proxy = split_proxy_impl
bool	next_split (C sep, size_t *start_pos, basic_substring *out) const
	returns true if the string has not been exhausted yet, meaning it's ok to call next_split() again.
split_proxy	split (C sep, size_t start_pos=0) const
	a view into the splits
basic_substring	pop_right (C sep=C('/'), bool skip_empty=false) const
	pop right: return the first split from the right.
basic_substring	pop_left (C sep=C('/'), bool skip_empty=false) const
	return the first split from the left.
basic_substring	gpop_left (C sep=C('/'), bool skip_empty=false) const
	greedy pop left.
basic_substring	gpop_right (C sep=C('/'), bool skip_empty=false) const
	greedy pop right.

Number-matching query methods
bool	is_number () const
bool	is_real () const
bool	is_integer () const
bool	is_unsigned_integer () const
basic_substring	first_non_empty_span () const
	get the first span consisting exclusively of non-empty characters
basic_substring	first_uint_span () const
	get the first span which can be interpreted as an unsigned integer
basic_substring	first_int_span () const
	get the first span which can be interpreted as a signed integer
basic_substring	_first_integral_span (size_t skip_start) const
basic_substring	first_real_span () const
	get the first span which can be interpreted as a real (floating-point) number
basic_substring	_word_follows (size_t pos, csubstr word) const noexcept
basic_substring	_first_real_span_dec (size_t pos) const noexcept
basic_substring	_first_real_span_hex (size_t pos) const noexcept
basic_substring	_first_real_span_bin (size_t pos) const noexcept
basic_substring	_first_real_span_oct (size_t pos) const noexcept
static constexpr C4_CONST bool	_is_delim_char (char c) noexcept
	true if the character is a delimiter character at the end
static constexpr C4_CONST bool	_is_hex_char (char c) noexcept
	true if the character is in [0-9a-fA-F]

Detailed Description

template<class C>
struct c4::basic_substring< C >

a non-owning string-view, consisting of a character pointer and a length.

Note

The pointer is explicitly restricted.

See also

a quickstart sample in rapidyaml's documentation.

Definition at line 211 of file substr.hpp.

Member Typedef Documentation

CC

template<class C>

using c4::basic_substring< C >::CC = typename std::add_const<C>::type

CC=const char.

Definition at line 225 of file substr.hpp.

NCC_

template<class C>

using c4::basic_substring< C >::NCC_ = typename std::remove_const<C>::type

NCC_=non const char.

Definition at line 226 of file substr.hpp.

ro_substr

template<class C>

using c4::basic_substring< C >::ro_substr = basic_substring<CC>

Definition at line 228 of file substr.hpp.

rw_substr

template<class C>

using c4::basic_substring< C >::rw_substr = basic_substring<NCC_>

Definition at line 229 of file substr.hpp.

value_type

template<class C>

using c4::basic_substring< C >::value_type = C

Definition at line 231 of file substr.hpp.

char_type

template<class C>

using c4::basic_substring< C >::char_type = C

Definition at line 232 of file substr.hpp.

size_type

template<class C>

using c4::basic_substring< C >::size_type = size_t

Definition at line 233 of file substr.hpp.

iterator

template<class C>

using c4::basic_substring< C >::iterator = C*

Definition at line 235 of file substr.hpp.

const_iterator

template<class C>

using c4::basic_substring< C >::const_iterator = CC*

Definition at line 236 of file substr.hpp.

split_proxy

template<class C>

using c4::basic_substring< C >::split_proxy = split_proxy_impl

Definition at line 1909 of file substr.hpp.

Member Enumeration Documentation

anonymous enum

template<class C>

anonymous enum : size_t

Enumerator
npos
NONE

Definition at line 238 of file substr.hpp.

: size_t { npos = (size_t)-1, NONE = (size_t)-1 };

Constructor & Destructor Documentation

basic_substring() [1/8]

template<class C>

c4::basic_substring< C >::basic_substring ( )

inlineconstexprnoexcept

Definition at line 255 of file substr.hpp.

: str(), len() {}

Referenced by c4::basic_substring< C >::split_proxy_impl::split_iterator_impl::operator*(), and c4::basic_substring< C >::split_proxy_impl::split_iterator_impl::operator->().

basic_substring() [2/8]

template<class C>

c4::basic_substring< C >::basic_substring ( basic_substring< C > const & )

inlinedefaultnoexcept

basic_substring() [3/8]

template<class C>

c4::basic_substring< C >::basic_substring ( basic_substring< C > && )

inlinedefaultnoexcept

basic_substring() [4/8]

template<class C>

c4::basic_substring< C >::basic_substring ( std::nullptr_t )

inlinenoexcept

Definition at line 259 of file substr.hpp.

: str(nullptr), len(0) {}

basic_substring() [5/8]

template<class C>

template<size_t N>

c4::basic_substring< C >::basic_substring ( C(&) s_[N] )

inlineconstexprnoexcept

Construct from an array.

Warning

the input string need not be zero terminated, but the length is taken as if the string was zero terminated

Definition at line 278 of file substr.hpp.

: str(s_), len(N-1) {}

basic_substring() [6/8]

template<class C>

c4::basic_substring< C >::basic_substring ( C * s_, size_t len_ )

inlinenoexcept

Construct from a pointer and length.

Warning

the input string need not be zero terminated.

Definition at line 281 of file substr.hpp.

: str(s_), len(len_) { C4_ASSERT(str || !len_); }

basic_substring() [7/8]

template<class C>

c4::basic_substring< C >::basic_substring ( C * beg_, C * end_ )

inlinenoexcept

Construct from two pointers.

Warning

the end pointer MUST BE larger than or equal to the begin pointer

the input string need not be zero terminated

Definition at line 285 of file substr.hpp.

: str(beg_), len(static_cast<size_t>(end_ - beg_)) { C4_ASSERT(end_ >= beg_); }

basic_substring() [8/8]

template<class C>

template<class CharPtr, typename std::enable_if< can_borrow_char_ptr< CharPtr, C >::value, int >::type = 0>

c4::basic_substring< C >::basic_substring ( CharPtr s_ )

inlinenoexcept

Construct from a C-string (zero-terminated string).

Warning

the input string MUST BE zero terminated.

will call strlen()

Note

this overload uses SFINAE to prevent it from overriding the array ctor

See also

For a more detailed explanation on why the plain overloads cannot coexist, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html

Definition at line 293 of file substr.hpp.

: str(s_), len(s_ ? strlen(s_) : 0) {}

Member Function Documentation

operator typename std::enable_if<!std::is_const< U >::value, ro_substr const & >::type()

template<class C>

template<class U = C>

c4::basic_substring< C >::operator typename std::enable_if<!std::is_const< U >::value, ro_substr const & >::type ( ) const

inlinenoexcept

convert automatically from substr (of C) to csubstr (of const C)

Definition at line 242 of file substr.hpp.

    {
        return *(ro_substr const*)this; // don't call the str+len ctor because it does a check
    }

operator=() [1/5]

template<class C>

basic_substring & c4::basic_substring< C >::operator= ( basic_substring< C > const & )

inlinedefaultnoexcept

operator=() [2/5]

template<class C>

basic_substring & c4::basic_substring< C >::operator= ( basic_substring< C > && )

inlinedefaultnoexcept

operator=() [3/5]

template<class C>

basic_substring & c4::basic_substring< C >::operator= ( std::nullptr_t )

inlinenoexcept

Definition at line 263 of file substr.hpp.

{ str = nullptr; len = 0; return *this; }

clear()

template<class C>

void c4::basic_substring< C >::clear ( )

inlinenoexcept

Definition at line 265 of file substr.hpp.

{ str = nullptr; len = 0; }

assign() [1/4]

template<class C>

template<size_t N>

void c4::basic_substring< C >::assign ( C(&) s_[N] )

inlinenoexcept

Assign from an array.

Warning

the input string need not be zero terminated, but the length is taken as if the string was zero terminated

Definition at line 300 of file substr.hpp.

{ str = s_; len = (N-1); }

Referenced by c4::yml::NodeRef::operator=().

assign() [2/4]

template<class C>

void c4::basic_substring< C >::assign ( C * s_, size_t len_ )

inlinenoexcept

Assign from a pointer and length.

Warning

the input string need not be zero terminated.

Definition at line 303 of file substr.hpp.

{ str = s_; len = len_; C4_ASSERT(str || !len_); }

assign() [3/4]

template<class C>

void c4::basic_substring< C >::assign ( C * beg_, C * end_ )

inlinenoexcept

Assign from two pointers.

Warning

the end pointer MUST BE larger than or equal to the begin pointer

the input string need not be zero terminated.

Definition at line 307 of file substr.hpp.

{ C4_ASSERT(end_ >= beg_); str = beg_; len = static_cast<size_t>(end_ - beg_); }

assign() [4/4]

template<class C>

template<class CharPtr, typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type = 0>

void c4::basic_substring< C >::assign ( CharPtr s_ )

inlinenoexcept

Assign from a C-string (zero-terminated string of type const C* or C*).

Warning

the input string must be zero terminated.

will call strlen()

Note

this overload uses SFINAE to prevent it from overriding the array assignment

See also

For a more detailed explanation on why the plain pointer overloads cannot coexist with the array overloads, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html

Definition at line 315 of file substr.hpp.

    {
        // the SFINAE is catching const types, so that on calls like
        // s.assign(const char*) we can do a static_assert, and so
        // the user will see an informative error message
        static_assert(can_borrow_char_ptr<CharPtr, C>::value, "string pointer is not mutable");
        str = s_;
        len = (s_ ? strlen(s_) : 0);
    }

operator=() [4/5]

template<class C>

template<size_t N>

basic_substring & c4::basic_substring< C >::operator= ( C(&) s_[N] )

inlinenoexcept

Assign from an array.

Warning

the input string need not be zero terminated.

Definition at line 329 of file substr.hpp.

{ str = s_; len = (N-1); return *this; }

operator=() [5/5]

template<class C>

template<class CharPtr, typename std::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type = 0>

basic_substring & c4::basic_substring< C >::operator= ( CharPtr s_ )

inlinenoexcept

Assign from a C-string (zero-terminated string of type const C* or C*).

Warning

the input string MUST BE zero terminated.

will call strlen()

Note

this overload uses SFINAE to prevent it from overriding the array assignment

See also

For a more detailed explanation on why the plain pointer overloads cannot coexist with the array overloads, see http://cplusplus.bordoon.com/specializeForCharacterArrays.html

Definition at line 337 of file substr.hpp.

    {
        // the SFINAE is catching const types, so that on calls like
        // substr(const char*) we can do a static_assert, and so
        // the user will see an informative error message
        static_assert(can_borrow_char_ptr<CharPtr, C>::value, "string pointer is not mutable");
        str = s_;
        len = s_ ? strlen(s_) : 0;
        return *this;
    }

has_str()

template<class C>

bool c4::basic_substring< C >::has_str ( ) const

inlinenoexcept

Definition at line 355 of file substr.hpp.

{ return ! empty() && str[0] != C(0); }

empty()

template<class C>

bool c4::basic_substring< C >::empty ( ) const

inlinenoexcept

Definition at line 356 of file substr.hpp.

{ return (len == 0 || str == nullptr); }

Referenced by c4::yml::Tree::add_tag_directive(), c4::basic_substring< CC >::first_int_span(), c4::basic_substring< CC >::first_real_span(), c4::basic_substring< CC >::first_uint_span(), c4::yml::location_format(), c4::yml::location_format_with_context(), c4::yml::Tree::lookup_path(), c4::basic_substring< CC >::replace_all(), sample_error_basic(), sample_error_parse(), sample_error_visit(), sample_fundamental_types(), sample_quick_overview(), sample_tree_arena(), c4::to_csubstr(), and c4::to_substr().

not_empty()

template<class C>

bool c4::basic_substring< C >::not_empty ( ) const

inlinenoexcept

Definition at line 357 of file substr.hpp.

{ return (len != 0 && str != nullptr); }

size()

template<class C>

size_t c4::basic_substring< C >::size ( ) const

inlinenoexcept

Definition at line 358 of file substr.hpp.

{ return len; }

Referenced by c4::catrs_append(), c4::catseprs_append(), c4::yml::emitrs_json(), c4::yml::emitrs_yaml(), c4::formatrs_append(), c4::basic_substring< C >::split_proxy_impl::split_iterator_impl::operator==(), c4::basic_substring< CC >::replace_all(), sample_formatting(), sample_substr(), and sample_tree_arena().

begin() [1/2]

template<class C>

iterator c4::basic_substring< C >::begin ( )

inlinenoexcept

Definition at line 360 of file substr.hpp.

{ return str; }

Referenced by c4::atoi_first(), c4::atou_first(), c4::from_chars(), c4::basic_substring< CC >::replace_all(), IntsResult::reset_yaml(), and c4::to_chars().

end() [1/2]

template<class C>

iterator c4::basic_substring< C >::end ( )

inlinenoexcept

Definition at line 361 of file substr.hpp.

{ return str + len; }

Referenced by c4::atod_first(), c4::atof_first(), c4::atoi_first(), c4::atou_first(), c4::from_chars(), c4::from_chars_first(), c4::from_chars_first(), c4::basic_substring< CC >::replace_all(), IntsResult::reset_yaml(), and c4::to_chars().

begin() [2/2]

template<class C>

const_iterator c4::basic_substring< C >::begin ( ) const

inlinenoexcept

Definition at line 363 of file substr.hpp.

{ return str; }

end() [2/2]

template<class C>

const_iterator c4::basic_substring< C >::end ( ) const

inlinenoexcept

Definition at line 364 of file substr.hpp.

{ return str + len; }

data() [1/2]

template<class C>

C * c4::basic_substring< C >::data ( )

inlinenoexcept

Definition at line 366 of file substr.hpp.

{ return str; }

Referenced by c4::basic_substring< C >::split_proxy_impl::split_iterator_impl::operator==(), sample_substr(), and sample_tree_arena().

data() [2/2]

template<class C>

C const * c4::basic_substring< C >::data ( ) const

inlinenoexcept

Definition at line 367 of file substr.hpp.

{ return str; }

operator[]() [1/2]

template<class C>

C & c4::basic_substring< C >::operator[] ( size_t i )

inlinenoexcept

Definition at line 369 of file substr.hpp.

{ C4_ASSERT(i >= 0 && i < len); return str[i]; }

operator[]() [2/2]

template<class C>

C const & c4::basic_substring< C >::operator[] ( size_t i ) const

inlinenoexcept

Definition at line 370 of file substr.hpp.

{ C4_ASSERT(i >= 0 && i < len); return str[i]; }

front() [1/2]

template<class C>

C & c4::basic_substring< C >::front ( )

inlinenoexcept

Definition at line 372 of file substr.hpp.

{ C4_ASSERT(len > 0 && str != nullptr); return *str; }

front() [2/2]

template<class C>

C const & c4::basic_substring< C >::front ( ) const

inlinenoexcept

Definition at line 373 of file substr.hpp.

{ C4_ASSERT(len > 0 && str != nullptr); return *str; }

back() [1/2]

template<class C>

C & c4::basic_substring< C >::back ( )

inlinenoexcept

Definition at line 375 of file substr.hpp.

{ C4_ASSERT(len > 0 && str != nullptr); return *(str + len - 1); }

Referenced by sample_substr().

back() [2/2]

template<class C>

C const & c4::basic_substring< C >::back ( ) const

inlinenoexcept

Definition at line 376 of file substr.hpp.

{ C4_ASSERT(len > 0 && str != nullptr); return *(str + len - 1); }

compare() [1/4]

template<class C>

int c4::basic_substring< C >::compare ( C const c ) const

inlinenoexcept

Definition at line 385 of file substr.hpp.

    {
        C4_XASSERT((str != nullptr) || len == 0);
        if C4_LIKELY(str != nullptr && len > 0)
            return (*str != c) ? *str - c : (static_cast<int>(len) - 1);
        else
            return -1;
    }

Referenced by c4::operator!=(), c4::operator!=(), c4::operator!=(), c4::operator!=(), c4::operator!=(), c4::operator!=(), c4::operator!=(), c4::operator!=(), c4::operator<(), c4::operator<(), c4::operator<(), c4::operator<(), c4::operator<(), c4::operator<(), c4::operator<(), c4::operator<(), c4::operator<=(), c4::operator<=(), c4::operator<=(), c4::operator<=(), c4::operator<=(), c4::operator<=(), c4::operator<=(), c4::operator<=(), c4::operator==(), c4::operator==(), c4::operator==(), c4::operator==(), c4::operator==(), c4::operator==(), c4::operator==(), c4::operator==(), c4::operator>(), c4::operator>(), c4::operator>(), c4::operator>(), c4::operator>(), c4::operator>(), c4::operator>(), c4::operator>(), c4::operator>=(), c4::operator>=(), c4::operator>=(), c4::operator>=(), c4::operator>=(), c4::operator>=(), c4::operator>=(), and c4::operator>=().

compare() [2/4]

template<class C>

int c4::basic_substring< C >::compare ( C const * that, size_t sz ) const

inlinenoexcept

Definition at line 394 of file substr.hpp.

    {
        C4_SUPPRESS_WARNING_GCC_PUSH
        #if defined(__GNUC__) && (__GNUC__ >= 6)
        C4_SUPPRESS_WARNING_GCC("-Wnull-dereference")
        #endif
        C4_XASSERT(that || sz  == 0);
        C4_XASSERT(str  || len == 0);
        if C4_LIKELY(str && that)
        {
            {
                const size_t min = len < sz ? len : sz;
                for(size_t i = 0; i < min; ++i)
                    if(str[i] != that[i])
                        return str[i] < that[i] ? -1 : 1;
            }
            if(len < sz)
                return -1;
            else if(len == sz)
                return 0;
            else
                return 1;
        }
        else if(len == sz)
        {
            C4_XASSERT(len == 0 && sz == 0);
            return 0;
        }
        return len < sz ? -1 : 1;
        C4_SUPPRESS_WARNING_GCC_POP
    }

compare() [3/4]

template<class C>

template<class CharPtr>

auto c4::basic_substring< C >::compare ( CharPtr c_str ) const->typenamestd::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type

inlinenoexcept

Definition at line 427 of file substr.hpp.

    {
        return compare(c_str, strlen(c_str));
    }

compare() [4/4]

template<class C>

template<class U>

int c4::basic_substring< C >::compare ( basic_substring< U > const that ) const

inlinenoexcept

Definition at line 434 of file substr.hpp.

    {
        return this->compare(that.str, that.len);
    }

operator==() [1/5]

template<class C>

bool c4::basic_substring< C >::operator== ( std::nullptr_t ) const

inlinenoexcept

Definition at line 439 of file substr.hpp.

{ return str == nullptr; }

operator!=() [1/5]

template<class C>

bool c4::basic_substring< C >::operator!= ( std::nullptr_t ) const

inlinenoexcept

Definition at line 440 of file substr.hpp.

{ return str != nullptr; }

operator==() [2/5]

template<class C>

bool c4::basic_substring< C >::operator== ( C const c ) const

inlinenoexcept

Definition at line 442 of file substr.hpp.

{ return this->compare(c) == 0; }

operator!=() [2/5]

template<class C>

bool c4::basic_substring< C >::operator!= ( C const c ) const

inlinenoexcept

Definition at line 443 of file substr.hpp.

{ return this->compare(c) != 0; }

operator<() [1/4]

template<class C>

bool c4::basic_substring< C >::operator< ( C const c ) const

inlinenoexcept

Definition at line 444 of file substr.hpp.

{ return this->compare(c) <  0; }

operator>() [1/4]

template<class C>

bool c4::basic_substring< C >::operator> ( C const c ) const

inlinenoexcept

Definition at line 445 of file substr.hpp.

{ return this->compare(c) >  0; }

operator<=() [1/4]

template<class C>

bool c4::basic_substring< C >::operator<= ( C const c ) const

inlinenoexcept

Definition at line 446 of file substr.hpp.

{ return this->compare(c) <= 0; }

operator>=() [1/4]

template<class C>

bool c4::basic_substring< C >::operator>= ( C const c ) const

inlinenoexcept

Definition at line 447 of file substr.hpp.

{ return this->compare(c) >= 0; }

operator==() [3/5]

template<class C>

template<class U>

bool c4::basic_substring< C >::operator== ( basic_substring< U > const that ) const

inlinenoexcept

Definition at line 449 of file substr.hpp.

{ return this->compare(that) == 0; }

operator!=() [3/5]

template<class C>

template<class U>

bool c4::basic_substring< C >::operator!= ( basic_substring< U > const that ) const

inlinenoexcept

Definition at line 450 of file substr.hpp.

{ return this->compare(that) != 0; }

operator<() [2/4]

template<class C>

template<class U>

bool c4::basic_substring< C >::operator< ( basic_substring< U > const that ) const

inlinenoexcept

Definition at line 451 of file substr.hpp.

{ return this->compare(that) <  0; }

operator>() [2/4]

template<class C>

template<class U>

bool c4::basic_substring< C >::operator> ( basic_substring< U > const that ) const

inlinenoexcept

Definition at line 452 of file substr.hpp.

{ return this->compare(that) >  0; }

operator<=() [2/4]

template<class C>

template<class U>

bool c4::basic_substring< C >::operator<= ( basic_substring< U > const that ) const

inlinenoexcept

Definition at line 453 of file substr.hpp.

{ return this->compare(that) <= 0; }

operator>=() [2/4]

template<class C>

template<class U>

bool c4::basic_substring< C >::operator>= ( basic_substring< U > const that ) const

inlinenoexcept

Definition at line 454 of file substr.hpp.

{ return this->compare(that) >= 0; }

operator==() [4/5]

template<class C>

template<size_t N>

bool c4::basic_substring< C >::operator== ( const char(&) arr[N] ) const

inlinenoexcept

Definition at line 456 of file substr.hpp.

{ return this->compare(arr, N-1) == 0; }

operator!=() [4/5]

template<class C>

template<size_t N>

bool c4::basic_substring< C >::operator!= ( const char(&) arr[N] ) const

inlinenoexcept

Definition at line 457 of file substr.hpp.

{ return this->compare(arr, N-1) != 0; }

operator<() [3/4]

template<class C>

template<size_t N>

bool c4::basic_substring< C >::operator< ( const char(&) arr[N] ) const

inlinenoexcept

Definition at line 458 of file substr.hpp.

{ return this->compare(arr, N-1) <  0; }

operator>() [3/4]

template<class C>

template<size_t N>

bool c4::basic_substring< C >::operator> ( const char(&) arr[N] ) const

inlinenoexcept

Definition at line 459 of file substr.hpp.

{ return this->compare(arr, N-1) >  0; }

operator<=() [3/4]

template<class C>

template<size_t N>

bool c4::basic_substring< C >::operator<= ( const char(&) arr[N] ) const

inlinenoexcept

Definition at line 460 of file substr.hpp.

{ return this->compare(arr, N-1) <= 0; }

operator>=() [3/4]

template<class C>

template<size_t N>

bool c4::basic_substring< C >::operator>= ( const char(&) arr[N] ) const

inlinenoexcept

Definition at line 461 of file substr.hpp.

{ return this->compare(arr, N-1) >= 0; }

operator==() [5/5]

template<class C>

template<class CharPtr>

auto c4::basic_substring< C >::operator== ( CharPtr c_str ) const->typenamestd::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type

inlinenoexcept

Definition at line 463 of file substr.hpp.

{ return this->compare(c_str, strlen(c_str)) == 0; }

operator!=() [5/5]

template<class C>

template<class CharPtr>

auto c4::basic_substring< C >::operator!= ( CharPtr c_str ) const->typenamestd::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type

inlinenoexcept

Definition at line 464 of file substr.hpp.

{ return this->compare(c_str, strlen(c_str)) != 0; }

operator<() [4/4]

template<class C>

template<class CharPtr>

auto c4::basic_substring< C >::operator< ( CharPtr c_str ) const->typenamestd::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type

inlinenoexcept

Definition at line 465 of file substr.hpp.

{ return this->compare(c_str, strlen(c_str)) <  0; }

operator>() [4/4]

template<class C>

template<class CharPtr>

auto c4::basic_substring< C >::operator> ( CharPtr c_str ) const->typenamestd::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type

inlinenoexcept

Definition at line 466 of file substr.hpp.

{ return this->compare(c_str, strlen(c_str)) >  0; }

operator<=() [4/4]

template<class C>

template<class CharPtr>

auto c4::basic_substring< C >::operator<= ( CharPtr c_str ) const->typenamestd::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type

inlinenoexcept

Definition at line 467 of file substr.hpp.

{ return this->compare(c_str, strlen(c_str)) <= 0; }

operator>=() [4/4]

template<class C>

template<class CharPtr>

auto c4::basic_substring< C >::operator>= ( CharPtr c_str ) const->typenamestd::enable_if< is_compatible_char_ptr< CharPtr, C >::value, int >::type

inlinenoexcept

Definition at line 468 of file substr.hpp.

{ return this->compare(c_str, strlen(c_str)) >= 0; }

is_sub()

template<class C>

bool c4::basic_substring< C >::is_sub ( ro_substr const that ) const

inlinenoexcept

true if *this is a substring of that (ie, from the same buffer)

Definition at line 478 of file substr.hpp.

    {
        return that.is_super(*this);
    }

Referenced by sample_formatting(), sample_substr(), and sample_tree_arena().

is_super()

template<class C>

bool c4::basic_substring< C >::is_super ( ro_substr const that ) const

inlinenoexcept

true if that is a substring of *this (ie, from the same buffer)

Definition at line 484 of file substr.hpp.

    {
        if C4_LIKELY(len > 0)
            return that.str >= str && that.str+that.len <= str+len;
        else
            return that.len == 0 && that.str == str && str != nullptr;
    }

Referenced by sample_substr(), and sample_tree_arena().

overlaps()

template<class C>

bool c4::basic_substring< C >::overlaps ( ro_substr const that ) const

inlinenoexcept

true if there is overlap of at least one element between that and *this

Definition at line 493 of file substr.hpp.

    {
        // thanks @timwynants
        return that.str+that.len > str && that.str < str+len;
    }

Referenced by c4::yml::Tree::copy_to_arena(), c4::yml::dump(), c4::yml::escape_scalar(), c4::from_chars_first(), c4::yml::normalize_tag_long(), c4::basic_substring< CC >::replace_all(), c4::yml::TagDirectives::resolve(), sample_formatting(), sample_substr(), and sample_tree_arena().

sub() [1/2]

template<class C>

basic_substring c4::basic_substring< C >::sub ( size_t first ) const

inlinenoexcept

return [first,len[

Definition at line 502 of file substr.hpp.

    {
        C4_ASSERT(first >= 0 && first <= len);
        return basic_substring(str + first, len - first);
    }

Referenced by c4::yml::extra::EventHandlerInts::arena_rem(), c4::atod(), c4::atof(), c4::cat(), c4::catrs_append(), c4::catsep(), c4::catseprs_append(), c4::yml::emitrs_json(), c4::yml::emitrs_yaml(), c4::yml::escape_scalar_fn(), c4::yml::extra::events_ints_to_testsuite(), c4::format(), c4::formatrs_append(), c4::yml::is_valid_tag_handle(), c4::yml::normalize_tag(), c4::yml::normalize_tag_long(), c4::yml::normalize_tag_long(), c4::basic_substring< CC >::pair_range(), c4::yml::TagDirectives::resolve(), sample_substr(), c4::yml::EventHandlerTree::set_key_ref(), c4::yml::extra::EventHandlerInts::set_key_ref(), c4::yml::EventHandlerTree::set_val_ref(), c4::yml::extra::EventHandlerInts::set_val_ref(), c4::skip_bom(), c4::skip_bom(), c4::to_chars(), c4::to_chars(), c4::yml::to_tag(), c4::yml::transform_tag(), c4::uncat(), c4::uncatsep(), and c4::unformat().

sub() [2/2]

template<class C>

basic_substring c4::basic_substring< C >::sub ( size_t first, size_t num ) const

inlinenoexcept

return [first,first+num[.

If num==npos, return [first,len[

Definition at line 509 of file substr.hpp.

    {
        C4_ASSERT(first >= 0 && first <= len);
        C4_ASSERT((num >= 0 && num <= len) || (num == npos));
        size_t rnum = num != npos ? num : len - first;
        C4_ASSERT((first >= 0 && first + rnum <= len) || (num == 0));
        return basic_substring(str + first, rnum);
    }

range()

template<class C>

basic_substring c4::basic_substring< C >::range ( size_t first, size_t last = npos ) const

inlinenoexcept

return [first,last[.

If last==npos, return [first,len[

Definition at line 519 of file substr.hpp.

    {
        C4_ASSERT(first >= 0 && first <= len);
        last = last != npos ? last : len;
        C4_ASSERT(first <= last);
        C4_ASSERT(last  >= 0 && last  <= len);
        return basic_substring(str + first, last - first);
    }

Referenced by c4::yml::detail::_get_text_region(), c4::catrs_append(), c4::catseprs_append(), c4::yml::escape_scalar_fn(), c4::formatrs_append(), sample_substr(), and c4::yml::transform_tag().

first()

template<class C>

basic_substring c4::basic_substring< C >::first ( size_t num ) const

inlinenoexcept

return the first num elements: [0,num[

Definition at line 529 of file substr.hpp.

    {
        C4_ASSERT(num <= len || num == npos);
        return basic_substring(str, num != npos ? num : len);
    }

Referenced by c4::yml::detail::_get_text_region(), c4::yml::extra::EventHandlerInts::arena(), c4::decode_code_point(), c4::get_bom(), c4::get_bom(), c4::yml::normalize_tag_long(), c4::yml::TagDirectives::resolve(), c4::yml::Tree::resolve_tag_sub(), c4::yml::Tree::lookup_result::resolved(), sample_base64(), sample_formatting(), sample_substr(), sample_tree_arena(), c4::yml::serialize_to_arena_scalar(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::yml::extra::ievt::to_str_sub(), and c4::uncatsep().

last()

template<class C>

basic_substring c4::basic_substring< C >::last ( size_t num ) const

inlinenoexcept

return the last num elements: [len-num,len[

Definition at line 536 of file substr.hpp.

    {
        C4_ASSERT(num <= len || num == npos);
        return num != npos ?
            basic_substring(str + len - num, num) :
            *this;
    }

Referenced by c4::yml::detail::_get_text_region(), c4::yml::extra::EventHandlerInts::arena_rem(), c4::yml::extra::events_ints_to_testsuite(), and sample_substr().

offs()

template<class C>

basic_substring c4::basic_substring< C >::offs ( size_t left, size_t right ) const

inlinenoexcept

offset from the ends: return [left,len-right[ ; ie, trim a number of characters from the left and right.

This is equivalent to python's negative list indices.

Definition at line 547 of file substr.hpp.

    {
        C4_ASSERT(left  >= 0 && left  <= len);
        C4_ASSERT(right >= 0 && right <= len);
        C4_ASSERT(left  <= len - right + 1);
        return basic_substring(str + left, len - right - left);
    }

Referenced by c4::yml::is_valid_tag_handle(), c4::yml::TagDirectives::resolve(), sample_substr(), and c4::yml::to_tag().

left_of() [1/3]

template<class C>

basic_substring c4::basic_substring< C >::left_of ( size_t pos ) const

inlinenoexcept

return [0, pos[ .

Same as .first(pos), but provided for compatibility with .right_of()

Definition at line 556 of file substr.hpp.

    {
        C4_ASSERT(pos <= len || pos == npos);
        return (pos != npos) ?
            basic_substring(str, pos) :
            *this;
    }

Referenced by sample_substr().

left_of() [2/3]

template<class C>

basic_substring c4::basic_substring< C >::left_of ( size_t pos, bool include_pos ) const

inlinenoexcept

return [0, pos+include_pos[ .

Same as .first(pos+1), but provided for compatibility with .right_of()

Definition at line 565 of file substr.hpp.

    {
        C4_ASSERT(pos <= len || pos == npos);
        return (pos != npos) ?
            basic_substring(str, pos+include_pos) :
            *this;
    }

right_of() [1/3]

template<class C>

basic_substring c4::basic_substring< C >::right_of ( size_t pos ) const

inlinenoexcept

return [pos+1, len[

Definition at line 574 of file substr.hpp.

    {
        C4_ASSERT(pos <= len || pos == npos);
        return (pos != npos) ?
            basic_substring(str + (pos + 1), len - (pos + 1)) :
            basic_substring(str + len, size_t(0));
    }

Referenced by sample_substr().

right_of() [2/3]

template<class C>

basic_substring c4::basic_substring< C >::right_of ( size_t pos, bool include_pos ) const

inlinenoexcept

return [pos+!include_pos, len[

Definition at line 583 of file substr.hpp.

    {
        C4_ASSERT(pos <= len || pos == npos);
        return (pos != npos) ?
            basic_substring(str + (pos + !include_pos), len - (pos + !include_pos)) :
            basic_substring(str + len, size_t(0));
    }

left_of() [3/3]

template<class C>

basic_substring c4::basic_substring< C >::left_of ( ro_substr const subs ) const

inlinenoexcept

given subs a substring of the current string, get the portion of the current string to the left of it

Definition at line 595 of file substr.hpp.

    {
        C4_ASSERT(is_super(subs) || subs.empty());
        auto ssb = subs.begin();
        auto b = begin();
        auto e = end();
        if(ssb >= b && ssb <= e)
            return sub(0, static_cast<size_t>(ssb - b));
        else
            return sub(0, 0);
    }

right_of() [3/3]

template<class C>

basic_substring c4::basic_substring< C >::right_of ( ro_substr const subs ) const

inlinenoexcept

given subs a substring of the current string, get the portion of the current string to the right of it

Definition at line 609 of file substr.hpp.

    {
        C4_ASSERT(is_super(subs) || subs.empty());
        auto sse = subs.end();
        auto b = begin();
        auto e = end();
        if(sse >= b && sse <= e)
            return sub(static_cast<size_t>(sse - b), static_cast<size_t>(e - sse));
        else
            return sub(0, 0);
    }

triml() [1/2]

template<class C>

basic_substring c4::basic_substring< C >::triml ( const C c ) const

inline

trim left

Definition at line 629 of file substr.hpp.

    {
        if( ! empty())
        {
            size_t pos = first_not_of(c);
            if(pos != npos)
                return sub(pos);
        }
        return sub(0, 0);
    }

Referenced by sample_substr(), c4::yml::Tree::set_key_anchor(), and c4::yml::Tree::set_val_anchor().

triml() [2/2]

template<class C>

basic_substring c4::basic_substring< C >::triml ( ro_substr chars ) const

inline

trim left ANY of the characters.

See also

stripl() to remove a pattern from the left

Definition at line 641 of file substr.hpp.

    {
        if( ! empty())
        {
            size_t pos = first_not_of(chars);
            if(pos != npos)
                return sub(pos);
        }
        return sub(0, 0);
    }

trimr() [1/2]

template<class C>

basic_substring c4::basic_substring< C >::trimr ( const C c ) const

inline

trim the character c from the right

Definition at line 653 of file substr.hpp.

    {
        if( ! empty())
        {
            size_t pos = last_not_of(c, npos);
            if(pos != npos)
                return sub(0, pos+1);
        }
        return sub(0, 0);
    }

Referenced by sample_substr().

trimr() [2/2]

template<class C>

basic_substring c4::basic_substring< C >::trimr ( ro_substr chars ) const

inline

trim right ANY of the characters

See also

stripr() to remove a pattern from the right

Definition at line 665 of file substr.hpp.

    {
        if( ! empty())
        {
            size_t pos = last_not_of(chars, npos);
            if(pos != npos)
                return sub(0, pos+1);
        }
        return sub(0, 0);
    }

trim() [1/2]

template<class C>

basic_substring c4::basic_substring< C >::trim ( const C c ) const

inline

trim the character c left and right

Definition at line 677 of file substr.hpp.

    {
        return triml(c).trimr(c);
    }

Referenced by sample_substr().

trim() [2/2]

template<class C>

basic_substring c4::basic_substring< C >::trim ( ro_substr const chars ) const

inline

trim left and right ANY of the characters

See also

strip() to remove a pattern from the left and right

Definition at line 683 of file substr.hpp.

    {
        return triml(chars).trimr(chars);
    }

stripl()

template<class C>

basic_substring c4::basic_substring< C >::stripl ( ro_substr pattern ) const

inline

remove a pattern from the left

See also

triml() to remove characters

Definition at line 690 of file substr.hpp.

    {
        if( ! begins_with(pattern))
            return *this;
        return sub(pattern.len < len ? pattern.len : len);
    }

Referenced by sample_substr().

stripr()

template<class C>

basic_substring c4::basic_substring< C >::stripr ( ro_substr pattern ) const

inline

remove a pattern from the right

See also

trimr() to remove characters

Definition at line 699 of file substr.hpp.

    {
        if( ! ends_with(pattern))
            return *this;
        return left_of(len - (pattern.len < len ? pattern.len : len));
    }

Referenced by sample_substr().

find() [1/2]

template<class C>

size_t c4::basic_substring< C >::find ( const C c, size_t start_pos = 0 ) const

inline

Definition at line 713 of file substr.hpp.

    {
        return first_of(c, start_pos);
    }

Referenced by c4::yml::is_custom_tag(), c4::basic_substring< CC >::pair_range(), sample_substr(), and c4::uncatsep().

find() [2/2]

template<class C>

size_t c4::basic_substring< C >::find ( ro_substr pattern, size_t start_pos = 0 ) const

inline

Definition at line 717 of file substr.hpp.

    {
        C4_ASSERT(start_pos == npos || (start_pos >= 0 && start_pos <= len));
        if(len < pattern.len) return npos;
        for(size_t i = start_pos, e = len - pattern.len + 1; i < e; ++i)
        {
            bool gotit = true;
            for(size_t j = 0; j < pattern.len; ++j)
            {
                C4_ASSERT(i + j < len);
                if(str[i + j] != pattern.str[j])
                {
                    gotit = false;
                    break;
                }
            }
            if(gotit)
            {
                return i;
            }
        }
        return npos;
    }

count() [1/2]

template<class C>

size_t c4::basic_substring< C >::count ( const C c, size_t pos = 0 ) const

inline

count the number of occurrences of c

Definition at line 744 of file substr.hpp.

    {
        C4_ASSERT(pos >= 0 && pos <= len);
        size_t num = 0;
        pos = find(c, pos);
        while(pos != npos)
        {
            ++num;
            pos = find(c, pos + 1);
        }
        return num;
    }

Referenced by sample_substr().

count() [2/2]

template<class C>

size_t c4::basic_substring< C >::count ( ro_substr c, size_t pos = 0 ) const

inline

count the number of occurrences of s

Definition at line 758 of file substr.hpp.

    {
        C4_ASSERT(pos >= 0 && pos <= len);
        size_t num = 0;
        pos = find(c, pos);
        while(pos != npos)
        {
            ++num;
            pos = find(c, pos + c.len);
        }
        return num;
    }

select() [1/2]

template<class C>

basic_substring c4::basic_substring< C >::select ( const C c, size_t pos = 0 ) const

inline

get the substr consisting of the first occurrence of c after pos, or an empty substr if none occurs

Definition at line 772 of file substr.hpp.

    {
        pos = find(c, pos);
        return pos != npos ? sub(pos, 1) : basic_substring();
    }

Referenced by sample_substr().

select() [2/2]

template<class C>

basic_substring c4::basic_substring< C >::select ( ro_substr pattern, size_t pos = 0 ) const

inline

get the substr consisting of the first occurrence of pattern after pos, or an empty substr if none occurs

Definition at line 779 of file substr.hpp.

    {
        pos = find(pattern, pos);
        return pos != npos ? sub(pos, pattern.len) : basic_substring();
    }

first_of_any() [1/4]

template<class C>

first_of_any_result c4::basic_substring< C >::first_of_any ( ro_substr s0, ro_substr s1 ) const

inline

Definition at line 794 of file substr.hpp.

    {
        ro_substr s[2] = {s0, s1};
        return first_of_any_iter(&s[0], &s[0] + 2);
    }

first_of_any() [2/4]

template<class C>

first_of_any_result c4::basic_substring< C >::first_of_any ( ro_substr s0, ro_substr s1, ro_substr s2 ) const

inline

Definition at line 800 of file substr.hpp.

    {
        ro_substr s[3] = {s0, s1, s2};
        return first_of_any_iter(&s[0], &s[0] + 3);
    }

first_of_any() [3/4]

template<class C>

first_of_any_result c4::basic_substring< C >::first_of_any ( ro_substr s0, ro_substr s1, ro_substr s2, ro_substr s3 ) const

inline

Definition at line 806 of file substr.hpp.

    {
        ro_substr s[4] = {s0, s1, s2, s3};
        return first_of_any_iter(&s[0], &s[0] + 4);
    }

first_of_any() [4/4]

template<class C>

first_of_any_result c4::basic_substring< C >::first_of_any ( ro_substr s0, ro_substr s1, ro_substr s2, ro_substr s3, ro_substr s4 ) const

inline

Definition at line 812 of file substr.hpp.

    {
        ro_substr s[5] = {s0, s1, s2, s3, s4};
        return first_of_any_iter(&s[0], &s[0] + 5);
    }

first_of_any_iter()

template<class C>

template<class It>

first_of_any_result c4::basic_substring< C >::first_of_any_iter ( It first_span, It last_span ) const

inline

Definition at line 819 of file substr.hpp.

    {
        for(size_t i = 0; i < len; ++i)
        {
            size_t curr = 0;
            for(It it = first_span; it != last_span; ++curr, ++it)
            {
                auto const& chars = *it;
                if((i + chars.len) > len) continue;
                bool gotit = true;
                for(size_t j = 0; j < chars.len; ++j)
                {
                    C4_ASSERT(i + j < len);
                    if(str[i + j] != chars[j])
                    {
                        gotit = false;
                        break;
                    }
                }
                if(gotit)
                {
                    return {curr, i};
                }
            }
        }
        return {NONE, npos};
    }

begins_with() [1/3]

template<class C>

bool c4::basic_substring< C >::begins_with ( const C c ) const

inlinenoexcept

true if the first character of the string is c

Definition at line 850 of file substr.hpp.

    {
        C4_SUPPRESS_WARNING_GCC_PUSH
        #if defined(__GNUC__) && (__GNUC__ >= 6)
        C4_SUPPRESS_WARNING_GCC("-Wnull-dereference")
        #endif
        return len && str[0] == c;
        C4_SUPPRESS_WARNING_GCC_POP
    }

Referenced by c4::decode_code_point(), c4::yml::extra::events_ints_to_testsuite(), c4::yml::is_valid_tag_handle(), c4::yml::normalize_tag(), c4::yml::normalize_tag_long(), c4::yml::normalize_tag_long(), c4::yml::TagDirectives::resolve(), sample_location_tracking(), sample_quick_overview(), sample_substr(), c4::yml::EventHandlerTree::set_key_anchor(), c4::yml::EventHandlerTree::set_key_ref(), c4::yml::extra::EventHandlerInts::set_key_ref(), c4::yml::EventHandlerTree::set_val_anchor(), c4::yml::EventHandlerTree::set_val_ref(), c4::yml::extra::EventHandlerInts::set_val_ref(), and c4::yml::to_tag().

begins_with() [2/3]

template<class C>

bool c4::basic_substring< C >::begins_with ( const C c, size_t num ) const

inlinenoexcept

true if the first num characters of the string are c

Definition at line 861 of file substr.hpp.

    {
        if(len < num)
            return false;
        for(size_t i = 0; i < num; ++i)
            if(str[i] != c)
                return false;
        return num > 0;
    }

begins_with() [3/3]

template<class C>

bool c4::basic_substring< C >::begins_with ( ro_substr pattern ) const

inlinenoexcept

true if the string begins with the given pattern

Definition at line 872 of file substr.hpp.

    {
        if(len < pattern.len)
            return false;
        for(size_t i = 0; i < pattern.len; ++i)
            if(str[i] != pattern.str[i])
                return false;
        return pattern.len > 0;
    }

begins_with_any()

template<class C>

bool c4::basic_substring< C >::begins_with_any ( ro_substr chars ) const

inlinenoexcept

true if the first character of the string is any of the given chars

Definition at line 883 of file substr.hpp.

    {
        if(len)
            for(size_t i = 0; i < chars.len; ++i)
                if(str[0] == chars.str[i])
                    return true;
        return false;
    }

Referenced by sample_substr().

ends_with() [1/3]

template<class C>

bool c4::basic_substring< C >::ends_with ( const C c ) const

inlinenoexcept

true if the last character of the string is c

Definition at line 894 of file substr.hpp.

    {
        return len && str[len-1] == c;
    }

Referenced by c4::yml::is_valid_tag_handle(), c4::yml::TagDirectives::resolve(), c4::yml::Tree::lookup_result::resolved(), and sample_substr().

ends_with() [2/3]

template<class C>

bool c4::basic_substring< C >::ends_with ( const C c, const size_t num ) const

inlinenoexcept

true if the last num characters of the string are c

Definition at line 900 of file substr.hpp.

    {
        if(len < num)
            return false;
        for(size_t i = len - num; i < len; ++i)
            if(str[i] != c)
                return false;
        return num > 0;
    }

ends_with() [3/3]

template<class C>

bool c4::basic_substring< C >::ends_with ( ro_substr pattern ) const

inlinenoexcept

true if the string ends with the given pattern

Definition at line 911 of file substr.hpp.

    {
        if(len < pattern.len)
            return false;
        for(size_t i = 0, s = len-pattern.len; i < pattern.len; ++i)
            if(str[s+i] != pattern[i])
                return false;
        return pattern.len > 0;
    }

ends_with_any()

template<class C>

bool c4::basic_substring< C >::ends_with_any ( ro_substr chars ) const

inlinenoexcept

true if the last character of the string is any of the given chars

Definition at line 922 of file substr.hpp.

    {
        if(len)
            for(size_t i = 0; i < chars.len; ++i)
                if(str[len - 1] == chars[i])
                    return true;
        return false;
    }

Referenced by sample_substr().

first_of() [1/2]

template<class C>

size_t c4::basic_substring< C >::first_of ( const C c, size_t start = 0 ) const

inline

Returns

the first position where c is found in the string, or npos if none is found

Definition at line 934 of file substr.hpp.

    {
        C4_ASSERT(start == npos || (start >= 0 && start <= len));
        for(size_t i = start; i < len; ++i)
        {
            if(str[i] == c)
                return i;
        }
        return npos;
    }

Referenced by c4::yml::detail::_get_text_region(), and sample_substr().

last_of() [1/2]

template<class C>

size_t c4::basic_substring< C >::last_of ( const C c, size_t start = npos ) const

inline

Returns

the last position where c is found in the string, or npos if none is found

Definition at line 946 of file substr.hpp.

    {
        C4_ASSERT(start == npos || (start >= 0 && start <= len));
        if(start == npos)
            start = len;
        for(size_t i = start-1; i != size_t(-1); --i)
        {
            if(str[i] == c)
                return i;
        }
        return npos;
    }

Referenced by c4::yml::detail::_get_text_region(), and sample_substr().

first_of() [2/2]

template<class C>

size_t c4::basic_substring< C >::first_of ( ro_substr chars, size_t start = 0 ) const

inline

Returns

the first position where ANY of the chars is found in the string, or npos if none is found

Definition at line 960 of file substr.hpp.

    {
        C4_ASSERT(start == npos || (start >= 0 && start <= len));
        for(size_t i = start; i < len; ++i)
        {
            for(size_t j = 0; j < chars.len; ++j)
            {
                if(str[i] == chars.str[j])
                    return i;
            }
        }
        return npos;
    }

last_of() [2/2]

template<class C>

size_t c4::basic_substring< C >::last_of ( ro_substr chars, size_t start = npos ) const

inline

Returns

the last position where ANY of the chars is found in the string, or npos if none is found

Definition at line 975 of file substr.hpp.

    {
        C4_ASSERT(start == npos || (start >= 0 && start <= len));
        if(start == npos)
            start = len;
        for(size_t i = start-1; i != size_t(-1); --i)
        {
            for(size_t j = 0; j < chars.len; ++j)
            {
                if(str[i] == chars[j])
                    return i;
            }
        }
        return npos;
    }

first_not_of() [1/4]

template<class C>

size_t c4::basic_substring< C >::first_not_of ( const C c ) const

inline

Definition at line 993 of file substr.hpp.

    {
        for(size_t i = 0; i < len; ++i)
        {
            if(str[i] != c)
                return i;
        }
        return npos;
    }

Referenced by sample_substr().

first_not_of() [2/4]

template<class C>

size_t c4::basic_substring< C >::first_not_of ( const C c, size_t start ) const

inline

Definition at line 1003 of file substr.hpp.

    {
        C4_ASSERT((start >= 0 && start <= len) || (start == len && len == 0));
        for(size_t i = start; i < len; ++i)
        {
            if(str[i] != c)
                return i;
        }
        return npos;
    }

last_not_of() [1/4]

template<class C>

size_t c4::basic_substring< C >::last_not_of ( const C c ) const

inline

Definition at line 1014 of file substr.hpp.

    {
        for(size_t i = len-1; i != size_t(-1); --i)
        {
            if(str[i] != c)
                return i;
        }
        return npos;
    }

Referenced by sample_substr().

last_not_of() [2/4]

template<class C>

size_t c4::basic_substring< C >::last_not_of ( const C c, size_t start ) const

inline

Definition at line 1024 of file substr.hpp.

    {
        C4_ASSERT(start == npos || (start >= 0 && start <= len));
        if(start == npos)
            start = len;
        for(size_t i = start-1; i != size_t(-1); --i)
        {
            if(str[i] != c)
                return i;
        }
        return npos;
    }

first_not_of() [3/4]

template<class C>

size_t c4::basic_substring< C >::first_not_of ( ro_substr chars ) const

inline

Definition at line 1037 of file substr.hpp.

    {
        for(size_t i = 0; i < len; ++i)
        {
            bool gotit = true;
            for(size_t j = 0; j < chars.len; ++j)
            {
                if(str[i] == chars.str[j])
                {
                    gotit = false;
                    break;
                }
            }
            if(gotit)
            {
                return i;
            }
        }
        return npos;
    }

first_not_of() [4/4]

template<class C>

size_t c4::basic_substring< C >::first_not_of ( ro_substr chars, size_t start ) const

inline

Definition at line 1058 of file substr.hpp.

    {
        C4_ASSERT((start >= 0 && start <= len) || (start == len && len == 0));
        for(size_t i = start; i < len; ++i)
        {
            bool gotit = true;
            for(size_t j = 0; j < chars.len; ++j)
            {
                if(str[i] == chars.str[j])
                {
                    gotit = false;
                    break;
                }
            }
            if(gotit)
            {
                return i;
            }
        }
        return npos;
    }

last_not_of() [3/4]

template<class C>

size_t c4::basic_substring< C >::last_not_of ( ro_substr chars ) const

inline

Definition at line 1080 of file substr.hpp.

    {
        for(size_t i = len-1; i != size_t(-1); --i)
        {
            bool gotit = true;
            for(size_t j = 0; j < chars.len; ++j)
            {
                if(str[i] == chars.str[j])
                {
                    gotit = false;
                    break;
                }
            }
            if(gotit)
            {
                return i;
            }
        }
        return npos;
    }

last_not_of() [4/4]

template<class C>

size_t c4::basic_substring< C >::last_not_of ( ro_substr chars, size_t start ) const

inline

Definition at line 1101 of file substr.hpp.

    {
        C4_ASSERT(start == npos || (start >= 0 && start <= len));
        if(start == npos)
            start = len;
        for(size_t i = start-1; i != size_t(-1); --i)
        {
            bool gotit = true;
            for(size_t j = 0; j < chars.len; ++j)
            {
                if(str[i] == chars.str[j])
                {
                    gotit = false;
                    break;
                }
            }
            if(gotit)
            {
                return i;
            }
        }
        return npos;
    }

pair_range()

template<class C>

basic_substring c4::basic_substring< C >::pair_range ( CC open, CC close ) const

inline

get the range delimited by an open-close pair of characters.

Note

There must be no nested pairs.

No checks for escapes are performed.

Definition at line 1135 of file substr.hpp.

    {
        size_t b = find(open);
        if(b == npos)
            return basic_substring();
        size_t e = find(close, b+1);
        if(e == npos)
            return basic_substring();
        basic_substring ret = range(b, e+1);
        C4_ASSERT(ret.sub(1).find(open) == npos);
        return ret;
    }

pair_range_esc()

template<class C>

basic_substring c4::basic_substring< C >::pair_range_esc ( CC open_close, CC escape = CC('\\') )

inline

get the range delimited by a single open-close character (eg, quotes).

Note

The open-close character can be escaped.

Definition at line 1150 of file substr.hpp.

    {
        size_t b = find(open_close);
        if(b == npos) return basic_substring();
        for(size_t i = b+1; i < len; ++i)
        {
            CC c = str[i];
            if(c == open_close)
            {
                if(str[i-1] != escape)
                {
                    return range(b, i+1);
                }
            }
        }
        return basic_substring();
    }

pair_range_nested()

template<class C>

basic_substring c4::basic_substring< C >::pair_range_nested ( CC open, CC close ) const

inline

get the range delimited by an open-close pair of characters, with possibly nested occurrences.

No checks for escapes are performed.

Definition at line 1171 of file substr.hpp.

    {
        size_t b = find(open);
        if(b == npos) return basic_substring();
        size_t e, curr = b+1, count = 0;
        const char both[] = {open, close, '\0'};
        while((e = first_of(both, curr)) != npos)
        {
            if(str[e] == open)
            {
                ++count;
                curr = e+1;
            }
            else if(str[e] == close)
            {
                if(count == 0) return range(b, e+1);
                --count;
                curr = e+1;
            }
        }
        return basic_substring();
    }

unquoted()

template<class C>

basic_substring c4::basic_substring< C >::unquoted ( ) const

inline

Definition at line 1194 of file substr.hpp.

    {
        constexpr const C dq('"'), sq('\'');
        if(len >= 2 && (str[len - 2] != C('\\')) &&
           ((begins_with(sq) && ends_with(sq))
            ||
            (begins_with(dq) && ends_with(dq))))
        {
            return range(1, len -1);
        }
        return *this;
    }

is_number()

template<class C>

bool c4::basic_substring< C >::is_number ( ) const

inline

Returns

true if the substring contents are a floating-point or integer number.

Note

any leading or trailing whitespace will return false.

Definition at line 1216 of file substr.hpp.

    {
        if(empty() || (first_non_empty_span().empty()))
            return false;
        if(first_uint_span() == *this)
            return true;
        if(first_int_span() == *this)
            return true;
        if(first_real_span() == *this)
            return true;
        return false;
    }

is_real()

template<class C>

bool c4::basic_substring< C >::is_real ( ) const

inline

Returns

true if the substring contents are a real number.

Note

any leading or trailing whitespace will return false.

Definition at line 1231 of file substr.hpp.

    {
        if(empty() || (first_non_empty_span().empty()))
            return false;
        if(first_real_span() == *this)
            return true;
        return false;
    }

is_integer()

template<class C>

bool c4::basic_substring< C >::is_integer ( ) const

inline

Returns

true if the substring contents are an integer number.

Note

any leading or trailing whitespace will return false.

Definition at line 1242 of file substr.hpp.

    {
        if(empty() || (first_non_empty_span().empty()))
            return false;
        if(first_uint_span() == *this)
            return true;
        if(first_int_span() == *this)
            return true;
        return false;
    }

is_unsigned_integer()

template<class C>

bool c4::basic_substring< C >::is_unsigned_integer ( ) const

inline

Returns

true if the substring contents are an unsigned integer number.

Note

any leading or trailing whitespace will return false.

Definition at line 1255 of file substr.hpp.

    {
        if(empty() || (first_non_empty_span().empty()))
            return false;
        if(first_uint_span() == *this)
            return true;
        return false;
    }

first_non_empty_span()

template<class C>

basic_substring c4::basic_substring< C >::first_non_empty_span ( ) const

inline

get the first span consisting exclusively of non-empty characters

Definition at line 1265 of file substr.hpp.

    {
        constexpr const ro_substr empty_chars(" \n\r\t");
        size_t pos = first_not_of(empty_chars);
        if(pos == npos)
            return first(0);
        auto ret = sub(pos);
        pos = ret.first_of(empty_chars);
        return ret.first(pos);
    }

first_uint_span()

template<class C>

basic_substring c4::basic_substring< C >::first_uint_span ( ) const

inline

get the first span which can be interpreted as an unsigned integer

Definition at line 1277 of file substr.hpp.

    {
        basic_substring ne = first_non_empty_span();
        if(ne.empty())
            return ne;
        if(ne.str[0] == '-')
            return first(0);
        size_t skip_start = size_t(ne.str[0] == '+');
        return ne._first_integral_span(skip_start);
    }

Referenced by c4::atou_first().

first_int_span()

template<class C>

basic_substring c4::basic_substring< C >::first_int_span ( ) const

inline

get the first span which can be interpreted as a signed integer

Definition at line 1289 of file substr.hpp.

    {
        basic_substring ne = first_non_empty_span();
        if(ne.empty())
            return ne;
        size_t skip_start = size_t(ne.str[0] == '+' || ne.str[0] == '-');
        return ne._first_integral_span(skip_start);
    }

Referenced by c4::atoi_first().

_first_integral_span()

template<class C>

basic_substring c4::basic_substring< C >::_first_integral_span ( size_t skip_start ) const

inline

Definition at line 1298 of file substr.hpp.

    {
        C4_ASSERT(!empty());
        if(skip_start == len)
            return first(0);
        C4_ASSERT(skip_start < len);
        if(len >= skip_start + 3)
        {
            if(str[skip_start] != '0')
            {
                for(size_t i = skip_start; i < len; ++i)
                {
                    char c = str[i];
                    if(c < '0' || c > '9')
                        return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
                }
            }
            else
            {
                char next = str[skip_start + 1];
                if(next == 'x' || next == 'X')
                {
                    skip_start += 2;
                    for(size_t i = skip_start; i < len; ++i)
                    {
                        const char c = str[i];
                        if( ! _is_hex_char(c))
                            return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
                    }
                    return *this;
                }
                else if(next == 'b' || next == 'B')
                {
                    skip_start += 2;
                    for(size_t i = skip_start; i < len; ++i)
                    {
                        const char c = str[i];
                        if(c != '0' && c != '1')
                            return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
                    }
                    return *this;
                }
                else if(next == 'o' || next == 'O')
                {
                    skip_start += 2;
                    for(size_t i = skip_start; i < len; ++i)
                    {
                        const char c = str[i];
                        if(c < '0' || c > '7')
                            return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
                    }
                    return *this;
                }
            }
        }
        // must be a decimal, or it is not a an number
        for(size_t i = skip_start; i < len; ++i)
        {
            const char c = str[i];
            if(c < '0' || c > '9')
                return i > skip_start && _is_delim_char(c) ? first(i) : first(0);
        }
        return *this;
    }

Referenced by c4::basic_substring< CC >::first_int_span(), and c4::basic_substring< CC >::first_uint_span().

first_real_span()

template<class C>

basic_substring c4::basic_substring< C >::first_real_span ( ) const

inline

get the first span which can be interpreted as a real (floating-point) number

Definition at line 1364 of file substr.hpp.

    {
        basic_substring ne = first_non_empty_span();
        if(ne.empty())
            return ne;
        const size_t skip_start = (ne.str[0] == '+' || ne.str[0] == '-');
        C4_ASSERT(skip_start == 0 || skip_start == 1);
        // if we have at least three digits after the leading sign, it
        // can be decimal, or hex, or bin or oct. Ex:
        // non-decimal: 0x0, 0b0, 0o0
        // decimal: 1.0, 10., 1e1, 100, inf, nan, infinity
        if(ne.len >= skip_start+3)
        {
            // if it does not have leading 0, it must be decimal, or it is not a real
            if(ne.str[skip_start] != '0')
            {
                if(ne.str[skip_start] == 'i') // is it infinity or inf?
                {
                    basic_substring word = ne._word_follows(skip_start + 1, "nfinity");
                    if(word.len)
                        return word;
                    return ne._word_follows(skip_start + 1, "nf");
                }
                else if(ne.str[skip_start] == 'n') // is it nan?
                {
                    return ne._word_follows(skip_start + 1, "an");
                }
                else // must be a decimal, or it is not a real
                {
                    return ne._first_real_span_dec(skip_start);
                }
            }
            else // starts with 0. is it 0x, 0b or 0o?
            {
                const char next = ne.str[skip_start + 1];
                // hexadecimal
                if(next == 'x' || next == 'X')
                    return ne._first_real_span_hex(skip_start + 2);
                // binary
                else if(next == 'b' || next == 'B')
                    return ne._first_real_span_bin(skip_start + 2);
                // octal
                else if(next == 'o' || next == 'O')
                    return ne._first_real_span_oct(skip_start + 2);
                // none of the above. may still be a decimal.
                else
                    return ne._first_real_span_dec(skip_start); // do not skip the 0.
            }
        }
        // less than 3 chars after the leading sign. It is either a
        // decimal or it is not a real. (cannot be any of 0x0, etc).
        return ne._first_real_span_dec(skip_start);
    }

_is_delim_char()

template<class C>

constexpr C4_CONST bool c4::basic_substring< C >::_is_delim_char ( char c )

inlinestaticconstexprnoexcept

true if the character is a delimiter character at the end

Definition at line 1419 of file substr.hpp.

    {
        return c == ' ' || c == '\n'
            || c == ']' || c == ')'  || c == '}'
            || c == ',' || c == ';' || c == '\r' || c == '\t' || c == '\0';
    }

_is_hex_char()

template<class C>

constexpr C4_CONST bool c4::basic_substring< C >::_is_hex_char ( char c )

inlinestaticconstexprnoexcept

true if the character is in [0-9a-fA-F]

Definition at line 1427 of file substr.hpp.

    {
        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
    }

_word_follows()

template<class C>

basic_substring c4::basic_substring< C >::_word_follows ( size_t pos, csubstr word ) const

inlinenoexcept

Definition at line 1432 of file substr.hpp.

    {
        size_t posend = pos + word.len;
        if(len >= posend && sub(pos, word.len) == word)
            if(len == posend || _is_delim_char(str[posend]))
                return first(posend);
        return first(0);
    }

Referenced by c4::basic_substring< CC >::first_real_span().

_first_real_span_dec()

template<class C>

basic_substring c4::basic_substring< C >::_first_real_span_dec ( size_t pos ) const

inlinenoexcept

Definition at line 1442 of file substr.hpp.

    {
        bool intchars = false;
        bool fracchars = false;
        bool powchars;
        // integral part
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c >= '0' && c <= '9')
            {
                intchars = true;
            }
            else if(c == '.')
            {
                ++pos;
                goto fractional_part_dec; // NOLINT
            }
            else if(c == 'e' || c == 'E')
            {
                ++pos;
                goto power_part_dec; // NOLINT
            }
            else if(_is_delim_char(c))
            {
                return intchars ? first(pos) : first(0);
            }
            else
            {
                return first(0);
            }
        }
        // no . or p were found; this is either an integral number
        // or not a number at all
        return intchars ?
            *this :
            first(0);
    fractional_part_dec:
        C4_ASSERT(pos > 0);
        C4_ASSERT(str[pos - 1] == '.');
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c >= '0' && c <= '9')
            {
                fracchars = true;
            }
            else if(c == 'e' || c == 'E')
            {
                ++pos;
                goto power_part_dec; // NOLINT
            }
            else if(_is_delim_char(c))
            {
                return intchars || fracchars ? first(pos) : first(0);
            }
            else
            {
                return first(0);
            }
        }
        return intchars || fracchars ?
            *this :
            first(0);
    power_part_dec:
        C4_ASSERT(pos > 0);
        C4_ASSERT(str[pos - 1] == 'e' || str[pos - 1] == 'E');
        // either digits, or +, or - are expected here, followed by more digits.
        if((len == pos) || ((!intchars) && (!fracchars)))
            return first(0);
        if(str[pos] == '-' || str[pos] == '+')
            ++pos; // skip the sign
        powchars = false;
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c >= '0' && c <= '9')
                powchars = true;
            else if(powchars && _is_delim_char(c))
                return first(pos);
            else
                return first(0);
        }
        return powchars ? *this : first(0);
    }

Referenced by c4::basic_substring< CC >::first_real_span().

_first_real_span_hex()

template<class C>

basic_substring c4::basic_substring< C >::_first_real_span_hex ( size_t pos ) const

inlinenoexcept

Definition at line 1529 of file substr.hpp.

    {
        bool intchars = false;
        bool fracchars = false;
        bool powchars;
        // integral part
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(_is_hex_char(c))
            {
                intchars = true;
            }
            else if(c == '.')
            {
                ++pos;
                goto fractional_part_hex; // NOLINT
            }
            else if(c == 'p' || c == 'P')
            {
                ++pos;
                goto power_part_hex; // NOLINT
            }
            else if(_is_delim_char(c))
            {
                return intchars ? first(pos) : first(0);
            }
            else
            {
                return first(0);
            }
        }
        // no . or p were found; this is either an integral number
        // or not a number at all
        return intchars ?
            *this :
            first(0);
    fractional_part_hex:
        C4_ASSERT(pos > 0);
        C4_ASSERT(str[pos - 1] == '.');
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(_is_hex_char(c))
            {
                fracchars = true;
            }
            else if(c == 'p' || c == 'P')
            {
                ++pos;
                goto power_part_hex; // NOLINT
            }
            else if(_is_delim_char(c))
            {
                return intchars || fracchars ? first(pos) : first(0);
            }
            else
            {
                return first(0);
            }
        }
        return intchars || fracchars ?
            *this :
            first(0);
    power_part_hex:
        C4_ASSERT(pos > 0);
        C4_ASSERT(str[pos - 1] == 'p' || str[pos - 1] == 'P');
        // either a + or a - is expected here, followed by more chars.
        // also, using (pos+1) in this check will cause an early
        // return when no more chars follow the sign.
        if(len <= (pos+1) || (str[pos] != '+' && str[pos] != '-') || ((!intchars) && (!fracchars)))
            return first(0);
        ++pos; // this was the sign.
        // ... so the (pos+1) ensures that we enter the loop and
        // hence that there exist chars in the power part
        powchars = false;
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c >= '0' && c <= '9')
                powchars = true;
            else if(powchars && _is_delim_char(c))
                return first(pos);
            else
                return first(0);
        }
        return *this;
    }

Referenced by c4::basic_substring< CC >::first_real_span().

_first_real_span_bin()

template<class C>

basic_substring c4::basic_substring< C >::_first_real_span_bin ( size_t pos ) const

inlinenoexcept

Definition at line 1619 of file substr.hpp.

    {
        bool intchars = false;
        bool fracchars = false;
        bool powchars;
        // integral part
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c == '0' || c == '1')
            {
                intchars = true;
            }
            else if(c == '.')
            {
                ++pos;
                goto fractional_part_bin; // NOLINT
            }
            else if(c == 'p' || c == 'P')
            {
                ++pos;
                goto power_part_bin; // NOLINT
            }
            else if(_is_delim_char(c))
            {
                return intchars ? first(pos) : first(0);
            }
            else
            {
                return first(0);
            }
        }
        // no . or p were found; this is either an integral number
        // or not a number at all
        return intchars ?
            *this :
            first(0);
    fractional_part_bin:
        C4_ASSERT(pos > 0);
        C4_ASSERT(str[pos - 1] == '.');
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c == '0' || c == '1')
            {
                fracchars = true;
            }
            else if(c == 'p' || c == 'P')
            {
                ++pos;
                goto power_part_bin; // NOLINT
            }
            else if(_is_delim_char(c))
            {
                return intchars || fracchars ? first(pos) : first(0);
            }
            else
            {
                return first(0);
            }
        }
        return intchars || fracchars ?
            *this :
            first(0);
    power_part_bin:
        C4_ASSERT(pos > 0);
        C4_ASSERT(str[pos - 1] == 'p' || str[pos - 1] == 'P');
        // either a + or a - is expected here, followed by more chars.
        // also, using (pos+1) in this check will cause an early
        // return when no more chars follow the sign.
        if(len <= (pos+1) || (str[pos] != '+' && str[pos] != '-') || ((!intchars) && (!fracchars)))
            return first(0);
        ++pos; // this was the sign.
        // ... so the (pos+1) ensures that we enter the loop and
        // hence that there exist chars in the power part
        powchars = false;
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c >= '0' && c <= '9')
                powchars = true;
            else if(powchars && _is_delim_char(c))
                return first(pos);
            else
                return first(0);
        }
        return *this;
    }

Referenced by c4::basic_substring< CC >::first_real_span().

_first_real_span_oct()

template<class C>

basic_substring c4::basic_substring< C >::_first_real_span_oct ( size_t pos ) const

inlinenoexcept

Definition at line 1709 of file substr.hpp.

    {
        bool intchars = false;
        bool fracchars = false;
        bool powchars;
        // integral part
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c >= '0' && c <= '7')
            {
                intchars = true;
            }
            else if(c == '.')
            {
                ++pos;
                goto fractional_part_oct; // NOLINT
            }
            else if(c == 'p' || c == 'P')
            {
                ++pos;
                goto power_part_oct; // NOLINT
            }
            else if(_is_delim_char(c))
            {
                return intchars ? first(pos) : first(0);
            }
            else
            {
                return first(0);
            }
        }
        // no . or p were found; this is either an integral number
        // or not a number at all
        return intchars ?
            *this :
            first(0);
    fractional_part_oct:
        C4_ASSERT(pos > 0);
        C4_ASSERT(str[pos - 1] == '.');
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c >= '0' && c <= '7')
            {
                fracchars = true;
            }
            else if(c == 'p' || c == 'P')
            {
                ++pos;
                goto power_part_oct; // NOLINT
            }
            else if(_is_delim_char(c))
            {
                return intchars || fracchars ? first(pos) : first(0);
            }
            else
            {
                return first(0);
            }
        }
        return intchars || fracchars ?
            *this :
            first(0);
    power_part_oct:
        C4_ASSERT(pos > 0);
        C4_ASSERT(str[pos - 1] == 'p' || str[pos - 1] == 'P');
        // either a + or a - is expected here, followed by more chars.
        // also, using (pos+1) in this check will cause an early
        // return when no more chars follow the sign.
        if(len <= (pos+1) || (str[pos] != '+' && str[pos] != '-') || ((!intchars) && (!fracchars)))
            return first(0);
        ++pos; // this was the sign.
        // ... so the (pos+1) ensures that we enter the loop and
        // hence that there exist chars in the power part
        powchars = false;
        for( ; pos < len; ++pos)
        {
            const char c = str[pos];
            if(c >= '0' && c <= '9')
                powchars = true;
            else if(powchars && _is_delim_char(c))
                return first(pos);
            else
                return first(0);
        }
        return *this;
    }

Referenced by c4::basic_substring< CC >::first_real_span().

next_split()

template<class C>

bool c4::basic_substring< C >::next_split ( C sep, size_t * start_pos, basic_substring< C > * out ) const

inline

returns true if the string has not been exhausted yet, meaning it's ok to call next_split() again.

When no instance of sep exists in the string, returns the full string. When the input is an empty string, the output string is the empty string.

Definition at line 1809 of file substr.hpp.

    {
        if C4_LIKELY(*start_pos < len)
        {
            for(size_t i = *start_pos; i < len; i++)
            {
                if(str[i] == sep)
                {
                    out->assign(str + *start_pos, i - *start_pos);
                    *start_pos = i+1;
                    return true;
                }
            }
            out->assign(str + *start_pos, len - *start_pos);
            *start_pos = len + 1;
            return true;
        }
        else
        {
            bool valid = len > 0 && (*start_pos == len);
            if(valid && str && str[len-1] == sep)
            {
                out->assign(str + len, size_t(0)); // the cast is needed to prevent overload ambiguity
            }
            else
            {
                out->assign(str + len + 1, size_t(0)); // the cast is needed to prevent overload ambiguity
            }
            *start_pos = len + 1;
            return valid;
        }
    }

split()

template<class C>

split_proxy c4::basic_substring< C >::split ( C sep, size_t start_pos = 0 ) const

inline

a view into the splits

Definition at line 1912 of file substr.hpp.

    {
        C4_XASSERT((start_pos >= 0 && start_pos < len) || empty());
        auto ss = sub(0, len);
        auto it = split_proxy(ss, start_pos, sep);
        return it;
    }

Referenced by c4::yml::location_format_with_context().

pop_right()

template<class C>

basic_substring c4::basic_substring< C >::pop_right ( C sep = C('/'), bool skip_empty = false ) const

inline

pop right: return the first split from the right.

Use gpop_left() to get the reciprocal part.

Definition at line 1925 of file substr.hpp.

    {
        if C4_LIKELY(len > 1)
        {
            auto pos = last_of(sep);
            if(pos != npos)
            {
                if(pos + 1 < len) // does not end with sep
                {
                    return sub(pos + 1); // return from sep to end
                }
                else // the string ends with sep
                {
                    if( ! skip_empty)
                    {
                        return sub(pos + 1, 0);
                    }
                    auto ppos = last_not_of(sep); // skip repeated seps
                    if(ppos == npos) // the string is all made of seps
                    {
                        return sub(0, 0);
                    }
                    // find the previous sep
                    auto pos0 = last_of(sep, ppos);
                    if(pos0 == npos) // only the last sep exists
                    {
                        return sub(0); // return the full string (because skip_empty is true)
                    }
                    ++pos0;
                    return sub(pos0);
                }
            }
            else // no sep was found, return the full string
            {
                return *this;
            }
        }
        else if(len == 1)
        {
            if(begins_with(sep))
            {
                return sub(0, 0);
            }
            return *this;
        }
        else // an empty string
        {
            return basic_substring();
        }
    }

pop_left()

template<class C>

basic_substring c4::basic_substring< C >::pop_left ( C sep = C('/'), bool skip_empty = false ) const

inline

return the first split from the left.

Use gpop_right() to get the reciprocal part.

Definition at line 1978 of file substr.hpp.

    {
        if C4_LIKELY(len > 1)
        {
            auto pos = first_of(sep);
            if(pos != npos)
            {
                if(pos > 0)  // does not start with sep
                {
                    return sub(0, pos); //  return everything up to it
                }
                else  // the string starts with sep
                {
                    if( ! skip_empty)
                    {
                        return sub(0, 0);
                    }
                    auto ppos = first_not_of(sep); // skip repeated seps
                    if(ppos == npos) // the string is all made of seps
                    {
                        return sub(0, 0);
                    }
                    // find the next sep
                    auto pos0 = first_of(sep, ppos);
                    if(pos0 == npos) // only the first sep exists
                    {
                        return sub(0); // return the full string (because skip_empty is true)
                    }
                    C4_XASSERT(pos0 > 0);
                    // return everything up to the second sep
                    return sub(0, pos0);
                }
            }
            else // no sep was found, return the full string
            {
                return sub(0);
            }
        }
        else if(len == 1)
        {
            if(begins_with(sep))
            {
                return sub(0, 0);
            }
            return sub(0);
        }
        else // an empty string
        {
            return basic_substring();
        }
    }

gpop_left()

template<class C>

basic_substring c4::basic_substring< C >::gpop_left ( C sep = C('/'), bool skip_empty = false ) const

inline

greedy pop left.

eg, csubstr("a/b/c").gpop_left('/')="c"

Definition at line 2033 of file substr.hpp.

    {
        auto ss = pop_right(sep, skip_empty);
        ss = left_of(ss);
        if(ss.find(sep) != npos)
        {
            if(ss.ends_with(sep))
            {
                if(skip_empty)
                {
                    ss = ss.trimr(sep);
                }
                else
                {
                    ss = ss.sub(0, ss.len-1); // safe to subtract because ends_with(sep) is true
                }
            }
        }
        return ss;
    }

gpop_right()

template<class C>

basic_substring c4::basic_substring< C >::gpop_right ( C sep = C('/'), bool skip_empty = false ) const

inline

greedy pop right.

eg, csubstr("a/b/c").gpop_right('/')="a"

Definition at line 2055 of file substr.hpp.

    {
        auto ss = pop_left(sep, skip_empty);
        ss = right_of(ss);
        if(ss.find(sep) != npos)
        {
            if(ss.begins_with(sep))
            {
                if(skip_empty)
                {
                    ss = ss.triml(sep);
                }
                else
                {
                    ss = ss.sub(1);
                }
            }
        }
        return ss;
    }

basename()

template<class C>

basic_substring c4::basic_substring< C >::basename ( C sep = C('/') ) const

inline

Definition at line 2083 of file substr.hpp.

    {
        auto ss = pop_right(sep, /*skip_empty*/true);
        ss = ss.trimr(sep);
        return ss;
    }

dirname()

template<class C>

basic_substring c4::basic_substring< C >::dirname ( C sep = C('/') ) const

inline

Definition at line 2090 of file substr.hpp.

    {
        auto ss = basename(sep);
        ss = ss.empty() ? *this : left_of(ss);
        return ss;
    }

name_wo_extshort()

template<class C>

basic_substring c4::basic_substring< C >::name_wo_extshort ( ) const

inline

Definition at line 2097 of file substr.hpp.

    {
        return gpop_left('.');
    }

name_wo_extlong()

template<class C>

basic_substring c4::basic_substring< C >::name_wo_extlong ( ) const

inline

Definition at line 2102 of file substr.hpp.

    {
        return pop_left('.');
    }

extshort()

template<class C>

basic_substring c4::basic_substring< C >::extshort ( ) const

inline

Definition at line 2107 of file substr.hpp.

    {
        return pop_right('.');
    }

extlong()

template<class C>

basic_substring c4::basic_substring< C >::extlong ( ) const

inline

Definition at line 2112 of file substr.hpp.

    {
        return gpop_right('.');
    }

toupper()

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::toupper ( ) ->typenamestd::enable_if<!std::is_const< U >::value, void >::type

inline

convert the string to upper-case

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2127 of file substr.hpp.

    {
        for(size_t i = 0; i < len; ++i)
        {
            str[i] = static_cast<C>(::toupper(str[i]));
        }
    }

Referenced by sample_substr().

tolower()

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::tolower ( ) ->typenamestd::enable_if<!std::is_const< U >::value, void >::type

inline

convert the string to lower-case

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2139 of file substr.hpp.

    {
        for(size_t i = 0; i < len; ++i)
        {
            str[i] = static_cast<C>(::tolower(str[i]));
        }
    }

Referenced by sample_substr().

fill()

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::fill ( C val ) ->typenamestd::enable_if<!std::is_const< U >::value, void >::type

inline

fill the entire contents with the given val

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2153 of file substr.hpp.

    {
        for(size_t i = 0; i < len; ++i)
            str[i] = val;
    }

Referenced by sample_substr(), c4::to_chars(), c4::to_chars(), and c4::to_chars().

copy_from() [1/2]

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::copy_from ( ro_substr that ) ->typenamestd::enable_if<!std::is_const< U >::value, void >::type

inline

copy a string to this substr, starting at 0

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2165 of file substr.hpp.

    {
        C4_ASSERT(!overlaps(that));
        size_t num = that.len <= len ? that.len : len;
        // calling memcpy with zero len is undefined behavior
        // and will wreak havoc in calling code's branches.
        // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
        if(num)
            memcpy(str, that.str, sizeof(C) * num);
    }

Referenced by c4::from_chars(), c4::from_chars(), c4::from_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), and c4::to_chars().

copy_from() [2/2]

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::copy_from ( ro_substr that, size_t ifirst, size_t num = npos )->typenamestd::enable_if<!std::is_const< U >::value, void >::type

inline

copy a string to this substr, starting at a specified given position

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2180 of file substr.hpp.

    {
        C4_ASSERT(ifirst >= 0 && ifirst <= len);
        num = num != npos ? num : len - ifirst;
        num = num < that.len ? num : that.len;
        C4_ASSERT(ifirst + num >= 0 && ifirst + num <= len);
        // calling memcpy with zero len is undefined behavior
        // and will wreak havoc in calling code's branches.
        // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
        if(num)
            memcpy(str + (sizeof(C) * ifirst), that.str, sizeof(C) * num);
    }

reverse()

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::reverse ( ) ->typenamestd::enable_if<!std::is_const< U >::value, void >::type

inline

reverse in place

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2199 of file substr.hpp.

    {
        if(len == 0) return;
        detail::_do_reverse(str, str + len - 1);
    }

Referenced by sample_substr().

reverse_sub()

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::reverse_sub ( size_t ifirst, size_t num )->typenamestd::enable_if<!std::is_const< U >::value, void >::type

inline

revert a subpart in place

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2209 of file substr.hpp.

    {
        C4_ASSERT(ifirst >= 0 && ifirst <= len);
        C4_ASSERT(ifirst + num >= 0 && ifirst + num <= len);
        if(num == 0) return;
        detail::_do_reverse(str + ifirst, str + ifirst + num - 1);
    }

Referenced by sample_substr().

reverse_range()

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::reverse_range ( size_t ifirst, size_t ilast )->typenamestd::enable_if<!std::is_const< U >::value, void >::type

inline

revert a range in place

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2221 of file substr.hpp.

    {
        C4_ASSERT(ifirst >= 0 && ifirst <= len);
        C4_ASSERT(ilast  >= 0 && ilast  <= len);
        if(ifirst == ilast) return;
        detail::_do_reverse(str + ifirst, str + ilast - 1);
    }

Referenced by sample_substr().

erase() [1/2]

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::erase ( size_t pos, size_t num )->typenamestd::enable_if<!std::is_const< U >::value, basic_substring >::type

inline

erase part of the string.

eg, with char s[] = "0123456789", substr(s).erase(3, 2) = "01256789", and s is now "0125678989"

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2236 of file substr.hpp.

    {
        C4_ASSERT(pos >= 0 && pos+num <= len);
        size_t num_to_move = len - pos - num;
        memmove(str + pos, str + pos + num, sizeof(C) * num_to_move);
        return basic_substring{str, len - num};
    }

erase_range()

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::erase_range ( size_t first, size_t last )->typenamestd::enable_if<!std::is_const< U >::value, basic_substring >::type

inline

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2247 of file substr.hpp.

    {
        C4_ASSERT(first <= last);
        return erase(first, static_cast<size_t>(last-first)); // NOLINT
    }

erase() [2/2]

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::erase ( ro_substr sub ) ->typenamestd::enable_if<!std::is_const< U >::value, basic_substring >::type

inline

erase a part of the string.

Note

sub must be a substring of this string

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2258 of file substr.hpp.

    {
        C4_ASSERT(is_super(sub));
        C4_ASSERT(sub.str >= str);
        return erase(static_cast<size_t>(sub.str - str), sub.len);
    }

replace() [1/2]

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::replace ( C value, C repl, size_t pos = 0 )->typenamestd::enable_if<!std::is_const< U >::value, size_t >::type

inline

replace every occurrence of character value with the character repl

Returns

the number of characters that were replaced

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2272 of file substr.hpp.

    {
        C4_ASSERT((pos >= 0 && pos <= len) || pos == npos);
        size_t did_it = 0;
        while((pos = find(value, pos)) != npos)
        {
            str[pos++] = repl;
            ++did_it;
        }
        return did_it;
    }

Referenced by sample_substr().

replace() [2/2]

template<class C>

template<typename U = C>

auto c4::basic_substring< C >::replace ( ro_substr chars, C repl, size_t pos = 0 )->typenamestd::enable_if<!std::is_const< U >::value, size_t >::type

inline

replace every occurrence of each character in value with the character repl.

Returns

the number of characters that were replaced

Note

this method requires that the string memory is writeable and is SFINAEd out for const C

Definition at line 2290 of file substr.hpp.

    {
        C4_ASSERT((pos >= 0 && pos <= len) || pos == npos);
        size_t did_it = 0;
        while((pos = first_of(chars, pos)) != npos)
        {
            str[pos++] = repl;
            ++did_it;
        }
        return did_it;
    }

replace_all()

template<class C>

size_t c4::basic_substring< C >::replace_all ( rw_substr dst, ro_substr pattern, ro_substr repl, size_t pos = 0 ) const

inline

replace pattern with repl, and write the result into dst.

pattern and repl don't need equal sizes.

Returns

the required size for dst. No overflow occurs if dst.len is smaller than the required size; this can be used to determine the required size for an existing container.

<

<

Definition at line 2309 of file substr.hpp.

    {
        C4_ASSERT( ! pattern.empty()); //!< @todo relax this precondition
        C4_ASSERT( ! this  ->overlaps(dst)); //!< @todo relax this precondition
        C4_ASSERT( ! pattern.overlaps(dst));
        C4_ASSERT( ! repl   .overlaps(dst));
        C4_ASSERT((pos >= 0 && pos <= len) || pos == npos);
        C4_SUPPRESS_WARNING_GCC_PUSH
        C4_SUPPRESS_WARNING_GCC("-Warray-bounds")  // gcc11 has a false positive here
        #if (!defined(__clang__)) && (defined(__GNUC__) && (__GNUC__ >= 7))
        C4_SUPPRESS_WARNING_GCC("-Wstringop-overflow")  // gcc11 has a false positive here
        #endif
        #define _c4append(first, last)                                  \
            {                                                           \
                C4_ASSERT((last) >= (first));                           \
                size_t num = static_cast<size_t>((last) - (first));     \
                if(num > 0 && sz + num <= dst.len)                      \
                {                                                       \
                    memcpy(dst.str + sz, first, num * sizeof(C));       \
                }                                                       \
                sz += num;                                              \
            }
        size_t sz = 0;
        size_t b = pos;
        _c4append(str, str + pos)
        do {
            size_t e = find(pattern, b);
            if(e == npos)
            {
                _c4append(str + b, str + len)
                break;
            }
            _c4append(str + b, str + e)
            _c4append(repl.begin(), repl.end())
            b = e + pattern.size();
        } while(b < len && b != npos);
        return sz;
        #undef _c4append
        C4_SUPPRESS_WARNING_GCC_POP
    }

Member Data Documentation

str

template<class C>

C* c4::basic_substring< C >::str

a restricted pointer to the first character of the substring

Definition at line 216 of file substr.hpp.

Referenced by c4::yml::extra::EventHandlerInts::alloc_arena(), c4::atod(), c4::atof(), c4::fmt::base64(), c4::fmt::base64(), c4::cat_sub(), c4::catsep_sub(), c4::fmt::cbase64(), c4::yml::Tree::copy_to_arena(), c4::decode_code_point(), c4::yml::emitrs_json(), c4::yml::emitrs_yaml(), c4::yml::escape_scalar(), c4::yml::escape_scalar_fn(), c4::yml::extra::estimate_events_ints_size(), c4::yml::estimate_tree_capacity(), c4::yml::extra::events_ints_print(), c4::yml::extra::events_ints_to_testsuite(), c4::basic_substring< CC >::find(), c4::basic_substring< CC >::first_int_span(), c4::basic_substring< CC >::first_not_of(), c4::basic_substring< CC >::first_not_of(), c4::basic_substring< CC >::first_of(), c4::basic_substring< CC >::first_real_span(), c4::basic_substring< CC >::first_uint_span(), c4::yml::format_exc(), c4::yml::format_exc(), c4::yml::format_exc(), c4::format_sub(), c4::from_chars(), c4::from_chars(), c4::from_chars(), c4::from_chars_first(), c4::yml::WriterBuf::get_result(), c4::yml::is_custom_tag(), c4::basic_substring< CC >::last_not_of(), c4::basic_substring< CC >::last_not_of(), c4::yml::Tree::location(), c4::yml::normalize_tag_long(), ErrorHandlerExample::on_error_basic(), ErrorHandlerExample::on_error_parse(), ErrorHandlerExample::on_error_visit(), c4::operator<<(), c4::yml::NodeRef::operator==(), c4::yml::Tree::reserve_arena(), c4::yml::TagDirectives::resolve(), c4::yml::FilterProcessorInplaceEndExtending::result(), c4::yml::FilterProcessorInplaceMidExtending::result(), c4::yml::FilterProcessorSrcDst::result(), sample_create_tree(), sample_deserialize_error(), sample_emit_to_container(), sample_empty_null_values(), sample_error_parse(), sample_error_visit_location(), sample_formatting(), sample_substr(), sample_tree_arena(), c4::yml::serialize_to_arena_str(), c4::yml::extra::EventHandlerInts::set_key_scalar_dquoted(), c4::yml::extra::EventHandlerInts::set_key_scalar_folded(), c4::yml::extra::EventHandlerInts::set_key_scalar_literal(), c4::yml::extra::EventHandlerInts::set_key_scalar_plain(), c4::yml::extra::EventHandlerInts::set_key_scalar_squoted(), c4::yml::extra::EventHandlerInts::set_key_tag(), c4::yml::extra::EventHandlerInts::set_val_scalar_dquoted(), c4::yml::extra::EventHandlerInts::set_val_scalar_folded(), c4::yml::extra::EventHandlerInts::set_val_scalar_literal(), c4::yml::extra::EventHandlerInts::set_val_scalar_plain(), c4::yml::extra::EventHandlerInts::set_val_scalar_squoted(), c4::yml::extra::EventHandlerInts::set_val_tag(), c4::yml::extra::EventHandlerInts::start_parse(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::yml::transform_tag(), and c4::yml::NodeType::type_str_sub().

len

template<class C>

size_t c4::basic_substring< C >::len

the length of the substring

Definition at line 218 of file substr.hpp.

Referenced by c4::yml::detail::_get_text_region(), c4::yml::extra::EventHandlerInts::alloc_arena(), c4::yml::extra::EventHandlerInts::arena(), c4::yml::extra::EventHandlerInts::arena_rem(), c4::atod(), c4::atod_first(), c4::atof(), c4::atof_first(), c4::atoi_first(), c4::atou_first(), c4::fmt::base64(), c4::fmt::base64(), c4::cat(), c4::cat_sub(), c4::catrs(), c4::catrs_append(), c4::catsep(), c4::catsep_sub(), c4::catseprs(), c4::catseprs_append(), c4::fmt::cbase64(), c4::yml::Tree::copy_to_arena(), c4::basic_substring< CC >::count(), c4::decode_code_point(), c4::yml::emitrs_json(), c4::yml::emitrs_yaml(), c4::yml::escape_scalar(), c4::yml::escape_scalar_fn(), c4::yml::extra::estimate_events_ints_size(), c4::yml::estimate_tree_capacity(), c4::yml::extra::events_ints_print(), c4::yml::extra::events_ints_to_testsuite(), c4::basic_substring< CC >::find(), c4::first_non_bom(), c4::basic_substring< CC >::first_not_of(), c4::basic_substring< CC >::first_not_of(), c4::basic_substring< CC >::first_of(), c4::basic_substring< CC >::first_real_span(), c4::yml::extra::EventHandlerInts::fits_buffers(), c4::format(), c4::yml::format_exc(), c4::yml::format_exc(), c4::yml::format_exc(), c4::format_sub(), c4::formatrs(), c4::formatrs_append(), c4::from_chars(), c4::from_chars(), c4::from_chars(), c4::from_chars(), c4::from_chars(), c4::from_chars(), c4::from_chars_first(), c4::from_chars_first(), c4::from_chars_first(), c4::yml::WriterBuf::get_result(), c4::yml::is_custom_tag(), c4::basic_substring< CC >::last_not_of(), c4::basic_substring< CC >::last_not_of(), c4::basic_substring< CC >::last_of(), c4::yml::location_format(), c4::yml::location_format_with_context(), c4::yml::normalize_tag_long(), ErrorHandlerExample::on_error_basic(), ErrorHandlerExample::on_error_parse(), ErrorHandlerExample::on_error_visit(), c4::operator<<(), c4::yml::NodeRef::operator==(), c4::yml::Tree::reserve_arena(), c4::yml::TagDirectives::resolve(), c4::yml::Tree::resolve_tag_sub(), c4::yml::Tree::lookup_result::resolved(), c4::yml::FilterProcessorInplaceEndExtending::result(), c4::yml::FilterProcessorInplaceMidExtending::result(), c4::yml::FilterProcessorSrcDst::result(), sample_base64(), sample_emit_to_container(), sample_empty_null_values(), sample_error_parse(), sample_error_visit_location(), sample_formatting(), sample_substr(), sample_tree_arena(), c4::basic_substring< CC >::select(), c4::yml::serialize_to_arena_scalar(), c4::yml::serialize_to_arena_str(), c4::yml::EventHandlerTree::set_key_anchor(), c4::yml::EventHandlerTree::set_key_ref(), c4::yml::extra::EventHandlerInts::set_key_scalar_dquoted(), c4::yml::extra::EventHandlerInts::set_key_scalar_folded(), c4::yml::extra::EventHandlerInts::set_key_scalar_literal(), c4::yml::extra::EventHandlerInts::set_key_scalar_plain(), c4::yml::extra::EventHandlerInts::set_key_scalar_squoted(), c4::yml::EventHandlerTree::set_key_tag(), c4::yml::extra::EventHandlerInts::set_key_tag(), c4::yml::EventHandlerTree::set_val_anchor(), c4::yml::EventHandlerTree::set_val_ref(), c4::yml::extra::EventHandlerInts::set_val_scalar_dquoted(), c4::yml::extra::EventHandlerInts::set_val_scalar_folded(), c4::yml::extra::EventHandlerInts::set_val_scalar_literal(), c4::yml::extra::EventHandlerInts::set_val_scalar_plain(), c4::yml::extra::EventHandlerInts::set_val_scalar_squoted(), c4::yml::EventHandlerTree::set_val_tag(), c4::yml::extra::EventHandlerInts::set_val_tag(), c4::yml::extra::EventHandlerInts::start_parse(), c4::basic_substring< CC >::stripl(), c4::basic_substring< CC >::stripr(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::to_chars(), c4::yml::extra::ievt::to_str_sub(), c4::yml::to_tag(), c4::yml::transform_tag(), c4::yml::NodeType::type_str_sub(), c4::uncat(), c4::uncatsep(), and c4::unformat().

---

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

• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/latest/ext/c4core.src/c4/substr.hpp