Struct gdnative_core::core_types::string::GodotString

pub struct GodotString(_);

Godot's reference-counted string type.

This is the Rust binding of GDScript's String type. It represents the native string class used within the Godot engine, and as such has different memory layout and characteristics than std::string::String.

GodotString is reference-counted like most types in godot-rust. Thus, its clone() method does not return a copy of the string, but simply another instance which shares the same backing string. Furthermore, GodotString is immutable and does not offer any write APIs. If you need to modify Godot strings, convert them to Rust strings, perform the modifications and convert back. In GDScript, strings have copy-on-write semantics, which guarantees that GodotString instances in Rust are independent of their GDScript counterparts. A modification of a string in GDScript (which was previously passed to Rust) will not be reflected in Rust.

When interfacing with the Godot engine API through godot-rust, you often have the choice between std::string::String and gdnative::core_types::GodotString. In user methods that are exposed to Godot through the #[export] macro, both types can be used as parameters and return types, and any conversions are done transparently. For auto-generated binding APIs in gdnative::api, return types are GodotString, but parameters are declared impl Into<GodotString>, allowing String or &str to be passed. In addition, the two types can always be explicitly converted using GodotString::from_str() and GodotString::display/to_string().

As a general guideline, use GodotString if:

• your strings are very large, so you can avoid copying them
• you need specific operations only available in Godot (e.g. sha256_text(), c_escape(), ...)
• you primarily pass them between different Godot APIs, without string processing in user code

Use Rust's String if:

• you need to modify the string
• you would like to decouple part of your code from Godot (e.g. independent game logic, standalone tests)
• you want a standard type for interoperability with third-party code (e.g. regex crate)
• you have a large number of method calls per string instance (which are more expensive due to indirectly calling into Godot)
• you need UTF-8 encoding (GodotString's encoding is platform-dependent and unspecified)

Implementations

impl GodotString

pub fn new() -> Self

pub fn from_str<S>(s: S) -> Self where
    S: AsRef<str>, 

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn is_numeric(&self) -> bool

pub fn is_valid_float(&self) -> bool

pub fn is_valid_html_color(&self) -> bool

pub fn is_valid_identifier(&self) -> bool

pub fn is_valid_integer(&self) -> bool

pub fn is_valid_ip_address(&self) -> bool

pub fn is_resource_file(&self) -> bool

pub fn is_absolute_path(&self) -> bool

pub fn is_relative_path(&self) -> bool

pub fn to_f32(&self) -> f32

pub fn to_f64(&self) -> f64

pub fn to_i32(&self) -> i32

pub fn u32_hash(&self) -> u32

pub fn u64_hash(&self) -> u64

pub fn hex_to_int(&self) -> i32

pub fn hex_to_int_without_prefix(&self) -> i32

pub fn camelcase_to_underscore(&self) -> Self

pub fn camelcase_to_underscore_lowercased(&self) -> Self

pub fn capitalize(&self) -> Self

pub fn to_lowercase(&self) -> Self

pub fn to_uppercase(&self) -> Self

pub fn get_file(&self) -> Self

pub fn get_base_dir(&self) -> Self

pub fn get_basename(&self) -> Self

pub fn get_extension(&self) -> Self

pub fn simplify_path(&self) -> Self

pub fn sha256_text(&self) -> Self

pub fn md5_text(&self) -> Self

pub fn c_escape(&self) -> Self

pub fn c_escape_multiline(&self) -> Self

pub fn c_unescape(&self) -> Self

pub fn http_escape(&self) -> Self

pub fn http_unescape(&self) -> Self

pub fn json_escape(&self) -> Self

pub fn xml_escape(&self) -> Self

pub fn xml_escape_with_quotes(&self) -> Self

pub fn xml_unescape(&self) -> Self

pub fn percent_decode(&self) -> Self

pub fn percent_encode(&self) -> Self

pub fn is_valid_hex_number(&self, with_prefix: bool) -> bool

pub fn begins_with(&self, s: &GodotString) -> bool

pub fn ends_with(&self, s: &GodotString) -> bool

pub fn begins_with_c_str(&self, s: &CStr) -> bool

pub fn sub_string(&self, range: Range<usize>) -> Self

pub fn find(&self, what: &GodotString) -> i32

pub fn find_from(&self, what: &GodotString, from: i32) -> i32

pub fn find_last(&self, what: &GodotString) -> i32

Trait Implementations

impl Add<&'_ GodotString> for &GodotString

type Output = GodotString

The resulting type after applying the + operator.

fn add(self, other: &GodotString) -> GodotString

Performs the + operation.

impl Add<GodotString> for GodotString

type Output = GodotString

The resulting type after applying the + operator.

fn add(self, other: GodotString) -> GodotString

Performs the + operation.

impl<S> Add<S> for &GodotString where
    S: AsRef<str>, 

type Output = GodotString

The resulting type after applying the + operator.

fn add(self, other: S) -> GodotString

Performs the + operation.

impl AddAssign<&'_ GodotString> for GodotString

AddAssign implementations copy the strings' contents since GodotString is immutable.

fn add_assign(&mut self, other: &Self)

Performs the += operation.

impl AddAssign<GodotString> for GodotString

AddAssign implementations copy the strings' contents since GodotString is immutable.

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<S> AddAssign<S> for GodotString where
    S: AsRef<str>, 

AddAssign implementations copy the strings' contents since GodotString is immutable.

fn add_assign(&mut self, other: S)

Performs the += operation.

impl Clone for GodotString

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GodotString

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for GodotString

fn default() -> Self

Returns the "default value" for a type.

impl Display for GodotString

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for GodotString

fn drop(&mut self)

Executes the destructor for this type.

impl Element for GodotString

type SysArray = godot_pool_string_array

type SysReadAccess = godot_pool_string_array_read_access

type SysWriteAccess = godot_pool_string_array_write_access

type SysTy = godot_string

type SysRefTy = *const godot_string

const SYS_VARIANT_TYPE: godot_variant_type

fn element_to_sys(self) -> Self::SysTy

fn element_from_sys(sys: Self::SysTy) -> Self

fn element_to_sys_ref(&self) -> Self::SysRefTy

unsafe fn element_from_sys_ref(sys: Self::SysRefTy) -> Self

fn array_to_variant_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut godot_variant, _: *const Self::SysArray)

