first pass at command error handling

Author: NathanSWard

crates/bevy_ecs/src/system/commands/config.rs

@@ -0,0 +1,147 @@
+use crate::world::World;
+use std::{
+    fmt::Debug,
+    ops::{Deref, DerefMut},
+};
+
+use super::{fallible::*, Command};
+
+pub trait AddCommand {
+    fn add_command(&mut self, command: impl Command);
+}
+
+pub struct FallibleCommandConfig<'a, C, T>
+where
+    C: FallibleCommand,
+    C::Error: Debug,
+    T: AddCommand,
+{
+    command: Option<C>,
+    inner: &'a mut T,
+}
+
+impl<'a, C, T> Deref for FallibleCommandConfig<'a, C, T>
+where
+    C: FallibleCommand,
+    C::Error: Debug,
+    T: AddCommand,
+{
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.inner
+    }
+}
+
+impl<'a, C, T> DerefMut for FallibleCommandConfig<'a, C, T>
+where
+    C: FallibleCommand,
+    C::Error: Debug,
+    T: AddCommand,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner
+    }
+}
+
+/// Similar to [`FallibleCommandConfig`] however does not
+/// implement [`DerefMut`] nor return `&mut T` of the underlying
+/// Commands type.
+pub struct FinalFallibleCommandConfig<'a, C, T>
+where
+    C: FallibleCommand,
+    C::Error: Debug,
+    T: AddCommand,
+{
+    command: Option<C>,
+    inner: &'a mut T,
+}
+
+macro_rules! impl_fallible_commands {
+    ($name:ident, $returnty:ty, $func:ident) => {
+        impl<'a, C, T> $name<'a, C, T>
+        where
+            C: FallibleCommand,
+            C::Error: Debug,
+            T: AddCommand,
+        {
+            #[inline]
+            pub(crate) fn new(command: C, inner: &'a mut T) -> Self {
+                Self {
+                    command: Some(command),
+                    inner,
+                }
+            }
+
+            #[inline]
+            #[allow(dead_code)]
+            fn return_inner(&mut self) -> &mut T {
+                self.inner
+            }
+
+            #[inline]
+            #[allow(dead_code)]
+            fn return_unit(&mut self) {}
+        }
+
+        impl<'a, C, T> $name<'a, C, T>
+        where
+            C: FallibleCommand,
+            C::Error: Debug,
+            T: AddCommand,
+        {
+            pub fn on_failure<'this, H>(&'this mut self, error_handler: H) -> $returnty
+            where
+                H: FnOnce(C::Error, &mut World) + Send + Sync + 'static,
+            {
+                let command = self.command.take().unwrap();
+                self.inner.add_command(FallibleCommandWrapper {
+                    command,
+                    error_handler,
+                });
+                self.$func()
+            }
+
+            pub fn ignore<'this>(&'this mut self) -> $returnty {
+                let command = self.command.take().unwrap();
+                self.inner
+                    .add_command(IgnoreFallibleCommandWrapper(command));
+                self.$func()
+            }
+
+            // this is the default
+            pub fn log_on_failure<'this>(&'this mut self) -> $returnty {
+                let command = self.command.take().unwrap();
+                self.inner
+                    .add_command(LoggingFallibleCommandWrapper(command));
+                self.$func()
+            }
+
+            pub fn panic_on_failure<'this>(&'this mut self) -> $returnty {
+                let command = self.command.take().unwrap();
+                self.inner
+                    .add_command(PanickingFallibleCommandWrapper(command));
+                self.$func()
+            }
+        }
+
+        impl<'a, C, T> Drop for $name<'a, C, T>
+        where
+            C: FallibleCommand,
+            C::Error: Debug,
+            T: AddCommand,
+        {
+            fn drop(&mut self) {
+                if let Some(command) = self.command.take() {
+                    self.inner
+                        .add_command(LoggingFallibleCommandWrapper(command));
+                }
+            }
+        }
+    };
+}
+
+impl_fallible_commands!(FinalFallibleCommandConfig, (), return_unit);
+impl_fallible_commands!(FallibleCommandConfig, &mut T, return_inner);

crates/bevy_ecs/src/system/commands/fallible.rs

@@ -0,0 +1,95 @@
+use super::Command;
+use crate::world::World;
+use bevy_utils::tracing::error;
+use std::fmt::Debug;
+
+pub trait FallibleCommand: Send + Sync + 'static {
+    type Error;
+
+    fn try_write(self, world: &mut World) -> Result<(), Self::Error>;
+}
+
+pub trait InfallibleCommand: Send + Sync + 'static {
+    fn write(self, world: &mut World);
+}
+
+pub(crate) struct IgnoreFallibleCommandWrapper<C: FallibleCommand>(pub(crate) C);
+
+impl<C> Command for IgnoreFallibleCommandWrapper<C>
+where
+    C: FallibleCommand,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        let _ = self.0.try_write(world);
+    }
+}
+
+pub(crate) struct LoggingFallibleCommandWrapper<C: FallibleCommand>(pub(crate) C);
+
+impl<C> Command for LoggingFallibleCommandWrapper<C>
+where
+    C: FallibleCommand,
+    C::Error: Debug,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        if let Err(err) = self.0.try_write(world) {
+            error!("Commands failed with error: {:?}", err);
+        }
+    }
+}
+
+pub(crate) struct PanickingFallibleCommandWrapper<C: FallibleCommand>(pub(crate) C);
+
+impl<C> Command for PanickingFallibleCommandWrapper<C>
+where
+    C: FallibleCommand,
+    C::Error: Debug,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        if let Err(err) = self.0.try_write(world) {
+            panic!("Commands failed with error: {:?}", err);
+        }
+    }
+}
+
+pub(crate) struct FallibleCommandWrapper<C, E>
+where
+    C: FallibleCommand,
+    E: FnOnce(C::Error, &mut World) + Send + Sync + 'static,
+{
+    pub(crate) command: C,
+    pub(crate) error_handler: E,
+}
+
+impl<C, E> Command for FallibleCommandWrapper<C, E>
+where
+    C: FallibleCommand,
+    E: FnOnce(C::Error, &mut World) + Send + Sync + 'static,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        let FallibleCommandWrapper {
+            command,
+            error_handler,
+        } = *self;
+
+        if let Err(e) = command.try_write(world) {
+            (error_handler)(e, world);
+        }
+    }
+}
+
+pub(crate) struct InfallibleCommandWrapper<C>
+where
+    C: InfallibleCommand,
+{
+    pub(crate) command: C,
+}
+
+impl<C> Command for InfallibleCommandWrapper<C>
+where
+    C: InfallibleCommand,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        self.command.write(world);
+    }
+}