Inheritance diagram for const_string_range< ITERATOR_TYPE >:

Public Types
using	BASE_RANGE = ::range<ITERATOR_TYPE>

using	THIS_RANGE = ::const_string_range<ITERATOR_TYPE>

using	STRING_RANGE = ::string_range<ITERATOR_TYPE>

using	ITEM_POINTER = get_type_item_pointer<ITERATOR_TYPE>

using	ITEM = non_const<dereference<ITEM_POINTER> >

using	CHARACTER = ITEM

using	this_iterator = typename BASE_RANGE::this_iterator

using	iterator = typename BASE_RANGE::iterator

using	const_iterator = typename BASE_RANGE::const_iterator

using	THIS_RAW_RANGE = typename BASE_RANGE::THIS_RAW_RANGE

using	RAW_RANGE = typename BASE_RANGE::RAW_RANGE

using	CONST_RAW_RANGE = typename BASE_RANGE::CONST_RAW_RANGE

using	SCOPED_STRING = scoped_string_base<ITERATOR_TYPE>

using	ARG_ITEM = typename BASE_RANGE::ARG_ITEM

using	STRING = string_base < ITERATOR_TYPE >

using	STRING_ARRAY = ::string_array_base < STRING, STRING, e_type_string_array >

Public Types inherited from range< ITERATOR_TYPE >
using	this_iterator = ITERATOR_TYPE

using	iterator = get_iterator<ITERATOR_TYPE>

using	const_iterator = get_const_iterator<iterator>

using	THIS_RAW_RANGE = ::range<ITERATOR_TYPE>

using	RAW_RANGE = ::range<iterator>

using	CONST_RAW_RANGE = ::range<const_iterator>

using	THIS_RANGE = ::range<ITERATOR_TYPE>

using	RANGE = ::range<iterator>

using	CONST_RANGE = ::range<const_iterator>

using	ITEM_POINTER = get_type_item_pointer<iterator>

using	THIS_ITEM = get_iterator_item<ITERATOR_TYPE>

using	ITEM = non_const<THIS_ITEM>

using	CONST_ITEM = add_const<THIS_ITEM>

using	ARG_ITEM = argument_of < ITEM >

Public Member Functions
template<::std::size_t count>
constexpr	const_string_range (const ITEM(&array)[count])

template<primitive_integral INTEGRAL>
constexpr	const_string_range (const_iterator begin, INTEGRAL count)

	const_string_range (no_initialize_t)

	const_string_range (nullptr_t)

template<typed_range< iterator > RANGE>
	const_string_range (const RANGE &range)

template<typed_range< const_iterator > RANGE>
	const_string_range (const RANGE &range)

	const_string_range (const THIS_RANGE &range)

	const_string_range (THIS_RANGE &&range)

	const_string_range (this_iterator begin, this_iterator end)

	const_string_range (const ::block &block)

	const_string_range (ITERATOR_TYPE psz)

	const_string_range (ITERATOR_TYPE psz, character_count len)

	const_string_range (ITERATOR_TYPE psz, character_count start, character_count count)

const_string_range	subrange (character_count iFirst) const

const_string_range	subrange (const_iterator p) const

const_string_range	subrange (const_iterator p, character_count count) const

template<primitive_integral START, primitive_integral COUNT>
const_string_range	subrange (START start, COUNT count) const

template<primitive_integral START>
const_string_range	subrange (START start, const_iterator p) const

auto &	last () const

auto &	last (::collection::index i) const

auto	last_index () const

auto	last_index (::collection::index i) const

bool	is_trimmed_empty () const

void	clear ()

STRING_RANGE	operator() (character_count start, character_count count) const

STRING_RANGE	operator() (character_count start, const_iterator end) const

STRING_RANGE	operator() (const_iterator start) const

template<primitive_integral START>
STRING_RANGE	operator() (START start) const

STRING_RANGE	operator() () const

::end_of_line_and_next_line< const CHARACTER * >	end_of_line_and_next_line () const

bool	has_character () const

bool	is_empty () const noexcept

memsize	length_in_bytes () const

character_count	get_upper_bound (character_count i=-1) const noexcept

	operator::block () const

CHARACTER	character_at (character_count i) const

const CHARACTER *	data () const

	operator const CHARACTER * () const

const CHARACTER *	address_at (::collection::index i) const

