dymokomi/luce-browser-foundation
Source of release 0.6.0
0.6.0 / src / ak / string_utils.lucb
#==============================================================================================
#
# string_utils - StringUtils: matching, searching, trimming and replacing over StringViews
#
# DESCRIPTION:
# Port of AK/StringUtils.h (lines 1-119) and AK/StringUtils.cpp (lines 1-438). The
# AK_ENUM_BITWISE_OPERATORS(SplitBehavior) instantiations come first, as in the header.
#
#==============================================================================================
# mark: SplitBehavior operators =================================================================
## Ported from AK/StringUtils.h:57 AK::operator&= (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func and_assign(lhs: SplitBehavior*, rhs: SplitBehavior) -> SplitBehavior*:
*lhs = *lhs & rhs
return lhs
## Ported from AK/StringUtils.h:57 AK::operator& (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func bit_and(lhs: SplitBehavior, rhs: SplitBehavior) -> SplitBehavior:
return lhs & rhs
## Ported from AK/StringUtils.h:57 AK::operator~ (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func bit_not(rhs: SplitBehavior) -> SplitBehavior:
return ~rhs
## Ported from AK/StringUtils.h:57 AK::operator| (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func bit_or(lhs: SplitBehavior, rhs: SplitBehavior) -> SplitBehavior:
return lhs | rhs
## Ported from AK/StringUtils.h:57 AK::operator^ (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func bit_xor(lhs: SplitBehavior, rhs: SplitBehavior) -> SplitBehavior:
return lhs ^ rhs
## Ported from AK/StringUtils.h:57 AK::has_any_flag (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func has_any_flag(value: SplitBehavior, mask: SplitBehavior) -> bool:
return (u32)(value & mask) != 0
## Ported from AK/StringUtils.h:57 AK::has_flag (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func has_flag(value: SplitBehavior, mask: SplitBehavior) -> bool:
return (value & mask) == mask
## Ported from AK/StringUtils.h:57 AK::operator|= (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func or_assign(lhs: SplitBehavior*, rhs: SplitBehavior) -> SplitBehavior*:
*lhs = *lhs | rhs
return lhs
## Ported from AK/StringUtils.h:57 AK::operator^= (AK_ENUM_BITWISE_OPERATORS(SplitBehavior)).
pub func xor_assign(lhs: SplitBehavior*, rhs: SplitBehavior) -> SplitBehavior*:
*lhs = *lhs ^ rhs
return lhs
## Ported from AK/StringUtils.h:70 AK::MaskSpan::operator==.
pub func mask_span_eq(this: const MaskSpan*, other: MaskSpan) -> bool:
return this.start == other.start and this.length == other.length
# mark: Matching ================================================================================
## The `record_span` lambda of StringUtils::matches.
func string_utils_matches_record_span(match_spans: Vector[MaskSpan]*?, start: usize, length: usize):
if let spans = match_spans:
vector_append_t(spans, MaskSpan(start = start, length = length))
## Ported from AK/StringUtils.cpp:25 AK::StringUtils::matches: glob matching with `*`, `?` and
## `\` escapes, optionally recording the span each mask character matched.
pub func string_utils_matches(str_: StringView, mask: StringView, case_sensitivity: CaseSensitivity = CaseSensitivity.case_insensitive, match_spans: Vector[MaskSpan]*? = none) -> bool:
if string_view_equals(&mask, "*"):
string_utils_matches_record_span(match_spans, 0, string_view_length(&str_))
return true
# The C++ walks char pointers; these are offsets from the view starts.
let string_bytes = string_view_bytes(&str_)
let mask_bytes = string_view_bytes(&mask)
var string_ptr: usize = 0
let string_end = string_bytes.length
var mask_ptr: usize = 0
let mask_end = mask_bytes.length
while string_ptr < string_end and mask_ptr < mask_end:
let string_start_ptr = string_ptr
var exact = false
match mask_bytes[mask_ptr]:
'*':
if mask_ptr == mask_end - 1:
string_utils_matches_record_span(match_spans, string_ptr, string_end - string_ptr)
return true
while string_ptr < string_end and not string_utils_matches(string_view_substring_view(&str_, string_ptr), string_view_substring_view(&mask, mask_ptr + 1), case_sensitivity):
string_ptr += 1
string_utils_matches_record_span(match_spans, string_start_ptr, string_ptr - string_start_ptr)
string_ptr = string_ptr -% 1
'?':
string_utils_matches_record_span(match_spans, string_ptr, 1)
'\\':
# if backslash is last character in mask, just treat it as an exact match
# otherwise use it as escape for next character
if mask_ptr + 1 < mask_end:
mask_ptr += 1
exact = true # [[fallthrough]]
_:
exact = true
if exact:
let p = mask_bytes[mask_ptr]
let ch = string_bytes[string_ptr]
if (p != ch) if case_sensitivity == CaseSensitivity.case_sensitive else (to_ascii_lowercase(p) != to_ascii_lowercase(ch)):
return false
string_ptr = string_ptr +% 1
mask_ptr += 1
if string_ptr == string_end:
# Allow ending '*' to contain nothing.
while mask_ptr != mask_end and mask_bytes[mask_ptr] == '*':
string_utils_matches_record_span(match_spans, string_ptr, 0)
mask_ptr += 1
return string_ptr == string_end and mask_ptr == mask_end
## Ported from AK/StringUtils.cpp:87 AK::StringUtils::equals_ignoring_ascii_case.
pub func string_utils_equals_ignoring_ascii_case(a: StringView, b: StringView) -> bool:
if string_view_length(&a) != string_view_length(&b):
return false
let a_characters = string_view_bytes(&a)
let b_characters = string_view_bytes(&b)
for i in 0..<string_view_length(&a):
if to_ascii_lowercase(a_characters[i]) != to_ascii_lowercase(b_characters[i]):
return false
return true
## Ported from AK/StringUtils.cpp:98 AK::StringUtils::ends_with.
pub func string_utils_ends_with(str_: StringView, end: StringView, case_sensitivity: CaseSensitivity) -> bool:
if string_view_is_empty(&end):
return true
if string_view_is_empty(&str_):
return false
if string_view_length(&end) > string_view_length(&str_):
return false
let str_chars = string_view_bytes(&str_)
let end_chars = string_view_bytes(&end)
if case_sensitivity == CaseSensitivity.case_sensitive:
return compare_bytes(str_chars[(str_chars.length - end_chars.length)..], end_chars) == 0
var si = str_chars.length - end_chars.length
for ei in 0..<end_chars.length:
if to_ascii_lowercase(str_chars[si]) != to_ascii_lowercase(end_chars[ei]):
return false
si += 1
return true
## Ported from AK/StringUtils.cpp:121 AK::StringUtils::starts_with.
pub func string_utils_starts_with(str_: StringView, start: StringView, case_sensitivity: CaseSensitivity) -> bool:
if string_view_is_empty(&start):
return true
if string_view_is_empty(&str_):
return false
if string_view_length(&start) > string_view_length(&str_):
return false
if string_view_characters_without_null_termination(&str_) == string_view_characters_without_null_termination(&start):
return true
let str_chars = string_view_bytes(&str_)
let start_chars = string_view_bytes(&start)
if case_sensitivity == CaseSensitivity.case_sensitive:
return compare_bytes(str_chars, start_chars) == 0
for starti in 0..<start_chars.length:
if to_ascii_lowercase(str_chars[starti]) != to_ascii_lowercase(start_chars[starti]):
return false
return true
## Ported from AK/StringUtils.cpp:146 AK::StringUtils::contains.
pub func string_utils_contains(str_: StringView, needle: StringView, case_sensitivity: CaseSensitivity) -> bool:
if string_view_is_empty(&str_) or string_view_length(&needle) > string_view_length(&str_):
return false
if string_view_is_empty(&needle):
return true
let str_chars = string_view_bytes(&str_)
let needle_chars = string_view_bytes(&needle)
if case_sensitivity == CaseSensitivity.case_sensitive:
return memmem_optional(str_chars, needle_chars) != none
let needle_first = to_ascii_lowercase(needle_chars[0])
var si: usize = 0
while si < str_chars.length:
if to_ascii_lowercase(str_chars[si]) != needle_first:
si += 1
continue
var ni: usize = 0
while si + ni < str_chars.length:
if to_ascii_lowercase(str_chars[si + ni]) != to_ascii_lowercase(needle_chars[ni]):
if ni > 0:
si += ni - 1
break
if ni + 1 == needle_chars.length:
return true
ni += 1
si += 1
return false
## Ported from AK/StringUtils.cpp:174 AK::StringUtils::is_whitespace.
pub func string_utils_is_whitespace(str_: StringView) -> bool:
for ch in string_view_bytes(&str_):
if not is_ascii_space(ch):
return false
return true
## Ported from AK/StringUtils.cpp:179 AK::StringUtils::trim.
pub func string_utils_trim(str_: StringView, characters: StringView, mode: TrimMode) -> StringView:
var substring_start: usize = 0
var substring_length = string_view_length(&str_)
let str_chars = string_view_bytes(&str_)
if mode == TrimMode.left or mode == TrimMode.both:
for i in 0..<str_chars.length:
if substring_length == 0:
return sv("")
if not string_view_contains_u8(&characters, str_chars[i]):
break
substring_start += 1
substring_length -= 1
if mode == TrimMode.right or mode == TrimMode.both:
var i = str_chars.length
while i > 0:
if substring_length == 0:
return sv("")
if not string_view_contains_u8(&characters, str_chars[i - 1]):
break
substring_length -= 1
i -= 1
return string_view_substring_view_usize(&str_, substring_start, substring_length)
## Ported from AK/StringUtils.cpp:208 AK::StringUtils::trim_whitespace.
pub func string_utils_trim_whitespace(str_: StringView, mode: TrimMode) -> StringView:
return string_utils_trim(str_, sv(" \n\t\u{b}\u{c}\r"), mode)
# mark: Searching ===============================================================================
## Ported from AK/StringUtils.cpp:213 AK::StringUtils::find(StringView, char, size_t).
pub func string_utils_find_u8(haystack: StringView, needle: u8, start_offset: usize = 0) -> usize?:
if start_offset >= string_view_length(&haystack):
return none
let result = simdutf_find(string_view_bytes(&haystack)[start_offset..], needle) else return none
return result + start_offset
## Ported from AK/StringUtils.cpp:228 AK::StringUtils::find(StringView, StringView, size_t).
pub func string_utils_find_string_view(haystack: StringView, needle: StringView, start: usize = 0) -> usize?:
if start > string_view_length(&haystack):
return none
let index = memmem_optional(string_view_bytes(&haystack)[start..], string_view_bytes(&needle)) else return none
return index + start
## Ported from AK/StringUtils.cpp:238 AK::StringUtils::find_last(StringView, char).
pub func string_utils_find_last_u8(haystack: StringView, needle: u8) -> usize?:
let characters = string_view_bytes(&haystack)
var i = characters.length
while i > 0:
if characters[i - 1] == needle:
return i - 1
i -= 1
return none
## Ported from AK/StringUtils.cpp:247 AK::StringUtils::find_last(StringView, StringView).
pub func string_utils_find_last_string_view(haystack: StringView, needle: StringView) -> usize?:
if string_view_length(&needle) > string_view_length(&haystack):
return none
var i = string_view_length(&haystack) - string_view_length(&needle)
while true:
let candidate = string_view_substring_view_usize(&haystack, i, string_view_length(&needle))
if string_view_eq_string_view(&candidate, needle):
return i
if i == 0:
break
i -= 1
return none
## Ported from AK/StringUtils.cpp:263 AK::StringUtils::find_last_not.
pub func string_utils_find_last_not(haystack: StringView, needle: u8) -> usize?:
let characters = string_view_bytes(&haystack)
var i = characters.length
while i > 0:
if characters[i - 1] != needle:
return i - 1
i -= 1
return none
## Ported from AK/StringUtils.cpp:272 AK::StringUtils::find_all.
pub func string_utils_find_all(haystack: StringView, needle: StringView) -> Vector[usize]:
var positions: Vector[usize]
var current_position: usize = 0
while current_position <= string_view_length(&haystack):
let maybe_position = memmem_optional(string_view_bytes(&haystack)[current_position..], string_view_bytes(&needle)) else break
vector_append_t(&positions, current_position + maybe_position)
current_position += maybe_position + 1
return positions
## Ported from AK/StringUtils.cpp:288 AK::StringUtils::find_any_of.
pub func string_utils_find_any_of(haystack: StringView, needles: StringView, direction: SearchDirection) -> usize?:
if string_view_is_empty(&haystack) or string_view_is_empty(&needles):
return none
let characters = string_view_bytes(&haystack)
if direction == SearchDirection.forward:
for i in 0..<characters.length:
if string_view_contains_u8(&needles, characters[i]):
return i
elif direction == SearchDirection.backward:
var i = characters.length
while i > 0:
if string_view_contains_u8(&needles, characters[i - 1]):
return i - 1
i -= 1
return none
# mark: Case conversion =========================================================================
## The `should_insert_underscore` lambda of StringUtils::to_snakecase.
func string_utils_to_snakecase_should_insert_underscore(str_: const StringView*, i: usize, current_char: u8) -> bool:
if i == 0:
return false
let previous_ch = string_view_at(str_, i - 1)
if is_ascii_lower_alpha(previous_ch) and is_ascii_upper_alpha(current_char):
return true
if i >= string_view_length(str_) - 1:
return false
let next_ch = string_view_at(str_, i + 1)
if is_ascii_upper_alpha(current_char) and is_ascii_lower_alpha(next_ch):
return true
return false
## Ported from AK/StringUtils.cpp:306 AK::StringUtils::to_snakecase.
pub func string_utils_to_snakecase(str_: StringView) -> ByteString:
var builder = string_builder_new()
for i in 0..<string_view_length(&str_):
let ch = string_view_at(&str_, i)
if string_utils_to_snakecase_should_insert_underscore(&str_, i, ch):
string_builder_append_u8(&builder, '_')
string_builder_append_as_lowercase(&builder, ch)
return string_builder_to_byte_string(&builder)
## Ported from AK/StringUtils.cpp:332 AK::StringUtils::to_titlecase.
pub func string_utils_to_titlecase(str_: StringView) -> String:
var builder = string_builder_new()
var next_is_upper = true
for ch in string_view_bytes(&str_):
if next_is_upper:
string_builder_append_u8(&builder, (u8)to_ascii_uppercase(ch))
else:
string_builder_append_u8(&builder, (u8)to_ascii_lowercase(ch))
next_is_upper = ch == ' '
return string_builder_to_string(&builder) else trap("MUST: to_titlecase")
# mark: Replacing and counting ==================================================================
## Ported from AK/StringUtils.cpp:351 AK::StringUtils::replace_into_builder. Finishes the
## replacing algorithm once it is known that at least one replacement is going to be done.
## Otherwise the caller may want to follow a different route to construct its output.
func string_utils_replace_into_builder(str_: StringView, needle: StringView, replacement: StringView, replace_mode: ReplaceMode, first_replacement_position: usize) -> StringBuilder:
var replaced_string = string_builder_new()
string_builder_append_string_view(&replaced_string, string_view_substring_view_usize(&str_, 0, first_replacement_position))
string_builder_append_string_view(&replaced_string, replacement)
var remaining = string_view_substring_view(&str_, first_replacement_position + string_view_length(&needle))
# ReplaceMode::FirstOnly: we already made the first replacement.
if replace_mode == ReplaceMode.all:
while not string_view_is_empty(&remaining):
let maybe_pos = string_view_find_string_view(&remaining, needle) else break
string_builder_append_string_view(&replaced_string, string_view_substring_view_usize(&remaining, 0, maybe_pos))
string_builder_append_string_view(&replaced_string, replacement)
remaining = string_view_substring_view(&remaining, maybe_pos + string_view_length(&needle))
# The remaining bits either don't contain the needle or are ignored due to `replace_mode`
# being `ReplaceMode::FirstOnly`.
string_builder_append_string_view(&replaced_string, remaining)
return replaced_string
## Ported from AK/StringUtils.cpp:383 AK::StringUtils::replace(StringView, ...).
pub func string_utils_replace_string_view(str_: StringView, needle: StringView, replacement: StringView, replace_mode: ReplaceMode) -> ByteString:
if string_view_is_empty(&str_):
return byte_string_from_string_view(str_)
let maybe_first = string_view_find_string_view(&str_, needle) else return byte_string_from_string_view(str_)
var resulting_builder = string_utils_replace_into_builder(str_, needle, replacement, replace_mode, maybe_first)
return string_builder_to_byte_string(&resulting_builder)
## Ported from AK/StringUtils.cpp:397 AK::StringUtils::replace(String const&, ...).
pub func string_utils_replace_string(haystack: const String*, needle: StringView, replacement: StringView, replace_mode: ReplaceMode) -> String!:
if string_is_empty(haystack):
return *haystack
let source_bytes = string_bytes_as_string_view(haystack)
let maybe_first = string_view_find_string_view(&source_bytes, needle) else return *haystack
var resulting_builder = string_utils_replace_into_builder(source_bytes, needle, replacement, replace_mode, maybe_first)
return try string_builder_to_string(&resulting_builder)
## Ported from AK/StringUtils.cpp:413 AK::StringUtils::count(StringView, StringView).
pub func string_utils_count_string_view(str_: StringView, needle: StringView) -> usize:
if string_view_is_empty(&needle):
return string_view_length(&str_)
var count: usize = 0
var i: usize = 0
while i < string_view_length(&str_) -% string_view_length(&needle) +% 1:
let rest = string_view_substring_view(&str_, i)
if string_view_starts_with_string_view(&rest, needle):
count += 1
i += 1
return count
## Ported from AK/StringUtils.cpp:426 AK::StringUtils::count(StringView, char).
pub func string_utils_count_u8(str_: StringView, needle: u8) -> usize:
var count: usize = 0
for ch in string_view_bytes(&str_):
if ch == needle:
count += 1
return count