godot_core::engine::io module

Author: StatisMike

godot-core/src/engine/gfile.rs renamed to godot-core/src/engine/io/gfile.rs

@@ -9,15 +9,13 @@ use crate::builtin::{real, GString, PackedByteArray, PackedStringArray, Variant}
 use crate::engine::file_access::{CompressionMode, ModeFlags};
 use crate::gen::central::global::Error;
 use crate::gen::classes::FileAccess;
-use crate::obj::{Gd, Inherits};
+use crate::obj::{Gd, NotUniqueError};
 
 use std::cmp;
 use std::io::{
     BufRead, Error as IoError, ErrorKind, Read, Result as IoResult, Seek, SeekFrom, Write,
 };
 
-use super::RefCounted;
-
 /// Open a file for reading or writing.
 ///
 /// This is a convenient wrapper around a [`FileAccess`] pointer with a unique reference, providing both safety and
@@ -832,85 +830,3 @@ impl BufRead for GFile {
         self.seek(pos).expect("failed to consume bytes during read");
     }
 }
-
-// ----------------------------------------------------------------------------------------------------------------------------------------------
-// Errors.
-
-/// Error stemming from the non-uniqueness of the [`Gd`] instance.
-///
-/// Keeping track of the uniqueness of references can be crucial in many applications, especially if we want to ensure
-/// that the passed [`Gd`] reference will be possessed by only one different object instance or function in its lifetime.
-///
-/// Only applicable to [`GodotClass`](crate::obj::GodotClass) objects that inherit from [`RefCounted`]. To check the
-/// uniqueness, call the `check()` associated method.
-///
-/// ## Example
-///
-/// ```no_run
-/// use godot::engine::RefCounted;
-/// use godot::engine::NotUniqueError;
-///
-/// let shared = RefCounted::new();
-/// let cloned = shared.clone();
-/// let result = NotUniqueError::check(shared);
-///
-/// assert!(result.is_err());
-///
-/// if let Err(error) = result {
-///     assert_eq!(error.get_reference_count(), 2)
-/// }
-/// ```
-#[derive(Debug)]
-pub struct NotUniqueError {
-    reference_count: i32,
-}
-
-impl NotUniqueError {
-    /// check [`Gd`] reference uniqueness.
-    ///
-    /// Checks the [`Gd`] of the [`GodotClass`](crate::obj::GodotClass) that inherits from [`RefCounted`] if it is unique
-    /// reference to the object.
-    ///
-    /// ## Example
-    ///
-    /// ```no_run
-    /// use godot::engine::RefCounted;
-    /// use godot::engine::NotUniqueError;
-    ///
-    /// let unique = RefCounted::new();
-    /// assert!(NotUniqueError::check(unique).is_ok());
-    ///
-    /// let shared = RefCounted::new();
-    /// let cloned = shared.clone();
-    /// assert!(NotUniqueError::check(shared).is_err());
-    /// assert!(NotUniqueError::check(cloned).is_err());
-    /// ```
-    pub fn check<T>(rc: Gd<T>) -> Result<Gd<T>, Self>
-    where
-        T: Inherits<RefCounted>,
-    {
-        let rc = rc.upcast::<RefCounted>();
-        let reference_count = rc.get_reference_count();
-
-        if reference_count != 1 {
-            Err(Self { reference_count })
-        } else {
-            Ok(rc.cast::<T>())
-        }
-    }
-
-    /// Get the detected reference count
-    pub fn get_reference_count(&self) -> i32 {
-        self.reference_count
-    }
-}
-
-impl std::fmt::Display for NotUniqueError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "pointer is not unique, current reference count: {}",
-            self.reference_count
-        )
-    }
-}

godot-core/src/engine/io/mod.rs

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+mod gfile;
+mod resources;
+
+pub use gfile::GFile;
+pub use resources::{load, try_load};