const CHARACTER *	rear_address (::collection::index i) const

const CHARACTER &	operator[] (::collection::index i) const

character_count	index_of (const CHARACTER *p) const

THIS_RANGE	get_utf8_char () const

::std::strong_ordering	case_insensitive_order (const SCOPED_STRING &range) const noexcept

::std::strong_ordering	collate (const SCOPED_STRING &range) const noexcept

::std::strong_ordering	case_insensitive_collate (const SCOPED_STRING &range) const noexcept

bool	operator== (const THIS_RANGE &range) const

constexpr ::std::strong_ordering	_order (const SCOPED_STRING &range) const

constexpr ::std::strong_ordering	order (const SCOPED_STRING &range) const noexcept

constexpr ::std::strong_ordering	operator<=> (const SCOPED_STRING &range) const

constexpr bool	_equals (const SCOPED_STRING &range) const

constexpr bool	equals (const SCOPED_STRING &range) const

constexpr bool	case_insensitive_equals (const SCOPED_STRING &range) const noexcept

constexpr const_iterator	_find (const SCOPED_STRING &range) const

constexpr const_iterator	find (const SCOPED_STRING &range) const

constexpr character_count	find_index (const SCOPED_STRING &range, character_count start=0) const

constexpr character_count	find_index (CHARACTER ch, character_count start=0) const

constexpr const_iterator	_rear_find (const SCOPED_STRING &range, const_iterator end=nullptr) const

constexpr const_iterator	rear_find (const SCOPED_STRING &range, const_iterator end=nullptr) const

constexpr character_count	_rear_find_index (const SCOPED_STRING &range, character_count end=-1) const

constexpr character_count	rear_find_index (const SCOPED_STRING &range, character_count end=-1) const

constexpr const_iterator	_rear_find (CHARACTER character, const_iterator end=nullptr) const

constexpr const_iterator	rear_find (CHARACTER character, const_iterator end=nullptr) const

constexpr character_count	_rear_find_index (CHARACTER character, character_count end=-1) const

constexpr character_count	rear_find_index (CHARACTER character, character_count end=-1) const

const_iterator	case_insensitive_find (const SCOPED_STRING &scopedstr) const RELEASENOTHROW

character_count	case_insensitive_find_index (const SCOPED_STRING &scopedstr) const RELEASENOTHROW

character_count	case_insensitive_find_index (const SCOPED_STRING &scopedstr, character_count start) const RELEASENOTHROW

constexpr const_iterator	_case_insensitive_rear_find (const SCOPED_STRING &scopedstr) const

character_count	_case_insensitive_rear_find_index (const SCOPED_STRING &scopedstr, character_count end=-1) const RELEASENOTHROW

constexpr const_iterator	case_insensitive_rear_find (const SCOPED_STRING &scopedstr) const

character_count	case_insensitive_rear_find_index (const SCOPED_STRING &scopedstr, character_count end=-1) const RELEASENOTHROW

constexpr const_iterator	_find_first_character_in (const SCOPED_STRING &range) const

constexpr character_count	_find_first_character_in_index (const SCOPED_STRING &range) const

constexpr const_iterator	find_first_character_in (const SCOPED_STRING &range) const

constexpr character_count	find_first_character_in_index (const SCOPED_STRING &range, ::character_count start=0) const

string_base< ITERATOR_TYPE >	lowered () const

constexpr THIS_RAW_RANGE	skip_any_character_in (const SCOPED_STRING &range) const

constexpr character_count	skip_any_character_in_index (const SCOPED_STRING &range, ::character_count start=0) const

constexpr const_iterator	_rear_skip_any_character_in (const SCOPED_STRING &range) const noexcept

constexpr const_iterator	rear_skip_any_character_in (const SCOPED_STRING &range) const noexcept

constexpr const_iterator	_skip (CHARACTER item) const

constexpr const_iterator	skip (CHARACTER item) const

constexpr const_iterator	_rear_find_first_character_in (const SCOPED_STRING &range) const noexcept

constexpr const_iterator	rear_find_first_character_in (const SCOPED_STRING &range) const noexcept

constexpr bool	_begins (const SCOPED_STRING &range) const

constexpr bool	begins (const SCOPED_STRING &range) const

::collection::count	begins_count (bool(*character_is_function)(CHARACTER character)) const

constexpr bool	_ends (const SCOPED_STRING &range) const