fn array_from_variant_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *const godot_variant) -> Self::SysArray

fn new_fn(api: &GodotApi) -> unsafe extern "C" fn(_: *mut Self::SysArray)

fn new_copy_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: *const Self::SysArray)

fn new_with_array_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: *const godot_array)

fn append_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: Self::SysRefTy)

fn append_array_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: *const Self::SysArray)

fn insert_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: godot_int, _: Self::SysRefTy) -> godot_error

fn invert_fn(api: &GodotApi) -> unsafe extern "C" fn(_: *mut Self::SysArray)

fn push_back_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: Self::SysRefTy)

fn remove_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: godot_int)

fn resize_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: godot_int)

fn read_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *const Self::SysArray) -> *mut Self::SysReadAccess

fn write_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray) -> *mut Self::SysWriteAccess

fn set_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysArray, _: godot_int, _: Self::SysRefTy)

fn get_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *const Self::SysArray, _: godot_int) -> Self::SysTy

fn size_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *const Self::SysArray) -> godot_int

fn destroy_fn(api: &GodotApi) -> unsafe extern "C" fn(_: *mut Self::SysArray)

fn read_access_copy_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *const Self::SysReadAccess) -> *mut Self::SysReadAccess

fn read_access_ptr_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *const Self::SysReadAccess) -> *const Self::SysTy

fn read_access_operator_assign_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysReadAccess, _: *mut Self::SysReadAccess)

fn read_access_destroy_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysReadAccess)

fn write_access_copy_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *const Self::SysWriteAccess) -> *mut Self::SysWriteAccess

fn write_access_ptr_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *const Self::SysWriteAccess) -> *mut Self::SysTy

fn write_access_operator_assign_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysWriteAccess, _: *mut Self::SysWriteAccess)

fn write_access_destroy_fn(
    api: &GodotApi
) -> unsafe extern "C" fn(_: *mut Self::SysWriteAccess)

impl Eq for GodotString

impl Export for GodotString

type Hint = StringHint

A type-specific hint type that is valid for the type being exported.

fn export_info(hint: Option<Self::Hint>) -> ExportInfo

Returns ExportInfo given an optional typed hint.

impl From<GodotString> for NodePath

fn from(s: GodotString) -> NodePath

Performs the conversion.

impl<S> From<S> for GodotString where
    S: AsRef<str>, 

fn from(s: S) -> GodotString

Performs the conversion.

impl FromVariant for GodotString

fn from_variant(variant: &Variant) -> Result<Self, FromVariantError>

impl Hash for GodotString

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Index<usize> for GodotString

The index operator provides a low-level view of characters in Godot's native encoding that doesn't always correspond to Unicode code points one-to-one. This operation goes through FFI. For intensive string operations, consider converting to a Rust String first to avoid this cost.

type Output = GodotChar

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Into<GodotString> for NodePath

fn into(self) -> GodotString

Performs the conversion.

impl NewRef for GodotString

fn new_ref(&self) -> GodotString

Creates a new reference to the underlying object.

impl Ord for GodotString

fn cmp(&self, other: &GodotString) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<GodotString> for GodotString

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<GodotString> for GodotString

fn partial_cmp(&self, other: &GodotString) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl ToVariant for GodotString

fn to_variant(&self) -> Variant

impl ToVariantEq for GodotString