From 8af69be47e88896b3c5f70174db609eee0c67971 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Sun, 5 Mar 2023 06:23:40 +0100
Subject: Converge `Command` types from `iced_futures` and `iced_native`

---
 native/src/command.rs | 59 ++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 40 insertions(+), 19 deletions(-)

(limited to 'native/src/command.rs')

diff --git a/native/src/command.rs b/native/src/command.rs
index 39bee8f6..cd4c51ff 100644
--- a/native/src/command.rs
+++ b/native/src/command.rs
@@ -3,37 +3,39 @@ mod action;
 
 pub use action::Action;
 
-use crate::widget;
-
-use iced_futures::MaybeSend;
+use crate::core::widget;
+use crate::futures::MaybeSend;
 
 use std::fmt;
 use std::future::Future;
 
 /// A set of asynchronous actions to be performed by some runtime.
 #[must_use = "`Command` must be returned to runtime to take effect"]
-pub struct Command<T>(iced_futures::Command<Action<T>>);
+pub struct Command<T>(Internal<Action<T>>);
+
+#[derive(Debug)]
+enum Internal<T> {
+    None,
+    Single(T),
+    Batch(Vec<T>),
+}
 
 impl<T> Command<T> {
     /// Creates an empty [`Command`].
     ///
     /// In other words, a [`Command`] that does nothing.
     pub const fn none() -> Self {
-        Self(iced_futures::Command::none())
+        Self(Internal::None)
     }
 
     /// Creates a [`Command`] that performs a single [`Action`].
     pub const fn single(action: Action<T>) -> Self {
-        Self(iced_futures::Command::single(action))
+        Self(Internal::Single(action))
     }
 
     /// Creates a [`Command`] that performs a [`widget::Operation`].
-    pub fn widget(
-        operation: impl iced_core::widget::Operation<T> + 'static,
-    ) -> Self {
-        Self(iced_futures::Command::single(Action::Widget(
-            widget::Action::new(operation),
-        )))
+    pub fn widget(operation: impl widget::Operation<T> + 'static) -> Self {
+        Self::single(Action::Widget(Box::new(operation)))
     }
 
     /// Creates a [`Command`] that performs the action of the given future.
@@ -51,9 +53,17 @@ impl<T> Command<T> {
     ///
     /// Once this command is run, all the commands will be executed at once.
     pub fn batch(commands: impl IntoIterator<Item = Command<T>>) -> Self {
-        Self(iced_futures::Command::batch(
-            commands.into_iter().map(|Command(command)| command),
-        ))
+        let mut batch = Vec::new();
+
+        for Command(command) in commands {
+            match command {
+                Internal::None => {}
+                Internal::Single(command) => batch.push(command),
+                Internal::Batch(commands) => batch.extend(commands),
+            }
+        }
+
+        Self(Internal::Batch(batch))
     }
 
     /// Applies a transformation to the result of a [`Command`].
@@ -65,16 +75,27 @@ impl<T> Command<T> {
         T: 'static,
         A: 'static,
     {
-        let Command(command) = self;
-
-        Command(command.map(move |action| action.map(f.clone())))
+        match self.0 {
+            Internal::None => Command::none(),
+            Internal::Single(action) => Command::single(action.map(f)),
+            Internal::Batch(batch) => Command(Internal::Batch(
+                batch
+                    .into_iter()
+                    .map(|action| action.map(f.clone()))
+                    .collect(),
+            )),
+        }
     }
 
     /// Returns all of the actions of the [`Command`].
     pub fn actions(self) -> Vec<Action<T>> {
         let Command(command) = self;
 
-        command.actions()
+        match command {
+            Internal::None => Vec::new(),
+            Internal::Single(action) => vec![action],
+            Internal::Batch(batch) => batch,
+        }
     }
 }
 
-- 
cgit