constexpr bool	ends (const SCOPED_STRING &range) const

template<typename PRED>
bool	is_every_char (PRED pred) const

template<typename NUMBER>
NUMBER &	translate_index (NUMBER &number) const

bool	contains (const SCOPED_STRING &scopedstr=0) const

bool	contains (CHARACTER ch) const

bool	contains (const SCOPED_STRING &scopedstr, const CHARACTER ppszBeg, const CHARACTER ppszEnd=nullptr) const

template<primitive_array STRING_ARRAY>
bool	contains_any (const STRING_ARRAY &stra) const

template<primitive_array STRING_ARRAY>
bool	contains_all (const STRING_ARRAY &stra) const

bool	case_insensitive_contains (const SCOPED_STRING &scopedstr=0) const

bool	case_insensitive_contains (const SCOPED_STRING &scopedstr, const CHARACTER ppszBeg, const CHARACTER ppszEnd=nullptr) const

template<primitive_array STRING_ARRAY>
bool	case_insensitive_contains_at_least_one_of (const STRING_ARRAY &stra) const

template<primitive_array STRING_ARRAY>
bool	case_insensitive_contains_all (const STRING_ARRAY &stra) const

bool	unicode_case_insensitive_contains (const SCOPED_STRING &scopedstr=0) const

bool	unicode_case_insensitive_contains (const SCOPED_STRING &scopedstr, const CHARACTER ppszBeg, const CHARACTER ppszEnd=nullptr) const

template<primitive_array STRING_ARRAY>
bool	unicode_case_insensitive_contains_at_least_one_of (const STRING_ARRAY &stra) const

template<primitive_array STRING_ARRAY>
bool	unicode_case_insensitive_contains_all (const STRING_ARRAY &stra) const

template<::comparison::equality< CHARACTER > EQUALITY>
::collection::count	_occurrence_count_of (const SCOPED_STRING &scopedstr, EQUALITY equality) const

::collection::count	occurrence_count_of (const SCOPED_STRING &scopedstr=0) const

::collection::count	case_insensitive_occurrence_count_of (const SCOPED_STRING &scopedstr=0) const

const_iterator	find (CHARACTER ch) const RELEASENOTHROW

const_iterator	case_insensitive_find (CHARACTER ch) const RELEASENOTHROW

character_count	case_insensitive_find_index (CHARACTER ch) const RELEASENOTHROW

character_count	case_insensitive_find_index (CHARACTER ch, character_count start) const RELEASENOTHROW

const_iterator	find_skip_or_end (CHARACTER ch=0) const RELEASENOTHROW

const_iterator	find_first_whitespace () const RELEASENOTHROW

THIS_RAW_RANGE	skip_whitespace () const RELEASENOTHROW

::character_count	count_left (const SCOPED_STRING &range="\t\r\n ") const RELEASENOTHROW

const_iterator	rear_find_first_whitespace () const RELEASENOTHROW

const_iterator	rear_skip_whitespace () const RELEASENOTHROW

::character_count	count_right (const SCOPED_STRING &range="\t\r\n ") const RELEASENOTHROW

::character_count	count_left_and_right (const SCOPED_STRING &range="\t\r\n ") const RELEASENOTHROW

const_string_range &	operator= (const THIS_RANGE &range)

const_string_range &	operator= (const_string_range &&range)

const_string_range &	operator= (const block &block)

bool	case_insensitive_begins (const SCOPED_STRING &scopedstrPrefix) const

bool	case_insensitive_ends (const SCOPED_STRING &scopedstrSuffix) const

const_iterator	unicode_find (const SCOPED_STRING &scopedstr) const RELEASENOTHROW
	Find the first occurrence of `scopedstr`, starting at `start` position and up to `count` characters from `start`. Optionally returns at `ppszTail` the address immediately after where `scopedstr` was found in the string.

const_iterator	unicode_case_insensitive_find (const SCOPED_STRING &scopedstr) const RELEASENOTHROW

::collection::index	unicode_case_insensitive_find_index (const SCOPED_STRING &scopedstr, character_count start=0) const RELEASENOTHROW

const_iterator	unicode_rear_find (const SCOPED_STRING &scopedstr) const RELEASENOTHROW

const_iterator	unicode_case_insensitive_rear_find (const SCOPED_STRING &scopedstr) const RELEASENOTHROW

