Add String::replace_char(s) methods for performance and convenience

[AThousandShips]

Will try do some performance comparison soon, but these replace in-place essentially, avoiding any COW or other manipulation, and also avoids creating any temporaries etc.

The multi-character one is optional but added for completeness for a few cases where multiple cases are replaced at once

Can expose to scripting if desired, but generally using characters is a bit more complicated in scripting so haven't added yet

Kept as separate commits for ease of editing until approval

See #92433 (comment)

A few more complex cases like String::validate_filename, OS::get_safe_dir_name, and get_csharp_project_name could be replaced using this, instead using a vector of characters, but for right now I keep this to the simple cases (mostly, see AnimationLibrary::validate_library_name for an exception)

See also:

• Add String::remove_char(s) methods for performance and convenience #92476

[AThousandShips]

Could have the keys be copied and then sorted here and use bsearch instead but not sure it'll be worth it generally, not expecting large arrays here so the difference between O(n) and O(log n) will be marginal compared to the copying and sorting

[Hilderin]

There's a const _null for the zero car.

[Hilderin]

Impressive work!!

I did some quick performance testing. I'm concern with the fact that each characters are copied one by one in the replace_char function even if the character is never found. With some testing, if the character is not found, the new replace_char function is slower then the current replace string. I put some suggestions in a version below for replace_char (note: I did not do extensive optimization on this code).

Test 1 (character replaced 14 times):

Source string: "C:\Projects\godot-jolt\build\windows-msvc-x64\External\Build\jolt\CMakeFiles_CMakeLTOTest-CXX\bin\CMakeFiles\boo.dir\Debug\main.cpp.obj"
Iterations: 1000000 times
Replacing \ for X

Using replace (string): 1200ms
Your version of replace_char: 320ms
Alternative version (see below): 300ms

Test 2 (character not replaced):

Source string: "C:\Projects\godot-jolt\build\windows-msvc-x64\External\Build\jolt\CMakeFiles_CMakeLTOTest-CXX\bin\CMakeFiles\boo.dir\Debug\main.cpp.obj"
Iterations: 1000000 times
Replacing * for X

Using replace (string): 160ms
Your version of replace_char: 320ms
Alternative version (see below): 140ms

Test 3 (small string 1 replace):

Source string: "te_st"
Iterations: 1000000 times
Replacing _ for X

Using replace (string): 425ms
Your version of replace_char: 150ms
Alternative version (see below): 140ms

Test 4 (small string and character not replaced):

Source string: "test"
Iterations: 1000000 times
Replacing _ for X

Using replace (string): 52ms
Your version of replace_char: 150ms
Alternative version (see below): 52ms

Alternative suggested version that does not update the string if search char not found and using memcpy:

String String::replace_char(char32_t p_key, char32_t p_with) const {
	ERR_FAIL_COND_V_MSG(p_with == 0, String(), "`with` must not be null.");

	int len = length();
	if (p_key == 0 || len == 0) {
		return *this;
	}

	int index = 0;
	const char32_t *old_ptr = ptr();
	for (; index < len; index++) {
		if (*old_ptr == p_key) {
			break;
		}
		++old_ptr;
	}

	if (index == len) {
		return *this;
	}

	String new_string;
	new_string.resize(len + 1);
	char32_t *new_ptrw = new_string.ptrw();

	memcpy(new_ptrw, ptr(), len * sizeof(char32_t));

	new_ptrw += index;
	*new_ptrw = p_with;

	++new_ptrw;
	++old_ptr;

	while (*old_ptr) {
		if (*old_ptr == p_key) {
			*new_ptrw = p_with;
		}
		++new_ptrw;
		++old_ptr;
	}

	*new_ptrw = _null;

	return new_string;
}

[AThousandShips]

I'll take a look and measure some between these, I have some theories, I feel a method checking for existence and then using my method for replacement might be faster as it accesses twice not thrice, but will see and compare

Thank you!