GString/StringName: custom find() + split(); shared macro code reuse

Author: Bromeon

Changelog.md

@@ -14,6 +14,7 @@ Cutting-edge API docs of the `master` branch are available [here](https://godot-
 - [v0.1.1](#v011), [v0.1.2](#v012), [v0.1.3](#v013)
 
 
+
 ## [v0.2.1](https://docs.rs/godot/0.2.1)
 
 _8 December 2024_

godot-codegen/src/special_cases/special_cases.rs

@@ -235,12 +235,8 @@ pub fn is_builtin_method_exposed(builtin_ty: &TyName, godot_method_name: &str) -
         // TODO maybe consider renaming "match_" -> "matches". The "*n" could technically be "*_n", but is probably OK.
 
         // GString
-        | ("String", "find")
-        | ("String", "findn")
         | ("String", "count")
         | ("String", "countn")
-        | ("String", "rfind")
-        | ("String", "rfindn")
         | ("String", "match")
         | ("String", "matchn")
         | ("String", "begins_with")
@@ -259,8 +255,6 @@ pub fn is_builtin_method_exposed(builtin_ty: &TyName, godot_method_name: &str) -
         | ("String", "to_camel_case")
         | ("String", "to_pascal_case")
         | ("String", "to_snake_case")
-        | ("String", "split")
-        | ("String", "rsplit")
         | ("String", "split_floats")
         | ("String", "join")
         | ("String", "to_upper")
@@ -331,21 +325,8 @@ pub fn is_builtin_method_exposed(builtin_ty: &TyName, godot_method_name: &str) -
         | ("String", "humanize_size")
 
         // StringName
-        | ("StringName", "casecmp_to")
-        | ("StringName", "nocasecmp_to")
-        | ("StringName", "naturalcasecmp_to")
-        | ("StringName", "naturalnocasecmp_to")
-        | ("StringName", "filecasecmp_to")
-        | ("StringName", "filenocasecmp_to")
-        | ("StringName", "get_slice")
-        | ("StringName", "get_slicec")
-        | ("StringName", "get_slice_count")
-        | ("StringName", "find")
-        | ("StringName", "findn")
         | ("StringName", "count")
         | ("StringName", "countn")
-        | ("StringName", "rfind")
-        | ("StringName", "rfindn")
         | ("StringName", "match")
         | ("StringName", "matchn")
         | ("StringName", "begins_with")
@@ -364,8 +345,6 @@ pub fn is_builtin_method_exposed(builtin_ty: &TyName, godot_method_name: &str) -
         | ("StringName", "to_camel_case")
         | ("StringName", "to_pascal_case")
         | ("StringName", "to_snake_case")
-        | ("StringName", "split")
-        | ("StringName", "rsplit")
         | ("StringName", "split_floats")
         | ("StringName", "join")
         | ("StringName", "to_upper")

godot-core/src/builtin/mod.rs

@@ -82,7 +82,7 @@ pub mod iter {
 
 /// Specialized types related to Godot's various string implementations.
 pub mod strings {
-    pub use super::string::TransientStringNameOrd;
+    pub use super::string::{ExStringNameFind, ExStringNameSplit, ExGStringFind, ExGStringSplit, TransientStringNameOrd};
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------

godot-core/src/builtin/string/gstring.rs

@@ -7,17 +7,16 @@
 
 use std::convert::Infallible;
 use std::ffi::c_char;
+use std::fmt;
 use std::fmt::Write;
-use std::str::FromStr;
-use std::{cmp, fmt, ops};
 
 use godot_ffi as sys;
 use sys::types::OpaqueString;
 use sys::{ffi_methods, interface_fn, GodotFfi};
 
 use crate::builtin::{inner, NodePath, StringName, Variant};
-use crate::meta;
 use crate::meta::AsArg;
+use crate::{impl_shared_string_api, meta};
 
 /// Godot's reference counted string type.
 ///
@@ -112,134 +111,6 @@ impl GString {
         }
     }
 
-    /// Returns a substring of this, as another `GString`.
-    pub fn substr(&self, range: impl ops::RangeBounds<usize>) -> Self {
-        let (from, len) = super::to_fromlen_pair(range);
-
-        self.as_inner().substr(from, len)
-    }
-
-    /// Format a string using substitutions from an array or dictionary.
-    ///
-    /// See Godot's [`String.format()`](https://docs.godotengine.org/en/stable/classes/class_string.html#class-string-method-format).
-    pub fn format(&self, array_or_dict: &Variant) -> Self {
-        self.as_inner().format(array_or_dict, "{_}")
-    }
-
-    /// Format a string using substitutions from an array or dictionary + custom placeholder.
-    ///
-    /// See Godot's [`String.format()`](https://docs.godotengine.org/en/stable/classes/class_string.html#class-string-method-format).
-    pub fn format_with_placeholder(
-        &self,
-        array_or_dict: &Variant,
-        placeholder: impl AsArg<GString>,
-    ) -> Self {
-        self.as_inner().format(array_or_dict, placeholder)
-    }
-
-    /// Case-sensitive, lexicographic comparison to another string.
-    ///
-    /// Returns the `Ordering` relation of `self` towards `to`. Ordering is determined by the Unicode code points of each string, which roughly
-    /// matches the alphabetical order.
-    ///
-    /// See also [`nocasecmp_to()`](Self::nocasecmp_to), [`naturalcasecmp_to()`](Self::naturalcasecmp_to), [`filecasecmp_to()`](Self::filecasecmp_to).
-    pub fn casecmp_to(&self, to: impl AsArg<GString>) -> cmp::Ordering {
-        sys::i64_to_ordering(self.as_inner().casecmp_to(to))
-    }
-
-    /// Case-**insensitive**, lexicographic comparison to another string.
-    ///
-    /// Returns the `Ordering` relation of `self` towards `to`. Ordering is determined by the Unicode code points of each string, which roughly
-    /// matches the alphabetical order.
-    ///
-    /// See also [`casecmp_to()`](Self::casecmp_to), [`naturalcasecmp_to()`](Self::naturalcasecmp_to), [`filecasecmp_to()`](Self::filecasecmp_to).
-    pub fn nocasecmp_to(&self, to: impl AsArg<GString>) -> cmp::Ordering {
-        sys::i64_to_ordering(self.as_inner().nocasecmp_to(to))
-    }
-
-    /// Case-sensitive, **natural-order** comparison to another string.
-    ///
-    /// Returns the `Ordering` relation of `self` towards `to`. Ordering is determined by the Unicode code points of each string, which roughly
-    /// matches the alphabetical order.
-    ///
-    /// When used for sorting, natural order comparison orders sequences of numbers by the combined value of each digit as is often expected,
-    /// instead of the single digit's value. A sorted sequence of numbered strings will be `["1", "2", "3", ...]`, not `["1", "10", "2", "3", ...]`.
-    ///
-    /// With different string lengths, returns `Ordering::Greater` if this string is longer than the `to` string, or `Ordering::Less` if shorter.
-    ///
-    /// See also [`casecmp_to()`](Self::casecmp_to), [`naturalnocasecmp_to()`](Self::naturalnocasecmp_to), [`filecasecmp_to()`](Self::filecasecmp_to).
-    pub fn naturalcasecmp_to(&self, to: impl AsArg<GString>) -> cmp::Ordering {
-        sys::i64_to_ordering(self.as_inner().naturalcasecmp_to(to))
-    }
-
-    /// Case-insensitive, **natural-order** comparison to another string.
-    ///
-    /// Returns the `Ordering` relation of `self` towards `to`. Ordering is determined by the Unicode code points of each string, which roughly
-    /// matches the alphabetical order.
-    ///
-    /// When used for sorting, natural order comparison orders sequences of numbers by the combined value of each digit as is often expected,
-    /// instead of the single digit's value. A sorted sequence of numbered strings will be `["1", "2", "3", ...]`, not `["1", "10", "2", "3", ...]`.
-    ///
-    /// With different string lengths, returns `Ordering::Greater` if this string is longer than the `to` string, or `Ordering::Less` if shorter.
-    ///
-    /// See also [`casecmp_to()`](Self::casecmp_to), [`naturalcasecmp_to()`](Self::naturalcasecmp_to), [`filecasecmp_to()`](Self::filecasecmp_to).
-    pub fn naturalnocasecmp_to(&self, to: impl AsArg<GString>) -> cmp::Ordering {
-        sys::i64_to_ordering(self.as_inner().naturalnocasecmp_to(to))
-    }
-
-    /// Case-sensitive, filename-oriented comparison to another string.
-    ///
-    /// Like [`naturalcasecmp_to()`][Self::naturalcasecmp_to], but prioritizes strings that begin with periods (`.`) and underscores (`_`) before
-    /// any other character. Useful when sorting folders or file names.
-    ///
-    /// See also [`casecmp_to()`](Self::casecmp_to), [`naturalcasecmp_to()`](Self::naturalcasecmp_to), [`filenocasecmp_to()`](Self::filenocasecmp_to).
-    #[cfg(since_api = "4.3")]
-    pub fn filecasecmp_to(&self, to: impl AsArg<GString>) -> cmp::Ordering {
-        sys::i64_to_ordering(self.as_inner().filecasecmp_to(to))
-    }
-
-    /// Case-insensitive, filename-oriented comparison to another string.
-    ///
-    /// Like [`naturalnocasecmp_to()`][Self::naturalnocasecmp_to], but prioritizes strings that begin with periods (`.`) and underscores (`_`) before
-    /// any other character. Useful when sorting folders or file names.
-    ///
-    /// See also [`casecmp_to()`](Self::casecmp_to), [`naturalcasecmp_to()`](Self::naturalcasecmp_to), [`filecasecmp_to()`](Self::filecasecmp_to).
-    #[cfg(since_api = "4.3")]
-    pub fn filenocasecmp_to(&self, to: impl AsArg<GString>) -> cmp::Ordering {
-        sys::i64_to_ordering(self.as_inner().filenocasecmp_to(to))
-    }
-
-    /// Splits the string using a string delimiter and returns the substring at index `slice`.
-    ///
-    /// Returns the original string if delimiter does not occur in the string. Returns `None` if `slice` is out of bounds.
-    ///
-    /// This is faster than [`split()`][Self::split], if you only need one substring.
-    pub fn get_slice(&self, delimiter: impl AsArg<GString>, slice: usize) -> Option<GString> {
-        let sliced = self.as_inner().get_slice(delimiter, slice as i64);
-
-        // Note: self="" always returns None.
-        super::populated_or_none(sliced)
-    }
-
-    /// Returns the total number of slices, when the string is split with the given delimiter.
-    ///
-    /// See also [`split()`][Self::split] and [`get_slice()`][Self::get_slice].
-    pub fn get_slice_count(&self, delimiter: impl AsArg<GString>) -> usize {
-        self.as_inner().get_slice_count(delimiter) as usize
-    }
-
-    /// Splits the string using a Unicode char `delimiter` and returns the substring at index `slice`.
-    ///
-    /// Returns the original string if delimiter does not occur in the string. Returns `None` if `slice` is out of bounds.
-    ///
-    /// This is faster than [`split()`][Self::split], if you only need one substring.
-    pub fn get_slicec(&self, delimiter: char, slice: usize) -> Option<GString> {
-        let sliced = self.as_inner().get_slicec(delimiter as i64, slice as i64);
-
-        // Note: self="" always returns None.
-        super::populated_or_none(sliced)
-    }
-
     ffi_methods! {
         type sys::GDExtensionStringPtr = *mut Self;
 
@@ -289,7 +160,7 @@ impl GString {
     }
 
     meta::declare_arg_method! {
-        /// Use as argument for an [`impl AsArg<StringName|NodePath>`][crate::AsArg] parameter.
+        /// Use as argument for an [`impl AsArg<StringName|NodePath>`][crate::meta::AsArg] parameter.
         ///
         /// This is a convenient way to convert arguments of similar string types.
         ///
@@ -342,6 +213,12 @@ impl_builtin_traits! {
     }
 }
 
+impl_shared_string_api! {
+    builtin: GString,
+    find_builder: ExGStringFind,
+    split_builder: ExGStringSplit,
+}
+
 impl fmt::Display for GString {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         for ch in self.chars() {
@@ -438,7 +315,7 @@ impl From<GString> for String {
     }
 }
 
-impl FromStr for GString {
+impl std::str::FromStr for GString {
     type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {

godot-core/src/builtin/string/mod.rs

@@ -10,6 +10,7 @@
 mod gstring;
 mod macros;
 mod node_path;
+mod string_macros;
 mod string_name;
 
 use crate::meta::error::ConvertError;
@@ -18,7 +19,7 @@ use std::ops;
 
 pub use gstring::*;
 pub use node_path::NodePath;
-pub use string_name::{StringName, TransientStringNameOrd};
+pub use string_name::*;
 
 impl GodotConvert for &str {
     type Via = GString;
@@ -82,3 +83,16 @@ fn populated_or_none(s: GString) -> Option<GString> {
         Some(s)
     }
 }
+
+fn found_to_option(index: i64) -> Option<usize> {
+    if index == -1 {
+        None
+    } else {
+        // If this fails, then likely because we overlooked a negative value.
+        let index_usize = index
+            .try_into()
+            .unwrap_or_else(|_| panic!("unexpected index {index} returned from Godot function"));
+
+        Some(index_usize)
+    }
+}