// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ********************************************************************** * Copyright (C) 1998-2016, International Business Machines * Corporation and others. All Rights Reserved. ********************************************************************** * * File unistr.h * * Modification History: * * Date Name Description * 09/25/98 stephen Creation. * 11/11/98 stephen Changed per 11/9 code review. * 04/20/99 stephen Overhauled per 4/16 code review. * 11/18/99 aliu Made to inherit from Replaceable. Added method * handleReplaceBetween(); other methods unchanged. * 06/25/01 grhoten Remove dependency on iostream. ****************************************************************************** */ #ifndef UNISTR_H #define UNISTR_H /** * \file * \brief C++ API: Unicode String */ #include "unicode/utypes.h" #if U_SHOW_CPLUSPLUS_API #include <cstddef> #include "unicode/char16ptr.h" #include "unicode/rep.h" #include "unicode/std_string.h" #include "unicode/stringpiece.h" #include "unicode/bytestream.h" struct UConverter; // unicode/ucnv.h #ifndef USTRING_H /** * \ingroup ustring_ustrlen * @param s Pointer to sequence of UChars. * @return Length of sequence. */ U_CAPI int32_t U_EXPORT2 u_strlen(const UChar *s); #endif U_NAMESPACE_BEGIN #if !UCONFIG_NO_BREAK_ITERATION class BreakIterator; // unicode/brkiter.h #endif class Edits; U_NAMESPACE_END // Not #ifndef U_HIDE_INTERNAL_API because UnicodeString needs the UStringCaseMapper. /** * Internal string case mapping function type. * All error checking must be done. * src and dest must not overlap. * @internal */ UStringCaseMapper; U_NAMESPACE_BEGIN class Locale; // unicode/locid.h class StringCharacterIterator; class UnicodeStringAppendable; // unicode/appendable.h /* The <iostream> include has been moved to unicode/ustream.h */ /** * Constant to be used in the UnicodeString(char *, int32_t, EInvariant) constructor * which constructs a Unicode string from an invariant-character char * string. * About invariant characters see utypes.h. * This constructor has no runtime dependency on conversion code and is * therefore recommended over ones taking a charset name string * (where the empty string "" indicates invariant-character conversion). * * @stable ICU 3.2 */ #define US_INV … /** * Unicode String literals in C++. * * Note: these macros are not recommended for new code. * Prior to the availability of C++11 and u"unicode string literals", * these macros were provided for portability and efficiency when * initializing UnicodeStrings from literals. * * They work only for strings that contain "invariant characters", i.e., * only latin letters, digits, and some punctuation. * See utypes.h for details. * * The string parameter must be a C string literal. * The length of the string, not including the terminating * `NUL`, must be specified as a constant. * @stable ICU 2.0 */ #if !U_CHAR16_IS_TYPEDEF #define UNICODE_STRING(cs, _length) … #else #define UNICODE_STRING … #endif /** * Unicode String literals in C++. * Dependent on the platform properties, different UnicodeString * constructors should be used to create a UnicodeString object from * a string literal. * The macros are defined for improved performance. * They work only for strings that contain "invariant characters", i.e., * only latin letters, digits, and some punctuation. * See utypes.h for details. * * The string parameter must be a C string literal. * @stable ICU 2.0 */ #define UNICODE_STRING_SIMPLE(cs) … /** * \def UNISTR_FROM_CHAR_EXPLICIT * This can be defined to be empty or "explicit". * If explicit, then the UnicodeString(char16_t) and UnicodeString(UChar32) * constructors are marked as explicit, preventing their inadvertent use. * @stable ICU 49 */ #ifndef UNISTR_FROM_CHAR_EXPLICIT # if defined(U_COMBINED_IMPLEMENTATION) || defined(U_COMMON_IMPLEMENTATION) || defined(U_I18N_IMPLEMENTATION) || defined(U_IO_IMPLEMENTATION) // Auto-"explicit" in ICU library code. #define UNISTR_FROM_CHAR_EXPLICIT … # else // Empty by default for source code compatibility. #define UNISTR_FROM_CHAR_EXPLICIT # endif #endif /** * \def UNISTR_FROM_STRING_EXPLICIT * This can be defined to be empty or "explicit". * If explicit, then the UnicodeString(const char *) and UnicodeString(const char16_t *) * constructors are marked as explicit, preventing their inadvertent use. * * In particular, this helps prevent accidentally depending on ICU conversion code * by passing a string literal into an API with a const UnicodeString & parameter. * @stable ICU 49 */ #ifndef UNISTR_FROM_STRING_EXPLICIT # if defined(U_COMBINED_IMPLEMENTATION) || defined(U_COMMON_IMPLEMENTATION) || defined(U_I18N_IMPLEMENTATION) || defined(U_IO_IMPLEMENTATION) // Auto-"explicit" in ICU library code. #define UNISTR_FROM_STRING_EXPLICIT … # else // Empty by default for source code compatibility. #define UNISTR_FROM_STRING_EXPLICIT # endif #endif /** * \def UNISTR_OBJECT_SIZE * Desired sizeof(UnicodeString) in bytes. * It should be a multiple of sizeof(pointer) to avoid unusable space for padding. * The object size may want to be a multiple of 16 bytes, * which is a common granularity for heap allocation. * * Any space inside the object beyond sizeof(vtable pointer) + 2 * is available for storing short strings inside the object. * The bigger the object, the longer a string that can be stored inside the object, * without additional heap allocation. * * Depending on a platform's pointer size, pointer alignment requirements, * and struct padding, the compiler will usually round up sizeof(UnicodeString) * to 4 * sizeof(pointer) (or 3 * sizeof(pointer) for P128 data models), * to hold the fields for heap-allocated strings. * Such a minimum size also ensures that the object is easily large enough * to hold at least 2 char16_ts, for one supplementary code point (U16_MAX_LENGTH). * * sizeof(UnicodeString) >= 48 should work for all known platforms. * * For example, on a 64-bit machine where sizeof(vtable pointer) is 8, * sizeof(UnicodeString) = 64 would leave space for * (64 - sizeof(vtable pointer) - 2) / U_SIZEOF_UCHAR = (64 - 8 - 2) / 2 = 27 * char16_ts stored inside the object. * * The minimum object size on a 64-bit machine would be * 4 * sizeof(pointer) = 4 * 8 = 32 bytes, * and the internal buffer would hold up to 11 char16_ts in that case. * * @see U16_MAX_LENGTH * @stable ICU 56 */ #ifndef UNISTR_OBJECT_SIZE #define UNISTR_OBJECT_SIZE … #endif /** * UnicodeString is a string class that stores Unicode characters directly and provides * similar functionality as the Java String and StringBuffer/StringBuilder classes. * It is a concrete implementation of the abstract class Replaceable (for transliteration). * * The UnicodeString equivalent of std::string’s clear() is remove(). * * A UnicodeString may "alias" an external array of characters * (that is, point to it, rather than own the array) * whose lifetime must then at least match the lifetime of the aliasing object. * This aliasing may be preserved when returning a UnicodeString by value, * depending on the compiler and the function implementation, * via Return Value Optimization (RVO) or the move assignment operator. * (However, the copy assignment operator does not preserve aliasing.) * For details see the description of storage models at the end of the class API docs * and in the User Guide chapter linked from there. * * The UnicodeString class is not suitable for subclassing. * * For an overview of Unicode strings in C and C++ see the * [User Guide Strings chapter](https://unicode-org.github.io/icu/userguide/strings#strings-in-cc). * * In ICU, a Unicode string consists of 16-bit Unicode *code units*. * A Unicode character may be stored with either one code unit * (the most common case) or with a matched pair of special code units * ("surrogates"). The data type for code units is char16_t. * For single-character handling, a Unicode character code *point* is a value * in the range 0..0x10ffff. ICU uses the UChar32 type for code points. * * Indexes and offsets into and lengths of strings always count code units, not code points. * This is the same as with multi-byte char* strings in traditional string handling. * Operations on partial strings typically do not test for code point boundaries. * If necessary, the user needs to take care of such boundaries by testing for the code unit * values or by using functions like * UnicodeString::getChar32Start() and UnicodeString::getChar32Limit() * (or, in C, the equivalent macros U16_SET_CP_START() and U16_SET_CP_LIMIT(), see utf.h). * * UnicodeString methods are more lenient with regard to input parameter values * than other ICU APIs. In particular: * - If indexes are out of bounds for a UnicodeString object * (< 0 or > length()) then they are "pinned" to the nearest boundary. * - If the buffer passed to an insert/append/replace operation is owned by the * target object, e.g., calling str.append(str), an extra copy may take place * to ensure safety. * - If primitive string pointer values (e.g., const char16_t * or char *) * for input strings are nullptr, then those input string parameters are treated * as if they pointed to an empty string. * However, this is *not* the case for char * parameters for charset names * or other IDs. * - Most UnicodeString methods do not take a UErrorCode parameter because * there are usually very few opportunities for failure other than a shortage * of memory, error codes in low-level C++ string methods would be inconvenient, * and the error code as the last parameter (ICU convention) would prevent * the use of default parameter values. * Instead, such methods set the UnicodeString into a "bogus" state * (see isBogus()) if an error occurs. * * In string comparisons, two UnicodeString objects that are both "bogus" * compare equal (to be transitive and prevent endless loops in sorting), * and a "bogus" string compares less than any non-"bogus" one. * * Const UnicodeString methods are thread-safe. Multiple threads can use * const methods on the same UnicodeString object simultaneously, * but non-const methods must not be called concurrently (in multiple threads) * with any other (const or non-const) methods. * * Similarly, const UnicodeString & parameters are thread-safe. * One object may be passed in as such a parameter concurrently in multiple threads. * This includes the const UnicodeString & parameters for * copy construction, assignment, and cloning. * * UnicodeString uses several storage methods. * String contents can be stored inside the UnicodeString object itself, * in an allocated and shared buffer, or in an outside buffer that is "aliased". * Most of this is done transparently, but careful aliasing in particular provides * significant performance improvements. * Also, the internal buffer is accessible via special functions. * For details see the * [User Guide Strings chapter](https://unicode-org.github.io/icu/userguide/strings#maximizing-performance-with-the-unicodestring-storage-model). * * @see utf.h * @see CharacterIterator * @stable ICU 2.0 */ class U_COMMON_API UnicodeString : public Replaceable { … }; /** * Create a new UnicodeString with the concatenation of two others. * * @param s1 The first string to be copied to the new one. * @param s2 The second string to be copied to the new one, after s1. * @return UnicodeString(s1).append(s2) * @stable ICU 2.8 */ U_COMMON_API UnicodeString U_EXPORT2 operator+ (const UnicodeString &s1, const UnicodeString &s2); //======================================== // Inline members //======================================== //======================================== // Privates //======================================== inline void UnicodeString::pinIndex(int32_t& start) const { … } inline void UnicodeString::pinIndices(int32_t& start, int32_t& _length) const { … } inline char16_t* UnicodeString::getArrayStart() { … } inline const char16_t* UnicodeString::getArrayStart() const { … } //======================================== // Default constructor //======================================== inline UnicodeString::UnicodeString() { … } inline UnicodeString::UnicodeString(const std::nullptr_t /*text*/) { … } inline UnicodeString::UnicodeString(const std::nullptr_t /*text*/, int32_t /*length*/) { … } inline UnicodeString::UnicodeString(std::nullptr_t /*buffer*/, int32_t /*buffLength*/, int32_t /*buffCapacity*/) { … } //======================================== // Read-only implementation methods //======================================== inline UBool UnicodeString::hasShortLength() const { … } inline int32_t UnicodeString::getShortLength() const { … } inline int32_t UnicodeString::length() const { … } inline int32_t UnicodeString::getCapacity() const { … } inline int32_t UnicodeString::hashCode() const { … } inline UBool UnicodeString::isBogus() const { … } inline UBool UnicodeString::isWritable() const { … } inline UBool UnicodeString::isBufferWritable() const { … } inline const char16_t * UnicodeString::getBuffer() const { … } //======================================== // Read-only alias methods //======================================== inline int8_t UnicodeString::doCompare(int32_t start, int32_t thisLength, const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) const { … } inline UBool UnicodeString::doEqualsSubstring(int32_t start, int32_t thisLength, const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) const { … } inline bool UnicodeString::operator== (const UnicodeString& text) const { … } inline bool UnicodeString::operator!= (const UnicodeString& text) const { … } inline UBool UnicodeString::operator> (const UnicodeString& text) const { … } inline UBool UnicodeString::operator< (const UnicodeString& text) const { … } inline UBool UnicodeString::operator>= (const UnicodeString& text) const { … } inline UBool UnicodeString::operator<= (const UnicodeString& text) const { … } inline int8_t UnicodeString::compare(const UnicodeString& text) const { … } inline int8_t UnicodeString::compare(int32_t start, int32_t _length, const UnicodeString& srcText) const { … } inline int8_t UnicodeString::compare(ConstChar16Ptr srcChars, int32_t srcLength) const { … } inline int8_t UnicodeString::compare(int32_t start, int32_t _length, const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) const { … } inline int8_t UnicodeString::compare(int32_t start, int32_t _length, const char16_t *srcChars) const { … } inline int8_t UnicodeString::compare(int32_t start, int32_t _length, const char16_t *srcChars, int32_t srcStart, int32_t srcLength) const { … } inline int8_t UnicodeString::compareBetween(int32_t start, int32_t limit, const UnicodeString& srcText, int32_t srcStart, int32_t srcLimit) const { … } inline int8_t UnicodeString::doCompareCodePointOrder(int32_t start, int32_t thisLength, const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) const { … } inline int8_t UnicodeString::compareCodePointOrder(const UnicodeString& text) const { … } inline int8_t UnicodeString::compareCodePointOrder(int32_t start, int32_t _length, const UnicodeString& srcText) const { … } inline int8_t UnicodeString::compareCodePointOrder(ConstChar16Ptr srcChars, int32_t srcLength) const { … } inline int8_t UnicodeString::compareCodePointOrder(int32_t start, int32_t _length, const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) const { … } inline int8_t UnicodeString::compareCodePointOrder(int32_t start, int32_t _length, const char16_t *srcChars) const { … } inline int8_t UnicodeString::compareCodePointOrder(int32_t start, int32_t _length, const char16_t *srcChars, int32_t srcStart, int32_t srcLength) const { … } inline int8_t UnicodeString::compareCodePointOrderBetween(int32_t start, int32_t limit, const UnicodeString& srcText, int32_t srcStart, int32_t srcLimit) const { … } inline int8_t UnicodeString::doCaseCompare(int32_t start, int32_t thisLength, const UnicodeString &srcText, int32_t srcStart, int32_t srcLength, uint32_t options) const { … } inline int8_t UnicodeString::caseCompare(const UnicodeString &text, uint32_t options) const { … } inline int8_t UnicodeString::caseCompare(int32_t start, int32_t _length, const UnicodeString &srcText, uint32_t options) const { … } inline int8_t UnicodeString::caseCompare(ConstChar16Ptr srcChars, int32_t srcLength, uint32_t options) const { … } inline int8_t UnicodeString::caseCompare(int32_t start, int32_t _length, const UnicodeString &srcText, int32_t srcStart, int32_t srcLength, uint32_t options) const { … } inline int8_t UnicodeString::caseCompare(int32_t start, int32_t _length, const char16_t *srcChars, uint32_t options) const { … } inline int8_t UnicodeString::caseCompare(int32_t start, int32_t _length, const char16_t *srcChars, int32_t srcStart, int32_t srcLength, uint32_t options) const { … } inline int8_t UnicodeString::caseCompareBetween(int32_t start, int32_t limit, const UnicodeString &srcText, int32_t srcStart, int32_t srcLimit, uint32_t options) const { … } inline int32_t UnicodeString::indexOf(const UnicodeString& srcText, int32_t srcStart, int32_t srcLength, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::indexOf(const UnicodeString& text) const { … } inline int32_t UnicodeString::indexOf(const UnicodeString& text, int32_t start) const { … } inline int32_t UnicodeString::indexOf(const UnicodeString& text, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::indexOf(const char16_t *srcChars, int32_t srcLength, int32_t start) const { … } inline int32_t UnicodeString::indexOf(ConstChar16Ptr srcChars, int32_t srcLength, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::indexOf(char16_t c, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::indexOf(UChar32 c, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::indexOf(char16_t c) const { … } inline int32_t UnicodeString::indexOf(UChar32 c) const { … } inline int32_t UnicodeString::indexOf(char16_t c, int32_t start) const { … } inline int32_t UnicodeString::indexOf(UChar32 c, int32_t start) const { … } inline int32_t UnicodeString::lastIndexOf(ConstChar16Ptr srcChars, int32_t srcLength, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::lastIndexOf(const char16_t *srcChars, int32_t srcLength, int32_t start) const { … } inline int32_t UnicodeString::lastIndexOf(const UnicodeString& srcText, int32_t srcStart, int32_t srcLength, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::lastIndexOf(const UnicodeString& text, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::lastIndexOf(const UnicodeString& text, int32_t start) const { … } inline int32_t UnicodeString::lastIndexOf(const UnicodeString& text) const { … } inline int32_t UnicodeString::lastIndexOf(char16_t c, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::lastIndexOf(UChar32 c, int32_t start, int32_t _length) const { … } inline int32_t UnicodeString::lastIndexOf(char16_t c) const { … } inline int32_t UnicodeString::lastIndexOf(UChar32 c) const { … } inline int32_t UnicodeString::lastIndexOf(char16_t c, int32_t start) const { … } inline int32_t UnicodeString::lastIndexOf(UChar32 c, int32_t start) const { … } inline UBool UnicodeString::startsWith(const UnicodeString& text) const { … } inline UBool UnicodeString::startsWith(const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) const { … } inline UBool UnicodeString::startsWith(ConstChar16Ptr srcChars, int32_t srcLength) const { … } inline UBool UnicodeString::startsWith(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) const { … } inline UBool UnicodeString::endsWith(const UnicodeString& text) const { … } inline UBool UnicodeString::endsWith(const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) const { … } inline UBool UnicodeString::endsWith(ConstChar16Ptr srcChars, int32_t srcLength) const { … } inline UBool UnicodeString::endsWith(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) const { … } //======================================== // replace //======================================== inline UnicodeString& UnicodeString::replace(int32_t start, int32_t _length, const UnicodeString& srcText) { … } inline UnicodeString& UnicodeString::replace(int32_t start, int32_t _length, const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) { … } inline UnicodeString& UnicodeString::replace(int32_t start, int32_t _length, ConstChar16Ptr srcChars, int32_t srcLength) { … } inline UnicodeString& UnicodeString::replace(int32_t start, int32_t _length, const char16_t *srcChars, int32_t srcStart, int32_t srcLength) { … } inline UnicodeString& UnicodeString::replace(int32_t start, int32_t _length, char16_t srcChar) { … } inline UnicodeString& UnicodeString::replaceBetween(int32_t start, int32_t limit, const UnicodeString& srcText) { … } inline UnicodeString& UnicodeString::replaceBetween(int32_t start, int32_t limit, const UnicodeString& srcText, int32_t srcStart, int32_t srcLimit) { … } inline UnicodeString& UnicodeString::findAndReplace(const UnicodeString& oldText, const UnicodeString& newText) { … } inline UnicodeString& UnicodeString::findAndReplace(int32_t start, int32_t _length, const UnicodeString& oldText, const UnicodeString& newText) { … } // ============================ // extract // ============================ inline void UnicodeString::doExtract(int32_t start, int32_t _length, UnicodeString& target) const { … } inline void UnicodeString::extract(int32_t start, int32_t _length, Char16Ptr target, int32_t targetStart) const { … } inline void UnicodeString::extract(int32_t start, int32_t _length, UnicodeString& target) const { … } #if !UCONFIG_NO_CONVERSION inline int32_t UnicodeString::extract(int32_t start, int32_t _length, char *dst, const char *codepage) const { // This dstSize value will be checked explicitly return extract(start, _length, dst, dst != nullptr ? 0xffffffff : 0, codepage); } #endif inline void UnicodeString::extractBetween(int32_t start, int32_t limit, char16_t *dst, int32_t dstStart) const { … } inline UnicodeString UnicodeString::tempSubStringBetween(int32_t start, int32_t limit) const { … } inline char16_t UnicodeString::doCharAt(int32_t offset) const { … } inline char16_t UnicodeString::charAt(int32_t offset) const { … } inline char16_t UnicodeString::operator[] (int32_t offset) const { … } inline UBool UnicodeString::isEmpty() const { … } //======================================== // Write implementation methods //======================================== inline void UnicodeString::setZeroLength() { … } inline void UnicodeString::setShortLength(int32_t len) { … } inline void UnicodeString::setLength(int32_t len) { … } inline void UnicodeString::setToEmpty() { … } inline void UnicodeString::setArray(char16_t *array, int32_t len, int32_t capacity) { … } inline UnicodeString& UnicodeString::operator= (char16_t ch) { … } inline UnicodeString& UnicodeString::operator= (UChar32 ch) { … } inline UnicodeString& UnicodeString::setTo(const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) { … } inline UnicodeString& UnicodeString::setTo(const UnicodeString& srcText, int32_t srcStart) { … } inline UnicodeString& UnicodeString::setTo(const UnicodeString& srcText) { … } inline UnicodeString& UnicodeString::setTo(const char16_t *srcChars, int32_t srcLength) { … } inline UnicodeString& UnicodeString::setTo(char16_t srcChar) { … } inline UnicodeString& UnicodeString::setTo(UChar32 srcChar) { … } inline UnicodeString& UnicodeString::append(const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) { … } inline UnicodeString& UnicodeString::append(const UnicodeString& srcText) { … } inline UnicodeString& UnicodeString::append(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) { … } inline UnicodeString& UnicodeString::append(ConstChar16Ptr srcChars, int32_t srcLength) { … } inline UnicodeString& UnicodeString::append(char16_t srcChar) { … } inline UnicodeString& UnicodeString::operator+= (char16_t ch) { … } inline UnicodeString& UnicodeString::operator+= (UChar32 ch) { … } inline UnicodeString& UnicodeString::operator+= (const UnicodeString& srcText) { … } inline UnicodeString& UnicodeString::insert(int32_t start, const UnicodeString& srcText, int32_t srcStart, int32_t srcLength) { … } inline UnicodeString& UnicodeString::insert(int32_t start, const UnicodeString& srcText) { … } inline UnicodeString& UnicodeString::insert(int32_t start, const char16_t *srcChars, int32_t srcStart, int32_t srcLength) { … } inline UnicodeString& UnicodeString::insert(int32_t start, ConstChar16Ptr srcChars, int32_t srcLength) { … } inline UnicodeString& UnicodeString::insert(int32_t start, char16_t srcChar) { … } inline UnicodeString& UnicodeString::insert(int32_t start, UChar32 srcChar) { … } inline UnicodeString& UnicodeString::remove() { … } inline UnicodeString& UnicodeString::remove(int32_t start, int32_t _length) { … } inline UnicodeString& UnicodeString::removeBetween(int32_t start, int32_t limit) { … } inline UnicodeString & UnicodeString::retainBetween(int32_t start, int32_t limit) { … } inline UBool UnicodeString::truncate(int32_t targetLength) { … } inline UnicodeString& UnicodeString::reverse() { … } inline UnicodeString& UnicodeString::reverse(int32_t start, int32_t _length) { … } U_NAMESPACE_END #endif /* U_SHOW_CPLUSPLUS_API */ #endif
Codebase Browser
godot