const_iterator	find_first (CHARACTER chSeparator, ::character_count start=0) const RELEASENOTHROW
	character_count _find_first_character_in(const CHARACTER * blockCharacters, character_count iStart = 0) const RELEASENOTHROW;

const_iterator	_rear_skip (CHARACTER ca) const RELEASENOTHROW

const_iterator	rear_skip (CHARACTER ca) const RELEASENOTHROW

CHARACTER	last_char (character_count count=-1) const

character_count	unichar_count () const

const_iterator	unichar_at (character_count iUnicharIndex) const

bool	operator== (const ::ansi_string &str) const

bool	operator== (const ::wd16_string &str) const

bool	operator== (const ::wd32_string &str) const

bool	operator== (const ::ansi_character *psz) const

bool	operator== (const ::wd16_character *psz) const

bool	operator== (const ::wd32_character *psz) const

bool	operator== (const ::inline_number_string &inline_number_string) const

bool	xml_is_comment () const

::std::strong_ordering	escape_case_insensitive_count_order (const ::scoped_string &scopedstr, int escape) const

STRING	surrounded (const SCOPED_STRING &scopedstr) const

STRING	surrounded (const SCOPED_STRING &scopedstrLeft, const SCOPED_STRING &scopedstrRight) const

STRING	double_quoted (bool bEscape=false) const

STRING	single_quoted (bool bEscape) const

STRING_ARRAY	explode (const SCOPED_STRING &scopedstrSeparator, bool bAddEmpty=true) const

::collection::count	_count_parts_from_beginning (::collection::count cPathPartCountToConsume, CHARACTER chSeparator)

::collection::count	count_parts_from_beginning (::collection::count cPathPartCountToConsume, CHARACTER chSeparator)

STRING_RANGE	_get_count_parts_from_beginning (::collection::count cPathPartCountToConsume, CHARACTER chSeparator) const

STRING_RANGE	get_count_parts_from_beginning (::collection::count cPathPartCountToConsume, CHARACTER chSeparator) const

template<typename ITERATOR_TYPE>
	const_string_range (const block &block)

template<primitive_array A_STRING_ARRAY>
bool	contains_any (const A_STRING_ARRAY &stra) const

template<primitive_array A_STRING_ARRAY>
bool	contains_all (const A_STRING_ARRAY &stra) const

template<primitive_array A_STRING_ARRAY>
bool	case_insensitive_contains_at_least_one_of (const A_STRING_ARRAY &stra) const

template<primitive_array A_STRING_ARRAY>
bool	case_insensitive_contains_all (const A_STRING_ARRAY &stra) const

template<primitive_array A_STRING_ARRAY>
bool	unicode_case_insensitive_contains_at_least_one_of (const A_STRING_ARRAY &stra) const

template<primitive_array A_STRING_ARRAY>
bool	unicode_case_insensitive_contains_all (const A_STRING_ARRAY &stra) const

template<primitive_integral START, primitive_integral COUNT>
const_string_range< ITERATOR_TYPE >	subrange (START start, COUNT count) const

template<::comparison::ordering< ITEM > ORDERING>
constexpr ::std::strong_ordering	_order (const THIS_RAW_RANGE &rangeBlock, ORDERING ordering) const

