asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/core/string/ustring.h

574 lines
22 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* ustring.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
[Complex Text Layouts] Implement TextServer interface. Implement Fallback TextServer.
2020-08-05 08:25:28 +02:00
#ifndef USTRING_GODOT_H
#define USTRING_GODOT_H
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Style: Cleanup header guards for consistency Fix file names for {Static,Lightmap}RaycasterEmbree.
2022-09-26 13:03:44 +02:00
// Note: _GODOT suffix added to header guard to avoid conflict with ICU header.
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 09:32:20 +01:00
#include "core/string/char_utils.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/templates/cowdata.h"
#include "core/templates/vector.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 18:13:45 +02:00
#include "core/typedefs.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/variant/array.h"
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
/*************************************************************************/
/* CharProxy */
/*************************************************************************/
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
template <class T>
class CharProxy {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
friend class Char16String;
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
friend class CharString;
friend class String;
const int _index;
CowData<T> &_cowdata;
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
static const T _null = 0;
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
CharProxy: Add copy constructor Adding the copy constructor is needed to solve a `-Wdeprecated-copy` warning from GCC and Clang, which is raised when upgrading doctest from 2.4.4 to 2.4.6.
2021-09-30 23:02:41 +02:00
_FORCE_INLINE_ CharProxy(const int &p_index, CowData<T> &p_cowdata) :
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
_index(p_index),
CharProxy: Add copy constructor Adding the copy constructor is needed to solve a `-Wdeprecated-copy` warning from GCC and Clang, which is raised when upgrading doctest from 2.4.4 to 2.4.6.
2021-09-30 23:02:41 +02:00
_cowdata(p_cowdata) {}
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
public:
CharProxy: Add copy constructor Adding the copy constructor is needed to solve a `-Wdeprecated-copy` warning from GCC and Clang, which is raised when upgrading doctest from 2.4.4 to 2.4.6.
2021-09-30 23:02:41 +02:00
_FORCE_INLINE_ CharProxy(const CharProxy<T> &p_other) :
_index(p_other._index),
_cowdata(p_other._cowdata) {}
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
_FORCE_INLINE_ operator T() const {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (unlikely(_index == _cowdata.size())) {
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
return _null;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
return _cowdata.get(_index);
}
_FORCE_INLINE_ const T *operator&() const {
return _cowdata.ptr() + _index;
}
CharProxy: Add copy constructor Adding the copy constructor is needed to solve a `-Wdeprecated-copy` warning from GCC and Clang, which is raised when upgrading doctest from 2.4.4 to 2.4.6.
2021-09-30 23:02:41 +02:00
_FORCE_INLINE_ void operator=(const T &p_other) const {
_cowdata.set(_index, p_other);
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
}
CharProxy: Add copy constructor Adding the copy constructor is needed to solve a `-Wdeprecated-copy` warning from GCC and Clang, which is raised when upgrading doctest from 2.4.4 to 2.4.6.
2021-09-30 23:02:41 +02:00
_FORCE_INLINE_ void operator=(const CharProxy<T> &p_other) const {
_cowdata.set(_index, p_other.operator T());
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
}
};
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
/*************************************************************************/
/* Char16String */
/*************************************************************************/
class Char16String {
CowData<char16_t> _cowdata;
static const char16_t _null;
public:
_FORCE_INLINE_ char16_t *ptrw() { return _cowdata.ptrw(); }
_FORCE_INLINE_ const char16_t *ptr() const { return _cowdata.ptr(); }
_FORCE_INLINE_ int size() const { return _cowdata.size(); }
Error resize(int p_size) { return _cowdata.resize(p_size); }
_FORCE_INLINE_ char16_t get(int p_index) const { return _cowdata.get(p_index); }
_FORCE_INLINE_ void set(int p_index, const char16_t &p_elem) { _cowdata.set(p_index, p_elem); }
_FORCE_INLINE_ const char16_t &operator[](int p_index) const {
if (unlikely(p_index == _cowdata.size())) {
return _null;
}
return _cowdata.get(p_index);
}
_FORCE_INLINE_ CharProxy<char16_t> operator[](int p_index) { return CharProxy<char16_t>(p_index, _cowdata); }
_FORCE_INLINE_ Char16String() {}
_FORCE_INLINE_ Char16String(const Char16String &p_str) { _cowdata._ref(p_str._cowdata); }
Don't return reference on copy assignment operators We prefer to prevent using chained assignment (`T a = b = c = T();`) as this can lead to confusing code and subtle bugs. According to https://en.wikipedia.org/wiki/Assignment_operator_(C%2B%2B), C++ allows any arbitrary return type, so this is standard compliant. This could be re-assessed if/when we have an actual need for a behavior more akin to that of the C++ STL, for now this PR simply changes a handful of cases which were inconsistent with the rest of the codebase (`void` return type was already the most common case prior to this commit).
2021-11-30 15:19:26 +01:00
_FORCE_INLINE_ void operator=(const Char16String &p_str) { _cowdata._ref(p_str._cowdata); }
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
_FORCE_INLINE_ Char16String(const char16_t *p_cstr) { copy_from(p_cstr); }
Don't return reference on copy assignment operators We prefer to prevent using chained assignment (`T a = b = c = T();`) as this can lead to confusing code and subtle bugs. According to https://en.wikipedia.org/wiki/Assignment_operator_(C%2B%2B), C++ allows any arbitrary return type, so this is standard compliant. This could be re-assessed if/when we have an actual need for a behavior more akin to that of the C++ STL, for now this PR simply changes a handful of cases which were inconsistent with the rest of the codebase (`void` return type was already the most common case prior to this commit).
2021-11-30 15:19:26 +01:00
void operator=(const char16_t *p_cstr);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
bool operator<(const Char16String &p_right) const;
Char16String &operator+=(char16_t p_char);
int length() const { return size() ? size() - 1 : 0; }
const char16_t *get_data() const;
operator const char16_t *() const { return get_data(); };
protected:
void copy_from(const char16_t *p_cstr);
};
/*************************************************************************/
/* CharString */
/*************************************************************************/
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
class CharString {
CowData<char> _cowdata;
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
static const char _null;
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
remove trailing whitespace
2016-03-09 00:00:52 +01:00
public:
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
_FORCE_INLINE_ char *ptrw() { return _cowdata.ptrw(); }
_FORCE_INLINE_ const char *ptr() const { return _cowdata.ptr(); }
_FORCE_INLINE_ int size() const { return _cowdata.size(); }
Error resize(int p_size) { return _cowdata.resize(p_size); }
Fix warnings seen with -Wignored-qualifiers.
2019-02-21 20:24:29 +01:00
_FORCE_INLINE_ char get(int p_index) const { return _cowdata.get(p_index); }
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
_FORCE_INLINE_ void set(int p_index, const char &p_elem) { _cowdata.set(p_index, p_elem); }
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
_FORCE_INLINE_ const char &operator[](int p_index) const {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (unlikely(p_index == _cowdata.size())) {
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
return _null;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
return _cowdata.get(p_index);
}
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
_FORCE_INLINE_ CharProxy<char> operator[](int p_index) { return CharProxy<char>(p_index, _cowdata); }
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
_FORCE_INLINE_ CharString() {}
_FORCE_INLINE_ CharString(const CharString &p_str) { _cowdata._ref(p_str._cowdata); }
Don't return reference on copy assignment operators We prefer to prevent using chained assignment (`T a = b = c = T();`) as this can lead to confusing code and subtle bugs. According to https://en.wikipedia.org/wiki/Assignment_operator_(C%2B%2B), C++ allows any arbitrary return type, so this is standard compliant. This could be re-assessed if/when we have an actual need for a behavior more akin to that of the C++ STL, for now this PR simply changes a handful of cases which were inconsistent with the rest of the codebase (`void` return type was already the most common case prior to this commit).
2021-11-30 15:19:26 +01:00
_FORCE_INLINE_ void operator=(const CharString &p_str) { _cowdata._ref(p_str._cowdata); }
fixed an access after free in OS_X11::set_context. Added constructor and assignment operator for CharString from const char* to simplify memory management when working with utf8/ascii strings for APIs taking char*. Reworked OS_X11::set_context to use CharString and avoid some manual memory management.
2019-03-12 13:57:22 +01:00
_FORCE_INLINE_ CharString(const char *p_cstr) { copy_from(p_cstr); }
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
Don't return reference on copy assignment operators We prefer to prevent using chained assignment (`T a = b = c = T();`) as this can lead to confusing code and subtle bugs. According to https://en.wikipedia.org/wiki/Assignment_operator_(C%2B%2B), C++ allows any arbitrary return type, so this is standard compliant. This could be re-assessed if/when we have an actual need for a behavior more akin to that of the C++ STL, for now this PR simply changes a handful of cases which were inconsistent with the rest of the codebase (`void` return type was already the most common case prior to this commit).
2021-11-30 15:19:26 +01:00
void operator=(const char *p_cstr);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool operator<(const CharString &p_right) const;
Improve logic for detecting and tracking extensions
2022-11-18 14:17:37 +01:00
bool operator==(const CharString &p_right) const;
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
CharString &operator+=(char p_char);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int length() const { return size() ? size() - 1 : 0; }
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
const char *get_data() const;
const char* operator on CharString now const.
2018-12-03 21:25:23 +01:00
operator const char *() const { return get_data(); };
fixed an access after free in OS_X11::set_context. Added constructor and assignment operator for CharString from const char* to simplify memory management when working with utf8/ascii strings for APIs taking char*. Reworked OS_X11::set_context to use CharString and avoid some manual memory management.
2019-03-12 13:57:22 +01:00
protected:
void copy_from(const char *p_cstr);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
/*************************************************************************/
/* String */
/*************************************************************************/
Remove CHARTYPE_16BITS unused checks fix #5263
2016-06-19 00:05:23 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
struct StrRange {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
const char32_t *c_str;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
int len;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
StrRange(const char32_t *p_c_str = nullptr, int p_len = 0) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
c_str = p_c_str;
len = p_len;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
class String {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
CowData<char32_t> _cowdata;
static const char32_t _null;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void copy_from(const char *p_cstr);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
void copy_from(const char *p_cstr, const int p_clip_to);
void copy_from(const wchar_t *p_cstr);
void copy_from(const wchar_t *p_cstr, const int p_clip_to);
void copy_from(const char32_t *p_cstr);
void copy_from(const char32_t *p_cstr, const int p_clip_to);
void copy_from(const char32_t &p_char);
void copy_from_unchecked(const char32_t *p_char, const int p_length);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool _base_is_subsequence_of(const String &p_string, bool case_insensitive) const;
Added count method to String
2019-01-18 09:29:28 +01:00
int _count(const String &p_string, int p_from, int p_to, bool p_case_insensitive) const;
Add `String.to_{camel,pascal,snake}_case` methods
2022-08-30 11:36:24 +02:00
String _camelcase_to_underscore() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
public:
enum {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
npos = -1 ///<for "some" compatibility with std::string (npos is a huge value in std::string)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
_FORCE_INLINE_ char32_t *ptrw() { return _cowdata.ptrw(); }
_FORCE_INLINE_ const char32_t *ptr() const { return _cowdata.ptr(); }
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
Rename `remove()` to `remove_at()` when removing by index
2021-07-04 00:17:03 +02:00
void remove_at(int p_index) { _cowdata.remove_at(p_index); }
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
_FORCE_INLINE_ void clear() { resize(0); }
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
_FORCE_INLINE_ char32_t get(int p_index) const { return _cowdata.get(p_index); }
_FORCE_INLINE_ void set(int p_index, const char32_t &p_elem) { _cowdata.set(p_index, p_elem); }
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
_FORCE_INLINE_ int size() const { return _cowdata.size(); }
Error resize(int p_size) { return _cowdata.resize(p_size); }
Reduce String CoW By introducing an intermediate proxy class for the array subscript operator for String and CharString we can control better when CowData will actually CoW. This should improve performance of String usage for most cases.
2018-12-16 01:44:18 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
_FORCE_INLINE_ const char32_t &operator[](int p_index) const {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (unlikely(p_index == _cowdata.size())) {
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
return _null;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
String[size()] should return a default constructed CharType As per the C++ standard 21.3.4.1 for std::string: Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined. Since the behavior is undefined Godot now does the same thing for const and non-const versions of operator[]. This fixes #21242 and fixes #22221.
2019-01-04 17:01:54 +01:00
return _cowdata.get(p_index);
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
_FORCE_INLINE_ CharProxy<char32_t> operator[](int p_index) { return CharProxy<char32_t>(p_index, _cowdata); }
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool operator==(const String &p_str) const;
bool operator!=(const String &p_str) const;
String operator+(const String &p_str) const;
Unify TextServer built-in module and GDExtension code.
2022-02-13 13:41:29 +01:00
String operator+(char32_t p_char) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String &operator+=(const String &);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
String &operator+=(char32_t p_char);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String &operator+=(const char *p_str);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
String &operator+=(const wchar_t *p_str);
String &operator+=(const char32_t *p_str);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* Compatibility Operators */
void operator=(const char *p_str);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
void operator=(const wchar_t *p_str);
void operator=(const char32_t *p_str);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool operator==(const char *p_str) const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
bool operator==(const wchar_t *p_str) const;
bool operator==(const char32_t *p_str) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool operator==(const StrRange &p_str_range) const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool operator!=(const char *p_str) const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
bool operator!=(const wchar_t *p_str) const;
bool operator!=(const char32_t *p_str) const;
bool operator<(const char32_t *p_str) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool operator<(const char *p_str) const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
bool operator<(const wchar_t *p_str) const;
Some performance tweaking of string handling
2017-12-11 23:38:07 +01:00
bool operator<(const String &p_str) const;
bool operator<=(const String &p_str) const;
Refactored Variant Operators. -Using classes to call and a table -For typed code (GDS or GDNative), can obtain functions to call prevalidated or ptr.
2020-11-05 03:01:55 +01:00
bool operator>(const String &p_str) const;
bool operator>=(const String &p_str) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
signed char casecmp_to(const String &p_str) const;
signed char nocasecmp_to(const String &p_str) const;
Fix natural sorting order in EditorFileDialog, FileDialog and EditorFileSystemDirectory Make EditorFileDialog, FileDialog and EditorFileSystemDirectory alphanumerical sorting more natural Added a new method 'naturalnocasecmp_to' and comparator 'NaturalNoCaseComparator' to String. Fixes #8712.
2017-05-11 21:07:59 +02:00
signed char naturalnocasecmp_to(const String &p_str) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
const char32_t *get_data() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* standard size stuff */
Some performance tweaking of string handling
2017-12-11 23:38:07 +01:00
_FORCE_INLINE_ int length() const {
int s = size();
return s ? (s - 1) : 0; // length does not include zero
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
bool is_valid_string() const;
Allows parsing of invalid UTF-16 surrogates (can be encountered in Windows filenames) and some non-standard UTF-8 variants, makes Unicode parse errors more verbose.
2022-07-05 14:18:29 +02:00
/* debug, error messages */
void print_unicode_error(const String &p_message, bool p_critical = false) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* complex helpers */
Make second parameter of substr optional
2019-05-03 14:21:04 +02:00
String substr(int p_from, int p_chars = -1) const;
Some performance tweaking of string handling
2017-12-11 23:38:07 +01:00
int find(const String &p_str, int p_from = 0) const; ///< return <0 if failed
Repair String lstrip and rstrip. Background: lstrip and rstrip were broken by changes to String in: 0e29f7974b59e4440cf02e1388fb9d8ab2b5c5fd which removed it's access to Vector::find(CharType). Moved Vector's find up into CowData so it can be shared by Vector and String. Added String::find_char using CowData::find. Implemented rstrip and lstrip using find_char. Added a few tests for String rstrip and lstrip.
2019-01-07 18:02:55 +01:00
int find(const char *p_str, int p_from = 0) const; ///< return <0 if failed
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
int find_char(const char32_t &p_char, int p_from = 0) const; ///< return <0 if failed
Some performance tweaking of string handling
2017-12-11 23:38:07 +01:00
int findn(const String &p_str, int p_from = 0) const; ///< return <0 if failed, case insensitive
int rfind(const String &p_str, int p_from = -1) const; ///< return <0 if failed
int rfindn(const String &p_str, int p_from = -1) const; ///< return <0 if failed, case insensitive
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
int findmk(const Vector<String> &p_keys, int p_from = 0, int *r_key = nullptr) const; ///< return <0 if failed
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool match(const String &p_wildcard) const;
bool matchn(const String &p_wildcard) const;
bool begins_with(const String &p_string) const;
bool begins_with(const char *p_string) const;
bool ends_with(const String &p_string) const;
Fix get_node() and $ autocompletion when using single quotes
2017-10-28 23:46:20 +02:00
bool is_enclosed_in(const String &p_string) const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool is_subsequence_of(const String &p_string) const;
Rename String::is_subsequence_ofi to String::is_subsequence_ofn
2022-01-27 00:03:56 +01:00
bool is_subsequence_ofn(const String &p_string) const;
Fix get_node() and $ autocompletion when using single quotes
2017-10-28 23:46:20 +02:00
bool is_quoted() const;
Add similarity comparison to String Uses the Sorensen-Dice coefficient to calculate similarity. This also adds String.bigrams() as a convenience function needed by the comparison.
2016-06-13 19:06:03 +02:00
Vector<String> bigrams() const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
float similarity(const String &p_string) const;
String format(const Variant &values, String placeholder = "{_}") const;
Some performance tweaking of string handling
2017-12-11 23:38:07 +01:00
String replace_first(const String &p_key, const String &p_with) const;
String replace(const String &p_key, const String &p_with) const;
String replace(const char *p_key, const char *p_with) const;
String replacen(const String &p_key, const String &p_with) const;
Create a GDScript String function repeat Fixes #30610
2019-09-02 05:49:55 +02:00
String repeat(int p_count) const;
Some performance tweaking of string handling
2017-12-11 23:38:07 +01:00
String insert(int p_at_pos, const String &p_string) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String pad_decimals(int p_digits) const;
String pad_zeros(int p_digits) const;
add string trim_prefix trim_suffix lstrip and rstrip methods
2018-04-13 16:40:27 +02:00
String trim_prefix(const String &p_prefix) const;
String trim_suffix(const String &p_suffix) const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String lpad(int min_length, const String &character = " ") const;
String rpad(int min_length, const String &character = " ") const;
String sprintf(const Array &values, bool *error) const;
Fix get_node() and $ autocompletion when using single quotes
2017-10-28 23:46:20 +02:00
String quote(String quotechar = "\"") const;
String unquote() const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
static String num(double p_num, int p_decimals = -1);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
static String num_scientific(double p_num);
Reformat structure string operators The order of numbers is not changed except for Transform2D. All logic is done inside of their structures (and not in Variant). For the number of decimals printed, they now use String::num_real which works best with real_t, except for Color which is fixed at 4 decimals (this is a reliable number of float digits when converting from 16-bpc so it seems like a good choice)
2021-02-25 15:54:50 +01:00
static String num_real(double p_num, bool p_trailing = true);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
static String num_int64(int64_t p_num, int base = 10, bool capitalize_hex = false);
Mono: Better versioning and gracefully unloading of Godot API assemblies
2018-02-22 13:13:51 +01:00
static String num_uint64(uint64_t p_num, int base = 10, bool capitalize_hex = false);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
static String chr(char32_t p_char);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
static String md5(const uint8_t *p_md5);
Add sha256 to String and File/FileAccess. Probably does #4166
2016-06-17 09:55:16 +02:00
static String hex_encode_buffer(const uint8_t *p_buffer, int p_len);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool is_numeric() const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
double to_float() const;
Make hex_to_int and bin_to_int handle the prefix automatically Also add BinToInt to C#
2021-01-28 13:39:05 +01:00
int64_t hex_to_int() const;
int64_t bin_to_int() const;
Remove 32-bit String to_int method
2020-05-13 11:31:51 +02:00
int64_t to_int() const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
Rename String bin_to_int64 to bin_to_int And also change String static to_int(const char *) to return int64_t
2020-06-03 06:04:04 +02:00
static int64_t to_int(const char *p_str, int p_len = -1);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
static int64_t to_int(const wchar_t *p_str, int p_len = -1);
static int64_t to_int(const char32_t *p_str, int p_len = -1, bool p_clamp = false);
Make all String float conversion methods be 64-bit
2020-07-24 20:07:57 +02:00
static double to_float(const char *p_str);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
static double to_float(const wchar_t *p_str, const wchar_t **r_end = nullptr);
static double to_float(const char32_t *p_str, const char32_t **r_end = nullptr);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String capitalize() const;
Add `String.to_{camel,pascal,snake}_case` methods
2022-08-30 11:36:24 +02:00
String to_camel_case() const;
String to_pascal_case() const;
String to_snake_case() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A lot of progress with canvas rendering, still far from working.
2019-06-16 04:45:24 +02:00
String get_with_code_lines() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
int get_slice_count(String p_splitter) const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String get_slice(String p_splitter, int p_slice) const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
String get_slicec(char32_t p_splitter, int p_slice) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Add support for empty delimiter in String.split
2022-08-12 16:21:15 +02:00
Vector<String> split(const String &p_splitter = "", bool p_allow_empty = true, int p_maxsplit = 0) const;
Vector<String> rsplit(const String &p_splitter = "", bool p_allow_empty = true, int p_maxsplit = 0) const;
-Rasterizer supports meshes with both skeletons and blend shapes -Collada exporter supports Blend Shapes (even on actions via set driven keys)
2014-10-10 00:44:27 +02:00
Vector<String> split_spaces() const;
Double precision of `String.split_floats`
2022-11-20 12:29:50 +01:00
Vector<double> split_floats(const String &p_splitter, bool p_allow_empty = true) const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Vector<float> split_floats_mk(const Vector<String> &p_splitters, bool p_allow_empty = true) const;
Vector<int> split_ints(const String &p_splitter, bool p_allow_empty = true) const;
Vector<int> split_ints_mk(const Vector<String> &p_splitters, bool p_allow_empty = true) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
String join(Vector<String> parts) const;
Allow configuring iOS export - EditorExportPlugin's _export_begin accepts all the arguments related to the current export (is_debug, path, flags). - EditorExportPlugin API is extended with methods allowing to configure iOS export: add_ios_framework, add_ios_plist_content, add_ios_linker_flags, add_ios_bundle_file. - iOS export template now contains Godot as a static library so that it can be linked with third-party Frameworks and GDNative static libraries. - Adds method to DirAccess for recursive copying of a directory. - Fixes iOS export to work with Xcode 9 (released recently).
2017-10-02 17:01:43 +02:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
static char32_t char_uppercase(char32_t p_char);
static char32_t char_lowercase(char32_t p_char);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String to_upper() const;
String to_lower() const;
Added count method to String
2019-01-18 09:29:28 +01:00
int count(const String &p_string, int p_from = 0, int p_to = 0) const;
int countn(const String &p_string, int p_from = 0, int p_to = 0) const;
Fix parameter name for String.left and String.right
2022-06-12 04:45:58 +02:00
String left(int p_len) const;
String right(int p_len) const;
Make `--doctool` locale aware * Adds `indent(str)` to `String`: * Indent the (multiline) string with the given indentation. * This method is added in order to keep the translated XML correctly indented. * Moves the loading of tool/doc translation into `editor/editor_translation.{h,cpp}`. * This will be used from both `EditorSettings` and the doc tool from `main`. * Makes use of doc translation when generating XML class references, and setup the translation locale based on `-l LOCALE` CLI parameter. The XML class reference won't be translated if `-l LOCALE` parameter is not given, or when it's `-l en`.
2021-12-15 16:01:06 +01:00
String indent(const String &p_prefix) const;
Added String::dedent() to remove text indentation This functions similarly to Python's textwrap.dedent() It's also been applied to doc_data.cpp to remove extra whitespace while parsing the XML.
2017-10-11 10:27:54 +02:00
String dedent() const;
Added possibility to strip left and right to strip_edges (#4594)
2016-05-11 09:22:59 +02:00
String strip_edges(bool left = true, bool right = true) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String strip_escapes() const;
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
String lstrip(const String &p_chars) const;
String rstrip(const String &p_chars) const;
rename String.extension() -> String.get_extension() / String.basename() -> String.get_basename()
2017-01-14 04:51:09 +01:00
String get_extension() const;
String get_basename() const;
Rename String `plus_file` to `path_join`
2022-08-30 02:34:01 +02:00
String path_join(const String &p_file) const;
Renamed String.ord_at to unicode_at
2020-11-23 12:47:11 +01:00
char32_t unicode_at(int p_idx) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
CharString ascii(bool p_allow_extended = false) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
CharString utf8() const;
File: Re-add support to skip CR (`\r`) in `File::get_as_text` This was removed in #63481, and we confirmed that it's better like this, but we add back the possibility to strip CR as an option, to optionally restore the previous behavior. For performance this is done directly in `String::parse_utf8`. Also fixes Android `FileAccess::get_line()` as this one _should_ strip CR. Supersedes #63717.
2022-07-31 18:46:53 +02:00
Error parse_utf8(const char *p_utf8, int p_len = -1, bool p_skip_cr = false);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
static String utf8(const char *p_utf8, int p_len = -1);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
Char16String utf16() const;
Allows parsing of invalid UTF-16 surrogates (can be encountered in Windows filenames) and some non-standard UTF-8 variants, makes Unicode parse errors more verbose.
2022-07-05 14:18:29 +02:00
Error parse_utf16(const char16_t *p_utf16, int p_len = -1);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
static String utf16(const char16_t *p_utf16, int p_len = -1);
static uint32_t hash(const char32_t *p_cstr, int p_len); /* hash the string */
static uint32_t hash(const char32_t *p_cstr); /* hash the string */
static uint32_t hash(const wchar_t *p_cstr, int p_len); /* hash the string */
static uint32_t hash(const wchar_t *p_cstr); /* hash the string */
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
static uint32_t hash(const char *p_cstr, int p_len); /* hash the string */
static uint32_t hash(const char *p_cstr); /* hash the string */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
uint32_t hash() const; /* hash the string */
remove trailing whitespace
2016-03-09 00:00:52 +01:00
uint64_t hash64() const; /* hash the string */
-fix bug in cache for atlas import/export -fix some menus -fixed bug in out transition curves -detect and remove file:/// in collada -remove multiscript for now -remove dependencies on mouse in OS, moved to Input -avoid fscache from screwing up (fix might make it slower, but it works) -funcref was missing, it's there now
2014-03-14 02:57:24 +01:00
String md5_text() const;
Add sha1 functions to string (using new CryptoCore)
2019-07-02 16:07:02 +02:00
String sha1_text() const;
Add sha256 to String and File/FileAccess. Probably does #4166
2016-06-17 09:55:16 +02:00
String sha256_text() const;
Small Issues & Maintenance -=-=-=-=-=-=-=-=-=-=-=-=-= -Begin work on Navigation Meshes (simple pathfinding for now, will improve soon) -More doc on theme overriding -Upgraded OpenSSL to version without bugs -Misc bugfixes
2014-08-02 03:10:38 +02:00
Vector<uint8_t> md5_buffer() const;
Add sha1 functions to string (using new CryptoCore)
2019-07-02 16:07:02 +02:00
Vector<uint8_t> sha1_buffer() const;
Add sha256_buffer() function to String
2016-06-23 18:57:45 +02:00
Vector<uint8_t> sha256_buffer() const;
Small Issues & Maintenance -=-=-=-=-=-=-=-=-=-=-=-=-= -Begin work on Navigation Meshes (simple pathfinding for now, will improve soon) -More doc on theme overriding -Upgraded OpenSSL to version without bugs -Misc bugfixes
2014-08-02 03:10:38 +02:00
Rename empty() to is_empty()
2020-12-15 13:04:21 +01:00
_FORCE_INLINE_ bool is_empty() const { return length() == 0; }
String: Add contains().
2022-02-03 17:03:38 +01:00
_FORCE_INLINE_ bool contains(const char *p_str) const { return find(p_str) != -1; }
_FORCE_INLINE_ bool contains(const String &p_str) const { return find(p_str) != -1; }
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
// path functions
Rename `String.is_abs_path()` to `String.is_absolute_path()` This is more consistent with `NodePath.is_absolute()`.
2021-06-03 15:41:22 +02:00
bool is_absolute_path() const;
Rename String::is_rel_path to String::is_relative_path
2021-08-30 01:43:47 +02:00
bool is_relative_path() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool is_resource_file() const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String path_to(const String &p_path) const;
String path_to_file(const String &p_path) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String get_base_dir() const;
String get_file() const;
Bind the `String::humanize_size` method The method signature is also changed to use `uint64_t` instead of `size_t` for it to be Variant-compatible.
2019-10-04 13:35:01 +02:00
static String humanize_size(uint64_t p_size);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String simplify_path() const;
[Windows] Add support for handling network share paths.
2022-01-24 12:12:46 +01:00
bool is_network_share_path() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String xml_escape(bool p_escape_quotes = false) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String xml_unescape() const;
Unify URI encoding/decoding and add to C# http_escape and percent_encode have been unified into uri_encode, and http_unescape and percent_decode have been unified into uri_decode.
2020-11-30 04:43:38 +01:00
String uri_encode() const;
String uri_decode() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String c_escape() const;
Improve .tscn VCS Serialize dictionaries adding newlines between key-value pairs Serialize group lists also with newlines in between Serialize string properties escaping only " and \ (needed for a good diff experience with built-in scripts and shaders) Bonus: Make AnimationPlayer serialize its blend times always sorted so their order is predictable in the .tscn file. This PR is back-compat; won't break the load of existing files.
2017-01-16 18:03:38 +01:00
String c_escape_multiline() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String c_unescape() const;
added a new function to escape properly json, fixes #3282
2016-01-10 19:01:06 +01:00
String json_escape() const;
[Net] Implement String::parse_url for parsing URLs. Splits the URL into (scheme, host, port, path). Supports both literal IPv4 and IPv6. Strip credentials when present (e.g. http://user:pass@example.com/). Use that function in both HTTPRequest and WebSocketClient.
2021-04-26 09:33:28 +02:00
Error parse_url(String &r_scheme, String &r_host, int &r_port, String &r_path) const;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Encodes property names properly in project.godot
2019-12-20 03:03:15 +01:00
String property_name_encode() const;
Relaxes Node naming constraints in glTF documents to match the Editor.
2021-01-28 21:48:12 +01:00
// node functions
static const String invalid_node_name_characters;
String validate_node_name() const;
Create onready variables when dropping nodes and holding Ctrl
2022-05-02 15:04:17 +02:00
String validate_identifier() const;
Handle gltf binary [ Ignore and Warn | Extract Textures (default) | Optimize Loading Embedded as Basisu ] Enable compressed mip maps from Basis Universal for faster compressions. Increase the quality of Basis to avoid corruption. To keep compatibility use the first mip of the previous internal Godot format. Because texture names may have invalid filename characters, adds String::validate_filename to sanitize filenames for import pipeline use.
2022-07-19 02:58:27 +02:00
String validate_filename() const;
Relaxes Node naming constraints in glTF documents to match the Editor.
2021-01-28 21:48:12 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool is_valid_identifier() const;
Rename `is_valid_integer()` to `is_valid_int()` Method from `String`
2021-06-16 18:24:34 +02:00
bool is_valid_int() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool is_valid_float() const;
added implementation of is_valid_ip_address()
2016-10-20 14:58:00 +02:00
bool is_valid_hex_number(bool p_with_prefix) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool is_valid_html_color() const;
bool is_valid_ip_address() const;
Add ability to edit editor feature profiles Allows enabling/disabling parts of the editor and storing/loading profiles for that.
2019-04-09 00:18:03 +02:00
bool is_valid_filename() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/**
* The constructors must not depend on other overloads
*/
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
_FORCE_INLINE_ String() {}
_FORCE_INLINE_ String(const String &p_str) { _cowdata._ref(p_str._cowdata); }
Don't return reference on copy assignment operators We prefer to prevent using chained assignment (`T a = b = c = T();`) as this can lead to confusing code and subtle bugs. According to https://en.wikipedia.org/wiki/Assignment_operator_(C%2B%2B), C++ allows any arbitrary return type, so this is standard compliant. This could be re-assessed if/when we have an actual need for a behavior more akin to that of the C++ STL, for now this PR simply changes a handful of cases which were inconsistent with the rest of the codebase (`void` return type was already the most common case prior to this commit).
2021-11-30 15:19:26 +01:00
_FORCE_INLINE_ void operator=(const String &p_str) { _cowdata._ref(p_str._cowdata); }
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
Vector<uint8_t> to_ascii_buffer() const;
Vector<uint8_t> to_utf8_buffer() const;
Vector<uint8_t> to_utf16_buffer() const;
Vector<uint8_t> to_utf32_buffer() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String(const char *p_str);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
String(const wchar_t *p_str);
String(const char32_t *p_str);
String(const char *p_str, int p_clip_to_len);
String(const wchar_t *p_str, int p_clip_to_len);
String(const char32_t *p_str, int p_clip_to_len);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String(const StrRange &p_range);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool operator==(const char *p_chr, const String &p_str);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
bool operator==(const wchar_t *p_chr, const String &p_str);
Refactored Variant Operators. -Using classes to call and a table -For typed code (GDS or GDNative), can obtain functions to call prevalidated or ptr.
2020-11-05 03:01:55 +01:00
bool operator!=(const char *p_chr, const String &p_str);
bool operator!=(const wchar_t *p_chr, const String &p_str);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String operator+(const char *p_chr, const String &p_str);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
String operator+(const wchar_t *p_chr, const String &p_str);
String operator+(char32_t p_chr, const String &p_str);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String itos(int64_t p_val);
Fix some crashes, overflows and using variables without values
2019-11-01 16:16:31 +01:00
String uitos(uint64_t p_val);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
String rtos(double p_val);
String rtoss(double p_val); //scientific version
struct NoCaseComparator {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool operator()(const String &p_a, const String &p_b) const {
return p_a.nocasecmp_to(p_b) < 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
};
Fix natural sorting order in EditorFileDialog, FileDialog and EditorFileSystemDirectory Make EditorFileDialog, FileDialog and EditorFileSystemDirectory alphanumerical sorting more natural Added a new method 'naturalnocasecmp_to' and comparator 'NaturalNoCaseComparator' to String. Fixes #8712.
2017-05-11 21:07:59 +02:00
struct NaturalNoCaseComparator {
bool operator()(const String &p_a, const String &p_b) const {
return p_a.naturalnocasecmp_to(p_b) < 0;
}
};
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
template <typename L, typename R>
_FORCE_INLINE_ bool is_str_less(const L *l_ptr, const R *r_ptr) {
while (true) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
const char32_t l = *l_ptr;
const char32_t r = *r_ptr;
if (l == 0 && r == 0) {
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
return false;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
} else if (l == 0) {
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
return true;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
} else if (r == 0) {
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
return false;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
} else if (l < r) {
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
return true;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
} else if (l > r) {
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
l_ptr++;
r_ptr++;
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
/* end of namespace */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
i18n: Add support for translating the class reference - Parse `.po` files from `doc/translations/*.po` like already done with `editor/translations/*.po`. - Add logic to register a doc translation mapping in `TranslationServer` and `EditorSettings`. - Add `DTR()` to lookup the doc translation mapping (similar to `TTR()`). Strings are automatically dedented and stripped of whitespace to ensure that they would match the translation catalog. - Use `DTR()` to translate relevant strings in `EditorHelp`, `EditorInspector`, `CreateDialog`, `ConnectionsDialog`. - Small simplification to `TranslationLoaderPO`, the path argument was not really meaningful.
2020-03-18 18:34:36 +01:00
// Tool translate (TTR and variants) for the editor UI,
// and doc translate for the class reference (DTR).
-Added configuration warning system for nodes -Added a new "add" and "instance" buttons for scene tree -Added a vformat() function to ease translation work
2016-05-17 23:27:15 +02:00
#ifdef TOOLS_ENABLED
i18n: Add support for translating the class reference - Parse `.po` files from `doc/translations/*.po` like already done with `editor/translations/*.po`. - Add logic to register a doc translation mapping in `TranslationServer` and `EditorSettings`. - Add `DTR()` to lookup the doc translation mapping (similar to `TTR()`). Strings are automatically dedented and stripped of whitespace to ensure that they would match the translation catalog. - Use `DTR()` to translate relevant strings in `EditorHelp`, `EditorInspector`, `CreateDialog`, `ConnectionsDialog`. - Small simplification to `TranslationLoaderPO`, the path argument was not really meaningful.
2020-03-18 18:34:36 +01:00
// Gets parsed.
Added plurals and context support to Translation
2020-07-16 10:52:06 +02:00
String TTR(const String &p_text, const String &p_context = "");
String TTRN(const String &p_text, const String &p_text_plural, int p_n, const String &p_context = "");
String DTR(const String &p_text, const String &p_context = "");
String DTRN(const String &p_text, const String &p_text_plural, int p_n, const String &p_context = "");
i18n: Add support for translating the class reference - Parse `.po` files from `doc/translations/*.po` like already done with `editor/translations/*.po`. - Add logic to register a doc translation mapping in `TranslationServer` and `EditorSettings`. - Add `DTR()` to lookup the doc translation mapping (similar to `TTR()`). Strings are automatically dedented and stripped of whitespace to ensure that they would match the translation catalog. - Use `DTR()` to translate relevant strings in `EditorHelp`, `EditorInspector`, `CreateDialog`, `ConnectionsDialog`. - Small simplification to `TranslationLoaderPO`, the path argument was not really meaningful.
2020-03-18 18:34:36 +01:00
// Use for C strings.
i18n: Fix extract.py support for new TTRC Also make compatible with Python 3.
2019-06-16 21:57:34 +02:00
#define TTRC(m_value) (m_value)
i18n: Add support for translating the class reference - Parse `.po` files from `doc/translations/*.po` like already done with `editor/translations/*.po`. - Add logic to register a doc translation mapping in `TranslationServer` and `EditorSettings`. - Add `DTR()` to lookup the doc translation mapping (similar to `TTR()`). Strings are automatically dedented and stripped of whitespace to ensure that they would match the translation catalog. - Use `DTR()` to translate relevant strings in `EditorHelp`, `EditorInspector`, `CreateDialog`, `ConnectionsDialog`. - Small simplification to `TranslationLoaderPO`, the path argument was not really meaningful.
2020-03-18 18:34:36 +01:00
// Use to avoid parsing (for use later with C strings).
Add ability to edit editor feature profiles Allows enabling/disabling parts of the editor and storing/loading profiles for that.
2019-04-09 00:18:03 +02:00
#define TTRGET(m_value) TTR(m_value)
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-Added configuration warning system for nodes -Added a new "add" and "instance" buttons for scene tree -Added a vformat() function to ease translation work
2016-05-17 23:27:15 +02:00
#else
Add ability to edit editor feature profiles Allows enabling/disabling parts of the editor and storing/loading profiles for that.
2019-04-09 00:18:03 +02:00
#define TTRC(m_value) (m_value)
i18n: Fix extract.py support for new TTRC Also make compatible with Python 3.
2019-06-16 21:57:34 +02:00
#define TTRGET(m_value) (m_value)
-Added configuration warning system for nodes -Added a new "add" and "instance" buttons for scene tree -Added a vformat() function to ease translation work
2016-05-17 23:27:15 +02:00
#endif
Add dedicated macros for property name extraction * Replace case-by-case extraction with PNAME & GNAME * Fix group handling when group hint begins with property name * Exclude properties that are PROPERTY_USAGE_NO_EDITOR * Extract missing ADD_ARRAY*, ADD_SUBGROUP* macros
2022-05-19 08:08:47 +02:00
// Use this to mark property names for editor translation.
// Often for dynamic properties defined in _get_property_list().
// Property names defined directly inside EDITOR_DEF, GLOBAL_DEF, and ADD_PROPERTY macros don't need this.
#define PNAME(m_value) (m_value)
// Similar to PNAME, but to mark groups, i.e. properties with PROPERTY_USAGE_GROUP.
// Groups defined directly inside ADD_GROUP macros don't need this.
// The arguments are the same as ADD_GROUP. m_prefix is only used for extraction.
#define GNAME(m_value, m_prefix) (m_value)
i18n: Add support for translating the class reference - Parse `.po` files from `doc/translations/*.po` like already done with `editor/translations/*.po`. - Add logic to register a doc translation mapping in `TranslationServer` and `EditorSettings`. - Add `DTR()` to lookup the doc translation mapping (similar to `TTR()`). Strings are automatically dedented and stripped of whitespace to ensure that they would match the translation catalog. - Use `DTR()` to translate relevant strings in `EditorHelp`, `EditorInspector`, `CreateDialog`, `ConnectionsDialog`. - Small simplification to `TranslationLoaderPO`, the path argument was not really meaningful.
2020-03-18 18:34:36 +01:00
// Runtime translate for the public node API.
Added plurals and context support to Translation
2020-07-16 10:52:06 +02:00
String RTR(const String &p_text, const String &p_context = "");
String RTRN(const String &p_text, const String &p_text_plural, int p_n, const String &p_context = "");
-Added configuration warning system for nodes -Added a new "add" and "instance" buttons for scene tree -Added a vformat() function to ease translation work
2016-05-17 23:27:15 +02:00
Double-click word selection for RichTextLabel (i.e. docs)
2017-12-23 09:59:54 +01:00
bool select_word(const String &p_s, int p_col, int &r_beg, int &r_end);
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 22:31:33 +01:00
_FORCE_INLINE_ void sarray_add_str(Vector<String> &arr) {
}
_FORCE_INLINE_ void sarray_add_str(Vector<String> &arr, const String &p_str) {
arr.push_back(p_str);
}
template <class... P>
_FORCE_INLINE_ void sarray_add_str(Vector<String> &arr, const String &p_str, P... p_args) {
arr.push_back(p_str);
sarray_add_str(arr, p_args...);
}
template <class... P>
_FORCE_INLINE_ Vector<String> sarray(P... p_args) {
Vector<String> arr;
sarray_add_str(arr, p_args...);
return arr;
}
[Complex Text Layouts] Implement TextServer interface. Implement Fallback TextServer.
2020-08-05 08:25:28 +02:00
#endif // USTRING_GODOT_H
Reference in a new issue Copy permalink