godot-core/src/engine/io/resources.rs

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use crate::builtin::GString;
+use crate::gen::classes::{Resource, ResourceLoader};
+use crate::obj::{Gd, GodotClass, Inherits};
+
+/// Loads a resource from the filesystem located at `path`, panicking on error.
+///
+/// See [`try_load`] for more information.
+///
+/// # Example
+///
+/// ```no_run
+/// use godot::prelude::*;
+///
+/// let scene = load::<PackedScene>("res://path/to/Main.tscn");
+/// ```
+///
+/// # Panics
+/// If the resource cannot be loaded, or is not of type `T` or inherited.
+#[inline]
+pub fn load<T>(path: impl Into<GString>) -> Gd<T>
+where
+    T: GodotClass + Inherits<Resource>,
+{
+    let path = path.into();
+    load_impl(&path).unwrap_or_else(|| panic!("failed to load node at path `{path}`"))
+}
+
+/// Loads a resource from the filesystem located at `path`.
+///
+/// The resource is loaded on the method call (unless it's referenced already elsewhere, e.g. in another script or in the scene),
+/// which might cause slight delay, especially when loading scenes.
+///
+/// If the resource cannot be loaded, or is not of type `T` or inherited, this method returns `None`.
+///
+/// This method is a simplified version of [`ResourceLoader::load()`][crate::engine::ResourceLoader::load],
+/// which can be used for more advanced scenarios.
+///
+/// # Note:
+/// Resource paths can be obtained by right-clicking on a resource in the Godot editor (_FileSystem_ dock) and choosing "Copy Path",
+/// or by dragging the file from the _FileSystem_ dock into the script.
+///
+/// The path must be absolute (typically starting with `res://`), a local path will fail.
+///
+/// # Example
+/// Loads a scene called `Main` located in the `path/to` subdirectory of the Godot project and caches it in a variable.
+/// The resource is directly stored with type `PackedScene`.
+///
+/// ```no_run
+/// use godot::prelude::*;
+///
+/// if let Some(scene) = try_load::<PackedScene>("res://path/to/Main.tscn") {
+///     // all good
+/// } else {
+///     // handle error
+/// }
+/// ```
+// TODO Result to differentiate 2 errors
+#[inline]
+pub fn try_load<T>(path: impl Into<GString>) -> Option<Gd<T>>
+where
+    T: GodotClass + Inherits<Resource>,
+{
+    load_impl(&path.into())
+}
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Implementation of this file
+
+// Separate function, to avoid constructing string twice
+// Note that more optimizations than that likely make no sense, as loading is quite expensive
+fn load_impl<T>(path: &GString) -> Option<Gd<T>>
+where
+    T: GodotClass + Inherits<Resource>,
+{
+    ResourceLoader::singleton()
+        .load_ex(path.clone())
+        .type_hint(T::class_name().to_godot_string())
+        .done() // TODO unclone
+        .and_then(|res| res.try_cast::<T>().ok())
+}

godot-core/src/engine/mod.rs

@@ -19,10 +19,10 @@ pub use crate::gen::utilities;
 
 use crate::sys;
 
-mod gfile;
+mod io;
 mod script_instance;
 
-pub use gfile::{GFile, NotUniqueError};
+pub use io::*;
 pub use script_instance::{create_script_instance, ScriptInstance};
 
 #[cfg(debug_assertions)]
@@ -132,67 +132,6 @@ where
     }
 }
 
-/// Loads a resource from the filesystem located at `path`, panicking on error.
-///
-/// See [`try_load`] for more information.
-///
-/// # Example
-///
-/// ```no_run
-/// use godot::prelude::*;
-///
-/// let scene = load::<PackedScene>("res://path/to/Main.tscn");
-/// ```
-///
-/// # Panics
-/// If the resource cannot be loaded, or is not of type `T` or inherited.
-#[inline]
-pub fn load<T>(path: impl Into<GString>) -> Gd<T>
-where
-    T: GodotClass + Inherits<Resource>,
-{
-    let path = path.into();
-    load_impl(&path).unwrap_or_else(|| panic!("failed to load node at path `{path}`"))
-}
-
-/// Loads a resource from the filesystem located at `path`.
-///
-/// The resource is loaded on the method call (unless it's referenced already elsewhere, e.g. in another script or in the scene),
-/// which might cause slight delay, especially when loading scenes.
-///
-/// If the resource cannot be loaded, or is not of type `T` or inherited, this method returns `None`.
-///
-/// This method is a simplified version of [`ResourceLoader::load()`][crate::engine::ResourceLoader::load],
-/// which can be used for more advanced scenarios.
-///
-/// # Note:
-/// Resource paths can be obtained by right-clicking on a resource in the Godot editor (_FileSystem_ dock) and choosing "Copy Path",
-/// or by dragging the file from the _FileSystem_ dock into the script.
-///
-/// The path must be absolute (typically starting with `res://`), a local path will fail.
-///
-/// # Example
-/// Loads a scene called `Main` located in the `path/to` subdirectory of the Godot project and caches it in a variable.
-/// The resource is directly stored with type `PackedScene`.
-///
-/// ```no_run
-/// use godot::prelude::*;
-///
-/// if let Some(scene) = try_load::<PackedScene>("res://path/to/Main.tscn") {
-///     // all good
-/// } else {
-///     // handle error
-/// }
-/// ```
-// TODO Result to differentiate 2 errors
-#[inline]
-pub fn try_load<T>(path: impl Into<GString>) -> Option<Gd<T>>
-where
-    T: GodotClass + Inherits<Resource>,
-{
-    load_impl(&path.into())
-}
-
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Utilities for crate
 
