downcasting for dyn type

Author: mrDIMAS

fyrox-core/src/dyntype.rs

@@ -28,8 +28,13 @@ use std::{
 use uuid::Uuid;
 
 pub enum DynTypeError {
+    Empty,
     NoConstructorContainerProvided,
     NoConstructorForTypeUuid(Uuid),
+    TypeCast {
+        actual_type_name: &'static str,
+        requested_type_name: &'static str,
+    },
 }
 
 impl DynTypeError {
@@ -55,6 +60,19 @@ impl Display for DynTypeError {
                     there's no constructor provided for the {uuid} type!"
                 )
             }
+            DynTypeError::Empty => {
+                write!(f, "The container is empty")
+            }
+            DynTypeError::TypeCast {
+                actual_type_name,
+                requested_type_name,
+            } => {
+                write!(
+                    f,
+                    "The actual type ({actual_type_name}) of the \
+                dynamic type is different ({requested_type_name})."
+                )
+            }
         }
     }
 }
@@ -207,6 +225,27 @@ impl DynTypeContainer {
     pub fn value_mut(&mut self) -> Option<&mut dyn DynType> {
         self.0.as_mut().map(|v| &mut *v.0)
     }
+
+    pub fn data_ref<T: DynType>(&self) -> Result<&T, DynTypeError> {
+        let value = self.value_ref().ok_or(DynTypeError::Empty)?;
+        (value as &dyn Any)
+            .downcast_ref()
+            .ok_or_else(|| DynTypeError::TypeCast {
+                actual_type_name: Reflect::type_name(value),
+                requested_type_name: type_name::<T>(),
+            })
+    }
+
+    pub fn data_mut<T: DynType>(&mut self) -> Result<&mut T, DynTypeError> {
+        let value = self.value_mut().ok_or(DynTypeError::Empty)?;
+        let actual_type_name = Reflect::type_name(value);
+        (value as &mut dyn Any)
+            .downcast_mut()
+            .ok_or_else(|| DynTypeError::TypeCast {
+                actual_type_name,
+                requested_type_name: type_name::<T>(),
+            })
+    }
 }
 
 impl Visit for DynTypeContainer {

fyrox-impl/src/plugin/error.rs

@@ -25,6 +25,7 @@ use crate::{
     core::{pool::PoolError, visitor::error::VisitError},
     scene::graph::GraphError,
 };
+use fyrox_core::dyntype::DynTypeError;
 use std::fmt::{Debug, Display, Formatter};
 
 /// All possible errors that may occur during script or plugin methods execution.
@@ -39,6 +40,8 @@ pub enum GameError {
     VisitError(VisitError),
     /// A [`LoadError`] has occurred.
     ResourceLoadError(LoadError),
+    /// A [`DynTypeError`] has occurred.
+    DynTypeError(DynTypeError),
 }
 
 impl From<GraphError> for GameError {
@@ -71,6 +74,12 @@ impl From<VisitError> for GameError {
     }
 }
 
+impl From<DynTypeError> for GameError {
+    fn from(value: DynTypeError) -> Self {
+        Self::DynTypeError(value)
+    }
+}
+
 impl std::error::Error for GameError {}
 
 impl Display for GameError {
@@ -81,6 +90,7 @@ impl Display for GameError {
             GameError::AnyError(err) => Display::fmt(&err, f),
             GameError::ResourceLoadError(err) => Display::fmt(&err, f),
             GameError::VisitError(err) => Display::fmt(&err, f),
+            GameError::DynTypeError(err) => Display::fmt(&err, f),
         }
     }
 }