Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-03 23:21:15 +00:00
Code Issues Projects Releases Packages Wiki Activity
godot/core/ustring.h

442 lines
16 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/*************************************************************************/
/* ustring.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/*************************************************************************/
Update copyright statements to 2021 Happy new year to the wonderful Godot community! 2020 has been a tough year for most of us personally, but a good year for Godot development nonetheless with a huge amount of work done towards Godot 4.0 and great improvements backported to the long-lived 3.2 branch. We've had close to 400 contributors to engine code this year, authoring near 7,000 commit! (And that's only for the `master` branch and for the engine code, there's a lot more when counting docs, demos and other first-party repos.) Here's to a great year 2021 for all Godot users 🎆 (cherry picked from commit b5334d14f7a471f94bcbd64d5bae2ad853d0b7f1)
2021-01-01 20:13:46 +01:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/* */
/* 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
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
#ifndef USTRING_H
#define USTRING_H
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
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/array.h"
#include "core/cowdata.h"
#include "core/typedefs.h"
#include "core/vector.h"
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 00:44:18 +00:00
template <class T>
class CharProxy {
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 16:01:54 +00: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 00:44:18 +00:00
_FORCE_INLINE_ CharProxy(const int &p_index, CowData<T> &cowdata) :
_index(p_index),
_cowdata(cowdata) {}
public:
_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
2021-05-05 12:44:11 +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 16:01:54 +00: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
2021-05-05 12:44:11 +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 16:01:54 +00: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 00:44:18 +00:00
return _cowdata.get(_index);
}
_FORCE_INLINE_ const T *operator&() const {
return _cowdata.ptr() + _index;
}
_FORCE_INLINE_ void operator=(const T &other) const {
_cowdata.set(_index, other);
}
_FORCE_INLINE_ void operator=(const CharProxy<T> &other) const {
_cowdata.set(_index, other.operator T());
}
};
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 16:01:54 +00: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 16:01:54 +00: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
2021-05-05 12:44:11 +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 16:01:54 +00: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
2021-05-05 12:44:11 +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 16:01:54 +00: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 00:44:18 +00: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); }
Fix new GCC 9 warnings: -Wdeprecated-copy.
2019-03-02 13:32:29 +01:00
_FORCE_INLINE_ CharString operator=(const CharString &p_str) {
_cowdata._ref(p_str._cowdata);
return *this;
}
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 12:57:22 +00: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
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 12:57:22 +00:00
CharString &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;
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-09 22:10:30 -03:00
const char *get_data() const;
const char* operator on CharString now const.
2018-12-03 20:25:23 +00: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 12:57:22 +00:00
protected:
void copy_from(const char *p_cstr);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
};
typedef wchar_t CharType;
Remove CHARTYPE_16BITS unused checks fix #5263
2016-06-19 00:05:23 +02:00
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
struct StrRange {
const CharType *c_str;
int len;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 16:00:45 +02:00
StrRange(const CharType *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-09 22:10:30 -03: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 {
CowData<CharType> _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 16:01:54 +00:00
static const CharType _null;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
void copy_from(const char *p_cstr);
fix out of buffer read when copying non-null terminated strings
2018-08-06 23:51:07 +02:00
void copy_from(const CharType *p_cstr, const int p_clip_to = -1);
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
void copy_from(const CharType &p_char);
fix out of buffer read when copying non-null terminated strings
2018-08-06 23:51:07 +02:00
void copy_from_unchecked(const CharType *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 11:29:28 +03:00
int _count(const String &p_string, int p_from, int p_to, bool p_case_insensitive) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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-09 22:10:30 -03: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
_FORCE_INLINE_ CharType *ptrw() { return _cowdata.ptrw(); }
_FORCE_INLINE_ const CharType *ptr() const { return _cowdata.ptr(); }
void remove(int p_index) { _cowdata.remove(p_index); }
_FORCE_INLINE_ void clear() { resize(0); }
Fix warnings seen with -Wignored-qualifiers.
2019-02-21 20:24:29 +01:00
_FORCE_INLINE_ CharType 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 CharType &p_elem) { _cowdata.set(p_index, p_elem); }
_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 00:44:18 +00: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 16:01:54 +00:00
_FORCE_INLINE_ const CharType &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
2021-05-05 12:44:11 +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 16:01:54 +00: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
2021-05-05 12:44:11 +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 16:01:54 +00: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 00:44:18 +00:00
_FORCE_INLINE_ CharProxy<CharType> operator[](int p_index) { return CharProxy<CharType>(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;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
//String operator+(CharType p_char) 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 &operator+=(const String &);
Synchronize parameter names in definition and declaration Fixes #10244.
2017-08-11 15:10:05 -04:00
String &operator+=(CharType 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);
String &operator+=(const CharType *p_str);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/* Compatibility Operators */
void operator=(const char *p_str);
void operator=(const CharType *p_str);
bool operator==(const char *p_str) const;
bool operator==(const CharType *p_str) const;
bool operator==(const StrRange &p_str_range) const;
bool operator!=(const char *p_str) const;
bool operator!=(const CharType *p_str) const;
bool operator<(const CharType *p_str) const;
bool operator<(const char *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;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 20:07:59 +01:00
signed char naturalnocasecmp_to(const String &p_str) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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
const CharType *c_str() const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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-09 22:10:30 -03: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 17:02:55 +00:00
int find(const char *p_str, int p_from = 0) const; ///< return <0 if failed
Fix warnings seen with -Wignored-qualifiers.
2019-02-21 20:24:29 +01:00
int find_char(const CharType &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 find_last(const String &p_str) const; ///< return <0 if failed
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
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 16:00:45 +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;
bool is_subsequence_ofi(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 14:06:03 -03: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-01 23:49:55 -04: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-09 22:10:30 -03: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 17:40:27 +03: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-09 22:10:30 -03:00
static String num_scientific(double p_num);
static String num_real(double p_num);
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);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
static String chr(CharType p_char);
static String md5(const uint8_t *p_md5);
Add sha256 to String and File/FileAccess. Probably does #4166
2016-06-17 10:55:16 +03:00
static String hex_encode_buffer(const uint8_t *p_buffer, int p_len);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
bool is_numeric() const;
double to_double() const;
float to_float() const;
added implementation of is_valid_ip_address()
2016-10-20 09:58:00 -03:00
int hex_to_int(bool p_with_prefix = true) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
int to_int() const;
Variant INT and REAL are now 64 bits (other types remain at 32)
2017-01-08 20:58:39 -03:00
int64_t hex_to_int64(bool p_with_prefix = true) const;
Support for binary literals in GDScript. Added an error that shows if a point is written in a hex literal. Added highlighting for binary literals in GDScript
2019-04-25 13:43:48 +01:00
int64_t bin_to_int64(bool p_with_prefix = true) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
int64_t to_int64() 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 int to_int(const char *p_str, int p_len = -1);
static double to_double(const char *p_str);
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 16:00:45 +02:00
static double to_double(const CharType *p_str, const CharType **r_end = nullptr);
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 int64_t to_int(const CharType *p_str, int p_len = -1);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
String capitalize() 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 camelcase_to_underscore(bool lowercase = true) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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;
Synchronize parameter names in definition and declaration Fixes #10244.
2017-08-11 15:10:05 -04:00
String get_slicec(CharType p_splitter, int p_slice) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added third argument for String.split() function (see issue #14349) Remove negative limit, leave only positive and make it reflect behaviour like in Python Also limit renamed to maxsplit to match Python one. Also docs updated. Fix indent
2017-12-12 05:14:38 +03:00
Vector<String> split(const String &p_splitter, bool p_allow_empty = true, int p_maxsplit = 0) const;
Added rsplit() for String class Docs updated
2017-12-15 22:23:58 +03:00
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-09 19:44:27 -03:00
Vector<String> split_spaces() 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(const String &p_splitter, bool p_allow_empty = true) const;
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-09 22:10:30 -03:00
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 22:01:43 +07:00
String join(Vector<String> parts);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
static CharType char_uppercase(CharType p_char);
static CharType char_lowercase(CharType p_char);
String to_upper() const;
String to_lower() const;
Added count method to String
2019-01-18 11:29:28 +03: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;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
String left(int p_pos) const;
String right(int p_pos) 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 16:27:54 +08: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-09 22:10:30 -03: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 00:51:09 -03:00
String get_extension() const;
String get_basename() 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 plus_file(const String &p_file) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
CharType ord_at(int p_idx) const;
void erase(int p_pos, int p_chars);
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-09 22:10:30 -03:00
CharString utf8() 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 parse_utf8(const char *p_utf8, int p_len = -1); //return true on error
static String utf8(const char *p_utf8, int p_len = -1);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Synchronize parameter names in definition and declaration Fixes #10244.
2017-08-11 15:10:05 -04:00
static uint32_t hash(const CharType *p_cstr, int p_len); /* hash the string */
static uint32_t hash(const CharType *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-09 22:10:30 -03: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-13 22:57:24 -03: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 10:55:16 +03: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-01 22:10:38 -03: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 13:57:45 -03: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-01 22:10:38 -03:00
Some performance tweaking of string handling
2017-12-11 23:38:07 +01:00
_FORCE_INLINE_ bool empty() const { return length() == 0; }
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
// path functions
bool is_abs_path() const;
bool is_rel_path() const;
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-09 22:10:30 -03: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 14:35:01 +03:00
static String humanize_size(uint64_t p_size);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
String simplify_path() 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 xml_escape(bool p_escape_quotes = false) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
String xml_unescape() const;
Revert "Unify http- and percent- encode/decode" This reverts commit b76ee30917c63211ac9e94a21bebbddf518d169f.
2018-04-12 21:12:34 +02:00
String http_escape() const;
String http_unescape() const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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-09 22:10:30 -03:00
String c_unescape() const;
added a new function to escape properly json, fixes #3282
2016-01-10 15:01:06 -03:00
String json_escape() const;
Fix typo for word_wrap
2016-09-30 03:28:05 +09:00
String word_wrap(int p_chars_per_line) 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. (cherry picked from commit 3bb40669d5efea707a90171ad2430a81fd4f4726)
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
Revert "Unify http- and percent- encode/decode" This reverts commit b76ee30917c63211ac9e94a21bebbddf518d169f.
2018-04-12 21:12:34 +02:00
String percent_encode() const;
String percent_decode() const;
Encodes property names properly in project.godot
2019-12-20 10:03:15 +08:00
String property_name_encode() const;
Relaxes Node naming constraints in glTF documents to match the Editor.
2021-01-28 11:43:49 -08:00
// node functions
static const String invalid_node_name_characters;
String validate_node_name() const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
bool is_valid_identifier() const;
bool is_valid_integer() const;
bool is_valid_float() const;
added implementation of is_valid_ip_address()
2016-10-20 09:58:00 -03:00
bool is_valid_hex_number(bool p_with_prefix) const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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-08 19:18:03 -03:00
bool is_valid_filename() const;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/**
* The constructors must not depend on other overloads
*/
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(CharType p_char);*/
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); }
Fix new GCC 9 warnings: -Wdeprecated-copy.
2019-03-02 13:32:29 +01:00
String operator=(const String &p_str) {
_cowdata._ref(p_str._cowdata);
return *this;
}
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
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
String(const char *p_str);
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 CharType *p_str, int p_clip_to_len = -1);
String(const StrRange &p_range);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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);
String operator+(CharType p_chr, const String &p_str);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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-09 22:10:30 -03: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-09 22:10:30 -03: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 20:07:59 +01: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) {
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
2021-05-05 12:44:11 +02:00
if (*l_ptr == 0 && *r_ptr == 0) {
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
2021-05-05 12:44:11 +02:00
} else if (*l_ptr == 0) {
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
return true;
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
2021-05-05 12:44:11 +02:00
} else if (*r_ptr == 0) {
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
2021-05-05 12:44:11 +02:00
} else if (*l_ptr < *r_ptr) {
Avoid string allocations in AlphCompare
2017-12-16 15:31:30 +01:00
return true;
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
2021-05-05 12:44:11 +02:00
} else if (*l_ptr > *r_ptr) {
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
2021-05-05 12:44:11 +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-09 22:10:30 -03:00
Modified editor strings to be translatable in the future
2016-05-03 22:25:37 -03:00
//tool translate
-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 18:27:15 -03:00
#ifdef TOOLS_ENABLED
Add ability to edit editor feature profiles Allows enabling/disabling parts of the editor and storing/loading profiles for that.
2019-04-08 19:18:03 -03:00
//gets parsed
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 TTR(const String &);
i18n: Fix extract.py support for new TTRC Also make compatible with Python 3.
2019-06-16 21:57:34 +02:00
//use for C strings
#define TTRC(m_value) (m_value)
Add ability to edit editor feature profiles Allows enabling/disabling parts of the editor and storing/loading profiles for that.
2019-04-08 19:18:03 -03:00
//use to avoid parsing (for use later with C strings)
#define TTRGET(m_value) TTR(m_value)
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 18:27:15 -03:00
#else
i18n: Fix extract.py support for new TTRC Also make compatible with Python 3.
2019-06-16 21:57:34 +02:00
#define TTR(m_value) (String())
Add ability to edit editor feature profiles Allows enabling/disabling parts of the editor and storing/loading profiles for that.
2019-04-08 19:18:03 -03: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 18:27:15 -03:00
#endif
//tool or regular translate
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 RTR(const String &);
-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 18:27:15 -03:00
Double-click word selection for RichTextLabel (i.e. docs)
2017-12-23 09:59:54 +01:00
bool is_symbol(CharType c);
bool select_word(const String &p_s, int p_col, int &r_beg, int &r_end);
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
#endif // USTRING_H
Reference in a new issue Copy permalink