save and try_save addition; try_load refactor

StatisMike · StatisMike · commit 7b79b58b712d · 2023-12-14T21:06:18.000+01:00
diff --git a/godot-codegen/src/codegen_special_cases.rs b/godot-codegen/src/codegen_special_cases.rs
@@ -162,6 +162,7 @@ const SELECTED_CLASSES: &[&str] = &[
     "Resource",
     "ResourceFormatLoader",
     "ResourceLoader",
+    "ResourceSaver",
     "RigidBody2D",
     "SceneTree",
     "SceneTreeTimer",
diff --git a/godot-core/src/engine/io/gfile.rs b/godot-core/src/engine/io/gfile.rs
@@ -9,7 +9,9 @@ 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, NotUniqueError};
+use crate::obj::Gd;
+
+use crate::engine::io::GdIoError;
 
 use std::cmp;
 use std::io::{
@@ -203,9 +205,8 @@ impl GFile {
     /// Its state is retained: both [`ModeFlags`] with which it was open and current internal cursor position.
     ///
     /// See also [`into_inner`](Self::into_inner) for the opposite operation.
-    pub fn try_from_unique(file_access: Gd<FileAccess>) -> Result<Self, NotUniqueError> {
-        // TODO: Remodel to add check `file_access.is_open()`, Err otherwise
-        let file_access = NotUniqueError::check(file_access)?;
+    pub fn try_from_unique(file_access: Gd<FileAccess>) -> Result<Self, GdIoError> {
+        let file_access = GdIoError::check_unique_open_file_access(file_access)?;
         Ok(Self::from_inner(file_access))
     }
 
diff --git a/godot-core/src/engine/io/io_error.rs b/godot-core/src/engine/io/io_error.rs
@@ -0,0 +1,162 @@
+/*
+ * 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 std::error::Error;
+
+use crate::engine::global::Error as GodotError;
+use crate::gen::classes::FileAccess;
+use crate::obj::{Gd, NotUniqueError};
+
+type Source = Box<dyn Error + 'static>;
+
+/// Error that can occur while using `gdext` IO utilities.
+#[derive(Debug)]
+pub struct GdIoError {
+    kind: ErrorKind,
+    source: Option<Source>,
+    class: Option<String>,
+    path: Option<String>,
+    godot_error: Option<GodotError>,
+}
+
+impl Default for GdIoError {
+    fn default() -> Self {
+        Self {
+            kind: ErrorKind::Custom,
+            source: None,
+            class: None,
+            path: None,
+            godot_error: None,
+        }
+    }
+}
+
+impl GdIoError {
+    /// Kind of the occured error.
+    pub fn kind(&self) -> ErrorKind {
+        self.kind
+    }
+
+    /// Path to the file the IO process was handling.
+    pub fn path(&self) -> Option<&str> {
+        self.path.as_deref()
+    }
+
+    /// Name of the [Resource](crate::engine::Resource)-inheriting class that the IO process was handling, if any.
+    pub fn class(&self) -> Option<&str> {
+        self.class.as_deref()
+    }
+
+    /// Underlying Godot error, if any.
+    pub fn godot_error(&self) -> Option<GodotError> {
+        self.godot_error
+    }
+
+    pub(crate) fn saving(error: GodotError, class: String, path: String) -> Self {
+        Self {
+            kind: ErrorKind::ResourceCantSave,
+            class: Some(class),
+            path: Some(path),
+            godot_error: Some(error),
+            ..Default::default()
+        }
+    }
+
+    pub(crate) fn loading(class: String, path: String) -> Self {
+        Self {
+            kind: ErrorKind::ResourceCantLoad,
+            class: Some(class),
+            path: Some(path),
+            ..Default::default()
+        }
+    }
+
+    pub(crate) fn loading_cast(class: String, path: String) -> Self {
+        Self {
+            kind: ErrorKind::ResourceCantCast,
+            class: Some(class),
+            path: Some(path),
+            ..Default::default()
+        }
+    }
+
+    pub(crate) fn check_unique_open_file_access(
+        file_access: Gd<FileAccess>,
+    ) -> Result<Gd<FileAccess>, Self> {
+        let path = file_access.get_path();
+        if !file_access.is_open() {
+            return Err(Self {
+                kind: ErrorKind::FileAccessNotOpen,
+                path: Some(path.to_string()),
+                ..Default::default()
+            });
+        }
+        match NotUniqueError::check(file_access) {
+            Ok(gd) => Ok(gd),
+            Err(err) => Err(Self {
+                kind: ErrorKind::FileAccessNotUnique,
+                path: Some(path.to_string()),
+                source: Some(err.into()),
+                ..Default::default()
+            }),
+        }
+    }
+}
+
+impl std::fmt::Display for GdIoError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match (
+            self.kind(),
+            self.path(),
+            self.class(),
+            self.source(),
+            self.godot_error(),
+        ) {
+            (ErrorKind::ResourceCantLoad, Some(path), Some(class), _, _) => write!(
+                    f, "can't load resource of class: '{class}' from path: '{path}'"
+                  ),
+            (ErrorKind::ResourceCantCast, Some(path), Some(class), _, _) => write!(
+                    f, "can't cast loaded resource to GodotClass: '{class}' from path: '{path}'"
+                  ),
+            (ErrorKind::ResourceCantSave, Some(path), Some(class), _, Some(godot_error)) => write!(
+                    f, "can't save resource of GodotClass: '{class}' to path: '{path}'; Godot error: {godot_error:?}"
+                  ),
+            (ErrorKind::FileAccessNotOpen, Some(path), _, _, _) => write!(
+                    f, "access to file '{path}' is not open"
+                  ),
+            (ErrorKind::ResourceCantLoad, Some(path), _, Some(source), _) => write!(
+                    f, "file access to '{path}' is not unique: '{source}'"
+                  ),
+            _ => write!(f, "{self:?}"),
+        }
+    }
+}
+
+impl Error for GdIoError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        if let Some(source) = &self.source {
+            return Some(source.as_ref());
+        }
+        None
+    }
+}
+
+#[derive(Eq, PartialEq, Debug, Clone, Copy)]
+pub enum ErrorKind {
+    /// Kind of error occuring when loading resource with [try_load](crate::engine::io::try_load) fails while loading object from file.
+    ResourceCantLoad,
+    /// Kind of error occuring when loading resource with [try_load](crate::engine::io::try_load) fails while casting object into provided GodotClass.
+    ResourceCantCast,
+    /// Kind of error occuring when saving resource with [try_save](crate::engine::io::try_save) fails.
+    ResourceCantSave,
+    /// Kind of error occuring when [FileAccess] used to create [GFile](crate::engine::io::GFile) is not open.
+    FileAccessNotOpen,
+    /// Kind of error occuring when pointer to [FileAccess] is not an unique reference when creating [GFile](crate::engine::io::GFile).
+    FileAccessNotUnique,
+    /// Default [GdIoError] type. Shouldn't occur from built-in `gdext` functions.
+    Custom,
+}
diff --git a/godot-core/src/engine/io/mod.rs b/godot-core/src/engine/io/mod.rs
@@ -6,7 +6,9 @@
  */
 
 mod gfile;
+mod io_error;
 mod resources;
 
 pub use gfile::GFile;
-pub use resources::{load, try_load};
+pub use io_error::*;
+pub use resources::{load, save, try_load, try_save};
diff --git a/godot-core/src/engine/io/resources.rs b/godot-core/src/engine/io/resources.rs
@@ -6,9 +6,12 @@
  */
 
 use crate::builtin::GString;
-use crate::gen::classes::{Resource, ResourceLoader};
+use crate::engine::global::Error as GodotError;
+use crate::gen::classes::{Resource, ResourceLoader, ResourceSaver};
 use crate::obj::{Gd, GodotClass, Inherits};
 
+use super::GdIoError;
+
 /// Loads a resource from the filesystem located at `path`, panicking on error.
 ///
 /// See [`try_load`] for more information.
@@ -29,15 +32,15 @@ where
     T: GodotClass + Inherits<Resource>,
 {
     let path = path.into();
-    load_impl(&path).unwrap_or_else(|| panic!("failed to load node at path `{path}`"))
+    load_impl(&path).unwrap_or_else(|err| panic!("failed: {err}"))
 }
 
 /// 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 function can fail if resource can't be loaded by [`ResourceLoader`] or if the subsequent cast into `T` fails.
 ///
 /// This method is a simplified version of [`ResourceLoader::load()`][crate::engine::ResourceLoader::load],
 /// which can be used for more advanced scenarios.
@@ -55,33 +58,125 @@ where
 /// ```no_run
 /// use godot::prelude::*;
 ///
-/// if let Some(scene) = try_load::<PackedScene>("res://path/to/Main.tscn") {
+/// if let Ok(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>>
+pub fn try_load<T>(path: impl Into<GString>) -> Result<Gd<T>, GdIoError>
 where
     T: GodotClass + Inherits<Resource>,
 {
     load_impl(&path.into())
 }
 
+/// Saves a [`Resource`]-inheriting [`GodotClass`] `obj` into file located at `path`.
+///
+/// See [`try_save`] for more information.
+///
+/// # Panics
+/// If the resouce cannot be saved.
+///
+/// # Example
+/// ```no_run
+/// use godot::prelude::*;
+/// use godot::engine::save;
+///
+/// save(Resource::new(), "res://base_resource.tres")
+/// ```
+/// use godot::
+#[inline]
+pub fn save<T>(obj: Gd<T>, path: impl Into<GString>)
+where
+    T: GodotClass + Inherits<Resource>,
+{
+    let path = path.into();
+    save_impl(obj, &path)
+        .unwrap_or_else(|err| panic!("failed to save resource at path '{}': {}", &path, err));
+}
+
+/// Saves a [Resource]-inheriting [GodotClass] `obj` into file located at `path`.
+///
+/// This function can fail if [`ResourceSaver`] can't save the resource to file, as it is a simplified version of
+/// [`ResourceSaver::save()`][crate::engine::ResourceSaver::save]. The underlying method can be used for more advances scenarios.
+///
+/// # Note
+/// Target path must be presented in Godot-recognized format, mainly the ones beginning with `res://` and `user://`. Saving
+/// to `res://` is possible only when working with unexported project - after its export only `user://` is viable.
+///
+/// # Example
+/// ```no_run
+/// use godot::prelude::*;
+/// use godot::engine::try_save;
+///
+/// #[derive(GodotClass)]
+/// #[class(base=Resource, init)]
+/// struct SavedGame {
+///   // exported properties are saved in `.tres` files
+///   #[export]
+///   level: u32
+/// };
+///
+/// let savestate = SavedGame::new_gd();
+/// let res = try_save(savestate, "user://save.tres");
+///
+/// assert!(res.is_ok());
+/// ```
+#[inline]
+pub fn try_save<T>(obj: Gd<T>, path: impl Into<GString>) -> Result<(), GdIoError>
+where
+    T: GodotClass + Inherits<Resource>,
+{
+    save_impl(obj, &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>>
+fn load_impl<T>(path: &GString) -> Result<Gd<T>, GdIoError>
 where
     T: GodotClass + Inherits<Resource>,
 {
-    ResourceLoader::singleton()
+    // TODO unclone GString
+    match 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())
+        .done()
+    {
+        Some(res) => match res.try_cast::<T>() {
+            Ok(obj) => Ok(obj),
+            Err(_) => Err(GdIoError::loading_cast(
+                T::class_name().to_string(),
+                path.to_string(),
+            )),
+        },
+        None => Err(GdIoError::loading(
+            T::class_name().to_string(),
+            path.to_string(),
+        )),
+    }
+}
+
+fn save_impl<T>(obj: Gd<T>, path: &GString) -> Result<(), GdIoError>
+where
+    T: GodotClass + Inherits<Resource>,
+{
+    // TODO unclone GString
+    let res = ResourceSaver::singleton()
+        .save_ex(obj.upcast())
+        .path(path.clone())
+        .done();
+
+    if res == GodotError::OK {
+        return Ok(());
+    }
+    Err(GdIoError::saving(
+        res,
+        T::class_name().to_string(),
+        path.to_string(),
+    ))
 }
diff --git a/godot-core/src/obj/gd.rs b/godot-core/src/obj/gd.rs
@@ -739,6 +739,8 @@ impl NotUniqueError {
     }
 }
 
+impl std::error::Error for NotUniqueError {}
+
 impl std::fmt::Display for NotUniqueError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
diff --git a/itest/rust/src/engine_tests/mod.rs b/itest/rust/src/engine_tests/mod.rs
@@ -8,4 +8,5 @@
 mod gfile_test;
 mod native_structures_test;
 mod node_test;
+mod save_load_test;
 mod utilities_test;
diff --git a/itest/rust/src/engine_tests/save_load_test.rs b/itest/rust/src/engine_tests/save_load_test.rs
diff --git a/itest/rust/src/object_tests/object_test.rs b/itest/rust/src/object_tests/object_test.rs

Original file line number	Diff line number	Diff line change
`@@ -739,6 +739,8 @@ impl NotUniqueError {`
`739`	`739`	`}`
`740`	`740`	`}`
`741`	`741`
	`742`	`+impl std::error::Error for NotUniqueError {}`
	`743`	`+`
`742`	`744`	`impl std::fmt::Display for NotUniqueError {`
`743`	`745`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`744`	`746`	`write!(`