Reduce proxies to one struct.

Make proxy methods return opaque RPIT types that are implemented by Proxy.

Author: conqp

src/minecraft.rs

@@ -30,6 +30,7 @@ mod game_mode;
 #[cfg(feature = "minecraft-java-edition")]
 pub mod java_edition;
 mod negate;
+mod proxy;
 mod range;
 mod resource_location;
 mod serialize;

src/minecraft/bedrock_edition.rs

@@ -4,9 +4,11 @@ mod camera;
 
 use std::future::Future;
 
+use camera::Camera;
 pub use camera::Target;
 
 use crate::minecraft::java_edition::TargetSelector;
+use crate::minecraft::proxy::Proxy;
 use crate::minecraft::{parse_response, Entity, Error, Serialize};
 use crate::Minecraft;
 
@@ -19,7 +21,7 @@ pub trait BedrockEdition: Minecraft {
     fn always_day(&mut self, lock: bool) -> impl Future<Output = Result<String, Error>> + Send;
 
     /// Modify the player's camera view.
-    fn camera(&mut self, target: Entity<TargetSelector>) -> camera::Proxy<'_, Self>
+    fn camera(&mut self, target: Entity<TargetSelector>) -> impl Camera<'_>
     where
         Self: Sized + Send;
 }
@@ -42,7 +44,7 @@ where
             .and_then(parse_response)
     }
 
-    fn camera(&mut self, target: Entity<TargetSelector>) -> camera::Proxy<'_, Self> {
-        camera::Proxy::new(self, vec![target.serialize()])
+    fn camera(&mut self, target: Entity<TargetSelector>) -> impl Camera<'_> {
+        Proxy::new(self, vec![target.serialize()])
     }
 }

src/minecraft/bedrock_edition/camera.rs

@@ -1,60 +1,55 @@
 use std::borrow::Cow;
+use std::future::Future;
 
 pub use color::Color;
+use set::Set;
 pub use set::Target;
 pub use time::Time;
 
+use crate::minecraft::proxy::Proxy;
 use crate::minecraft::{Error, Serialize};
 use crate::RCon;
 
 mod color;
 mod set;
 mod time;
 