template<::comparison::ordering< ITEM > ORDERING>
constexpr ::std::strong_ordering	order (const THIS_RAW_RANGE &rangeBlock, ORDERING ordering) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	_equals (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	equals (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_find (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	find (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_find (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_find (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_find (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_find (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_find_first_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	find_first_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr THIS_RAW_RANGE	_skip_any_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	skip_any_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_skip_any_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_skip_any_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_skip (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	skip (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_find_first_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_find_first_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	_begins (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	begins (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	_ends (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	ends (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_skip (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_skip (ARG_ITEM item, EQUALITY equality) const

Public Member Functions inherited from range< ITERATOR_TYPE >
constexpr	range (no_initialize_t)

constexpr	range (nullptr_t)

constexpr	range (const range &range)

constexpr	range (range &&range)

template<typed_range< iterator > RANGE>
constexpr	range (const RANGE &range)

template<typed_range< const_iterator > RANGE>
constexpr	range (const RANGE &range)

template<typename TYPE>
constexpr	range (TYPE *&p)

template<::collection::count count>
constexpr	range (const ITEM(&array)[count], e_range erange=e_range_none)

template<primitive_integral INTEGRAL>
constexpr	range (this_iterator begin, INTEGRAL count, e_range erange=e_range_none)

constexpr	range (this_iterator begin, this_iterator end, e_range erange=e_range_none)

template<::comparison::equality< ITEM > EQUALITY>
constexpr	range (this_iterator begin, EQUALITY equality)

range &	operator= (const range &range)

range &	operator= (range &&range)

void	add_initializer_list (const ::std::initializer_list< ITEM > &initializer_list)

constexpr bool	is_string () const

void	set_string_flag ()

void	clear_string_flag ()

template<primitive_integral START>
constexpr THIS_RAW_RANGE	operator() (START start) const

template<primitive_integral START, primitive_integral COUNT>
constexpr THIS_RAW_RANGE	operator() (START start, COUNT count) const

template<primitive_integral START>
constexpr THIS_RAW_RANGE	operator() (START start)

template<primitive_integral START, primitive_integral COUNT>
THIS_RAW_RANGE	operator() (START start, COUNT count)

constexpr auto	index_of (const_iterator p) const

this_iterator &	begin ()

this_iterator &	end ()

const_iterator	begin () const

const_iterator	end () const

this_iterator &	begin (this_iterator begin)

this_iterator &	end (this_iterator end)

auto &	first ()

auto &	first () const

constexpr this_iterator	data ()

constexpr const this_iterator	data () const

constexpr ::collection::count	size () const

constexpr bool	is_empty () const

constexpr bool	is_set () const

bool	operator! () const

constexpr bool	is_before_begin (const_iterator iterator) const

constexpr bool	is_end (const_iterator iterator) const

constexpr bool	iterator_ok (const_iterator iterator) const

constexpr THIS_RAW_RANGE	_start_range (memsize start) const

constexpr THIS_RAW_RANGE	_end_range (const_iterator end) const

constexpr THIS_RAW_RANGE	_start_count_range (memsize start, memsize count) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	_equals (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	equals (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::ordering< ITEM > ORDERING>
constexpr ::std::strong_ordering	_order (const THIS_RAW_RANGE &rangeBlock, ORDERING ordering) const

template<::comparison::ordering< ITEM > ORDERING>
constexpr ::std::strong_ordering	order (const THIS_RAW_RANGE &rangeBlock, ORDERING ordering) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_find (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	find (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_find (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_find (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr THIS_RAW_RANGE	_skip_any_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	skip_any_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_find_first_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	find_first_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_find_first_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_find_first_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_skip (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	skip (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_skip (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_skip (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_find (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_find (ARG_ITEM item, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	_rear_skip_any_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr const_iterator	rear_skip_any_character_in (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	_begins (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	begins (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	_ends (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

template<::comparison::equality< ITEM > EQUALITY>
constexpr bool	ends (const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) const

Additional Inherited Members
Static Public Member Functions inherited from range< ITERATOR_TYPE >
static consteval memsize	item_size ()

static constexpr bool	_initialize_equals (bool &b, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock)

template<::comparison::equality< ITEM > EQUALITY>
static constexpr bool	_static_equals (THIS_RAW_RANGE range, THIS_RAW_RANGE rangeBlock, EQUALITY equality)

template<::comparison::equality< ITEM > EQUALITY>
static constexpr bool	static_equals (const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality)

static constexpr bool	_initialize_order (::std::strong_ordering &order, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock)

template<::comparison::ordering< ITEM > ORDERING>
static constexpr auto	_static_order (THIS_RAW_RANGE range, THIS_RAW_RANGE rangeBlock, ORDERING ordering)

template<::comparison::ordering< ITEM > ORDERING>
static constexpr ::std::strong_ordering	static_order (const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock, ORDERING ordering)

static bool	_initialize_find (const_iterator &p, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock)

template<::comparison::equality< ITEM > EQUALITY>
static const_iterator	_static_find (THIS_RAW_RANGE range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality)

template<::comparison::equality< ITEM > EQUALITY>
static const_iterator	static_find (const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality)

static bool	_initialize_rear_find (const_iterator &p, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock)

template<::comparison::equality< ITEM > EQUALITY>
static const_iterator	_static_rear_find (THIS_RAW_RANGE range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality)

template<::comparison::equality< ITEM > EQUALITY>
static const_iterator	static_rear_find (const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality)

static constexpr bool	_initialize_skip_any_character_in (const_iterator &p, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr THIS_RAW_RANGE	_static_skip_any_character_in (THIS_RAW_RANGE range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	static_skip_any_character_in (const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

static constexpr bool	_initialize_find_first_character_in (const_iterator &p, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	_static_find_first_character_in (THIS_RAW_RANGE range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	static_find_first_character_in (const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

static constexpr bool	_initialize_rear_find_first_character_in (const_iterator &p, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	_static_rear_find_first_character_in (THIS_RAW_RANGE range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	static_rear_find_first_character_in (THIS_RAW_RANGE range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

static constexpr bool	_initialize_skip (const_iterator &p, const THIS_RAW_RANGE &range) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	_static_skip (THIS_RAW_RANGE range, ARG_ITEM item, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	static_skip (const THIS_RAW_RANGE &range, ARG_ITEM item, EQUALITY equality) noexcept

static constexpr bool	_initialize_rear_skip (const_iterator &p, const THIS_RAW_RANGE &range) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	_static_rear_skip (THIS_RAW_RANGE range, ARG_ITEM item, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	static_rear_skip (const THIS_RAW_RANGE &range, ARG_ITEM item, EQUALITY equality) noexcept

static constexpr bool	_initialize_find_item (const_iterator &p, const THIS_RAW_RANGE &range) noexcept

static constexpr bool	_initialize_rear_find (const_iterator &p, const THIS_RAW_RANGE &range) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	_static_rear_find (THIS_RAW_RANGE range, ARG_ITEM item, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	static_rear_find (THIS_RAW_RANGE range, ARG_ITEM item, EQUALITY equality) noexcept

static constexpr bool	_initialize_rear_skip_any_character_in (const_iterator &p, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	_static_rear_skip_any_character_in (THIS_RAW_RANGE range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr const_iterator	static_rear_skip_any_character_in (THIS_RAW_RANGE range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

static constexpr bool	_initialize_contains (bool &b, const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr bool	_static_begins (THIS_RAW_RANGE range, THIS_RAW_RANGE rangeBlock, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr bool	static_begins (const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr bool	_static_ends (THIS_RAW_RANGE range, THIS_RAW_RANGE rangeBlock, EQUALITY equality) noexcept

template<::comparison::equality< ITEM > EQUALITY>
static constexpr bool	static_ends (const THIS_RAW_RANGE &range, const THIS_RAW_RANGE &rangeBlock, EQUALITY equality) noexcept

Public Attributes inherited from range< ITERATOR_TYPE >
this_iterator	m_begin

this_iterator	m_end

e_range	m_erange

Member Function Documentation

◆ escape_case_insensitive_count_order()

template<typename ITERATOR_TYPE>

std::strong_ordering const_string_range< ITERATOR_TYPE >::escape_case_insensitive_count_order	(	const ::scoped_string &	scopedstr,
		int	escape ) const

======================================================== Name : _tcsenicmp Desc : similar with case_insensitive_ansi_count_compare with escape process Param : escape - will be escape character

Return :

Coder Date Desc

bro 2002-10-29

◆ unicode_find()

template<typename ITERATOR_TYPE>

const_string_range< ITERATOR_TYPE >::const_iterator const_string_range< ITERATOR_TYPE >::unicode_find ( const SCOPED_STRING & scopedstr ) const

inline

Find the first occurrence of scopedstr, starting at start position and up to count characters from start. Optionally returns at ppszTail the address immediately after where scopedstr was found in the string.

Parameters

scopedstr	[in] scopedstr to search for.
start	[in] position where to start the start.
count	[in] amount of characters since `start` to continue searching for `scopedstr` was found in the string.

Returns: position where scopedstr was found respecting start and count or -1 if not found.

The documentation for this class was generated from the following files:

prototype/string/const_string_range.h
prototype/prototype/_impl_atom.h
prototype/string/_const_string_range_impl.h
prototype/string/_impl.h
prototype/string/_impl_string_base.h
prototype/string/_string_range_impl.h
prototype/string/mutable_string_range.h
prototype/string/string_base.h

Public Types

Public Member Functions

Additional Inherited Members

Member Function Documentation

◆ escape_case_insensitive_count_order()

Return :

bro 2002-10-29

◆ unicode_find()