@@ -287,16 +226,3 @@ fn is_derived_base_cached(derived: ClassName, base: ClassName) -> bool {
 
     is_parent_class
 }
-
-// Separate function, to avoid constructing string twice
-// Note that more optimizations than that likely make no sense, as loading is quite expensive
-fn load_impl<T>(path: &GString) -> Option<Gd<T>>
-where
-    T: GodotClass + Inherits<Resource>,
-{
-    ResourceLoader::singleton()
-        .load_ex(path.clone())
-        .type_hint(T::class_name().to_gstring())
-        .done() // TODO unclone
-        .and_then(|res| res.try_cast::<T>().ok())
-}

godot-core/src/obj/gd.rs

@@ -692,3 +692,82 @@ impl<T: GodotClass> std::hash::Hash for Gd<T> {
 // its mutability is anyway present, in the Godot engine.
 impl<T: GodotClass> std::panic::UnwindSafe for Gd<T> {}
 impl<T: GodotClass> std::panic::RefUnwindSafe for Gd<T> {}
+
+/// Error stemming from the non-uniqueness of the [`Gd`] instance.
+///
+/// Keeping track of the uniqueness of references can be crucial in many applications, especially if we want to ensure
+/// that the passed [`Gd`] reference will be possessed by only one different object instance or function in its lifetime.
+///
+/// Only applicable to [`GodotClass`] objects that inherit from [`RefCounted`](crate::gen::classes::RefCounted). To check the
+/// uniqueness, call the `check()` associated method.
+///
+/// ## Example
+///
+/// ```no_run
+/// use godot::engine::RefCounted;
+/// use godot::obj::NotUniqueError;
+///
+/// let shared = RefCounted::new();
+/// let cloned = shared.clone();
+/// let result = NotUniqueError::check(shared);
+///
+/// assert!(result.is_err());
+///
+/// if let Err(error) = result {
+///     assert_eq!(error.get_reference_count(), 2)
+/// }
+/// ```
+#[derive(Debug)]
+pub struct NotUniqueError {
+    reference_count: i32,
+}
+
+impl NotUniqueError {
+    /// check [`Gd`] reference uniqueness.
+    ///
+    /// Checks the [`Gd`] of the [`GodotClass`](crate::obj::GodotClass) that inherits from [`RefCounted`](crate::gen::classes::RefCounted)
+    /// if it is an unique reference to the object.
+    ///
+    /// ## Example
+    ///
+    /// ```no_run
+    /// use godot::engine::RefCounted;
+    /// use godot::obj::NotUniqueError;
+    ///
+    /// let unique = RefCounted::new();
+    /// assert!(NotUniqueError::check(unique).is_ok());
+    ///
+    /// let shared = RefCounted::new();
+    /// let cloned = shared.clone();
+    /// assert!(NotUniqueError::check(shared).is_err());
+    /// assert!(NotUniqueError::check(cloned).is_err());
+    /// ```
+    pub fn check<T>(rc: Gd<T>) -> Result<Gd<T>, Self>
+    where
+        T: Inherits<crate::gen::classes::RefCounted>,
+    {
+        let rc = rc.upcast::<crate::gen::classes::RefCounted>();
+        let reference_count = rc.get_reference_count();
+
+        if reference_count != 1 {
+            Err(Self { reference_count })
+        } else {
+            Ok(rc.cast::<T>())
+        }
+    }
+
+    /// Get the detected reference count
+    pub fn get_reference_count(&self) -> i32 {
+        self.reference_count
+    }
+}
+
+impl std::fmt::Display for NotUniqueError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "pointer is not unique, current reference count: {}",
+            self.reference_count
+        )
+    }
+}