-/// Camera actions proxy.
-#[derive(Debug)]
-pub struct Proxy<'client, T> {
-    client: &'client mut T,
-    args: Vec<Cow<'client, str>>,
-}
+/// Camera-related operations.
+pub trait Camera<'client> {
+    /// Return a proxy with available set options.
+    fn set(self, preset: Cow<'client, str>) -> impl Set;
 
-impl<'client, T> Proxy<'client, T> {
-    pub(crate) const fn new(client: &'client mut T, args: Vec<Cow<'client, str>>) -> Self {
-        Self { client, args }
-    }
+    /// Clear the camera view.
+    fn clear(&mut self) -> impl Future<Output = Result<String, Error>> + Send;
 
-    /// Return a proxy with available set options.
-    pub fn set(mut self, preset: Cow<'client, str>) -> set::Proxy<'client, T> {
-        self.args.extend([Cow::Borrowed("set"), preset]);
-        set::Proxy::new(self.client, self.args)
-    }
+    /// Fade camera view.
+    fn fade(
+        &mut self,
+        color: Color,
+        time: Option<Time>,
+    ) -> impl Future<Output = Result<String, Error>> + Send;
 }
 
-impl<T> Proxy<'_, T>
+impl<'client, T> Camera<'client> for Proxy<'client, T>
 where
     T: RCon + Send,
 {
-    /// Clear the camera view.
-    pub async fn clear(mut self) -> Result<String, Error> {
-        self.args.push(Cow::Borrowed("clear"));
-        self.client
-            .run_utf8(self.args.join(" "))
-            .await
-            .map_err(Into::into)
+    fn set(self, preset: Cow<'client, str>) -> impl Set {
+        self.delegate(&[Cow::Borrowed("set"), preset])
     }
 
-    /// Fade camera view.
-    pub async fn fade(self, color: Color, time: Option<Time>) -> Result<String, Error> {
+    async fn clear(&mut self) -> Result<String, Error> {
+        self.run_utf8(&["clear".into()]).await
+    }
+
+    async fn fade(&mut self, color: Color, time: Option<Time>) -> Result<String, Error> {
         let mut args = vec![Cow::Borrowed("fade")];
 
         if let Some(time) = time {
             args.push(time.serialize());
         }
 
         args.push(color.serialize());
-        self.client
-            .run_utf8(args.join(" "))
-            .await
-            .map_err(Into::into)
+        self.run_utf8(&args).await
     }
 }

src/minecraft/bedrock_edition/camera/set.rs

@@ -1,57 +1,49 @@
 use std::borrow::Cow;
+use std::future::Future;
 
 pub use target::Target;
 
+use crate::minecraft::proxy::Proxy;
 use crate::minecraft::util::EscapeString;
 use crate::minecraft::{Error, Serialize};
 use crate::RCon;
 
 mod target;
 
-/// Camera actions proxy.
-#[derive(Debug)]
-pub struct Proxy<'client, T> {
-    client: &'client mut T,
-    args: Vec<Cow<'client, str>>,
-}
+/// Set camera settings.
+pub trait Set {
+    /// Set the default value.
+    ///
+    /// TODO: investigate what this actually is. The wiki is quite sparse on this.
+    ///
+    /// See: <https://minecraft.fandom.com/wiki/Commands/camera>
+    fn default(
+        &mut self,
+        default: Option<Cow<'_, str>>,
+    ) -> impl Future<Output = Result<String, Error>>;
 
-impl<'client, T> Proxy<'client, T> {
-    pub(crate) const fn new(client: &'client mut T, args: Vec<Cow<'client, str>>) -> Self {
-        Self { client, args }
-    }
+    /// Set camera facing.
+    fn facing(&mut self, target: Target) -> impl Future<Output = Result<String, Error>>;
+
+    // TODO: Implement further sub-commands.
 }
 
-impl<T> Proxy<'_, T>
+impl<T> Set for Proxy<'_, T>
 where
     T: RCon + Send,
 {
-    /// Set the default value.
-    ///
-    /// TODO: investigate what this actually is. The wiki is quite sparse on this.
-    ///
-    /// See: <https://minecraft.fandom.com/wiki/Commands/camera>
-    pub async fn default(mut self, default: Option<Cow<'_, str>>) -> Result<String, Error> {
-        self.args.push(Cow::Borrowed("default"));
+    async fn default(&mut self, default: Option<Cow<'_, str>>) -> Result<String, Error> {
+        let mut args = vec![Cow::Borrowed("default")];
 
         if let Some(default) = default {
-            self.args.push(default.quote().into());
+            args.push(default.quote().into());
         }
 
-        self.client
-            .run_utf8(self.args.join(" "))
-            .await
-            .map_err(Into::into)
+        self.run_utf8(&args).await
     }
 
-    /// Set camera facing.
-    pub async fn facing(mut self, target: Target) -> Result<String, Error> {
-        self.args
-            .extend([Cow::Borrowed("facing"), target.serialize()]);
-        self.client
-            .run_utf8(self.args.join(" "))
+    async fn facing(&mut self, target: Target) -> Result<String, Error> {
+        self.run_utf8(&[Cow::Borrowed("facing"), target.serialize()])
             .await
-            .map_err(Into::into)
     }
-
-    // TODO: Implement further sub-commands.
 }

src/minecraft/java_edition.rs

@@ -3,9 +3,13 @@
 use std::borrow::Cow;
 use std::future::Future;
 
+use advancement::Advancement;
 pub use advancement::Grant;
+use attribute::Attribute;
+use bossbar::Bossbar;
 pub use target_selector::{Argument, Sort, TargetSelector};
 
+use crate::minecraft::proxy::Proxy;
 use crate::minecraft::{Entity, ResourceLocation, Serialize};
 use crate::Minecraft;
 
@@ -23,38 +27,21 @@ pub trait JavaEdition: Minecraft {
     ///
     /// # Returns
     ///
-    /// Returns an [`advancement::Proxy`] which can be used to execute
+    /// Returns an [`Proxy`] which can be used to execute
     /// advancement-related commands pertaining to the `target`.
-    fn advancement(&mut self, target: Entity<TargetSelector>) -> advancement::Proxy<'_, Self>
-    where
-        Self: Sized,
-    {
-        advancement::Proxy::new(self, vec!["advancement".into(), target.serialize()])
-    }
+    fn advancement(&mut self, target: Entity<TargetSelector>) -> impl Advancement;
 
     /// Manage a target's attribute.
     ///
     /// # Returns
     ///
-    /// Returns an [`attribute::Proxy`] which can be used to execute
+    /// Returns an [`Proxy`] which can be used to execute
     /// advancement-related commands pertaining to the `target`.
     fn attribute(
         &mut self,
         target: Entity<TargetSelector>,
         attribute: ResourceLocation,
-    ) -> attribute::Proxy<'_, Self>
-    where
-        Self: Sized,
-    {
-        attribute::Proxy::new(
-            self,
-            vec![
-                "attribute".into(),
-                target.serialize(),
-                attribute.serialize(),
-            ],
-        )
-    }
+    ) -> impl Attribute;
 
     /// Adds player to banlist.
     ///
@@ -93,24 +80,38 @@ pub trait JavaEdition: Minecraft {
         entry_type: Option<banlist::EntryType>,
     ) -> impl Future<Output = Result<Vec<banlist::Entry>, banlist::Error>> + Send;
 
-    /// Creates, modifies and lists bossbars.
-    fn bossbar(&mut self) -> bossbar::Proxy<'_, Self>
-    where
-        Self: Sized,
-    {
-        bossbar::Proxy::new(self, vec!["bossbar".into()])
-    }
+    /// Manage bossbars.
+    ///
+    /// # Returns
+    ///
+    /// Returns an [`Proxy`] which can be used to execute
+    /// bossbar-related commands.
+    fn bossbar(&mut self) -> impl Bossbar;
 }
 
 impl<T> JavaEdition for T
 where
     T: Minecraft + Send,
 {
-    /// Adds player to banlist.
-    ///
-    /// # Errors
-    ///
-    /// Returns an [`ban::Error`] on errors.
+    fn advancement(&mut self, target: Entity<TargetSelector>) -> impl Advancement {
+        Proxy::new(self, vec!["advancement".into(), target.serialize()])
+    }
+
+    fn attribute(
+        &mut self,
+        target: Entity<TargetSelector>,
+        attribute: ResourceLocation,
+    ) -> impl Attribute {
+        Proxy::new(
+            self,
+            vec![
+                "attribute".into(),
+                target.serialize(),
+                attribute.serialize(),
+            ],
+        )
+    }
+
     async fn ban(
         &mut self,
         target: Entity<TargetSelector>,
@@ -125,14 +126,6 @@ where
         ban::parse_response(&self.run_utf8(args.join(" ")).await?)
     }
 
-    /// Adds IP address to banlist.
-    ///
-    /// Specifies the IP address to be added to the blacklist.
-    /// Can also be a name of an online player, which represents the IP of that player.
-    ///
-    /// # Errors
-    ///
-    /// Returns an [`ban_ip::Error`] on errors.
     async fn ban_ip<S>(
         &mut self,
         target: ban_ip::Target,
@@ -150,11 +143,6 @@ where
         ban_ip::parse_response(&self.run_utf8(args.join(" ")).await?)
     }
 
-    /// Return the entries from the ban list.
-    ///
-    /// # Errors
-    ///
-    /// Returns an [`banlist::Error`] on errors.
     async fn banlist(
         &mut self,
         entry_type: Option<banlist::EntryType>,
@@ -167,4 +155,8 @@ where
 
         banlist::parse_response(&self.run_utf8(args.join(" ")).await?)
     }
+
+    fn bossbar(&mut self) -> impl Bossbar {
+        Proxy::new(self, vec!["bossbar".into()])
+    }
 }