progress

1 files changed, 24 insertions, 26 deletions

diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
index 19706a22..bd2a2c15 100644
--- a/azalea-brigadier/src/builder/argument_builder.rs
+++ b/azalea-brigadier/src/builder/argument_builder.rs
@@ -5,27 +5,25 @@ use crate::{
     tree::{command_node::CommandNode, root_command_node::RootCommandNode},
 };
 
-pub struct BaseArgumentBuilder<S, T>
+pub struct BaseArgumentBuilder<'a, S, T>
 where
-    T: ArgumentBuilder<S, T>,
+    S: Sized,
+    T: Sized,
 {
-    arguments: RootCommandNode<S>,
-    command: Option<dyn Command<S>>,
-    requirement: dyn Fn(&S) -> bool,
-    target: Option<dyn CommandNode<S>>,
-    modifier: Option<dyn RedirectModifier<S>>,
+    arguments: RootCommandNode<'a, S, T>,
+    command: Option<&'a dyn Command<S, T>>,
+    requirement: &'a dyn Fn(&S) -> bool,
+    target: Option<&'a dyn CommandNode<S, T>>,
+    modifier: Option<&'a dyn RedirectModifier<S, T>>,
     forks: bool,
 }
 
 pub trait ArgumentBuilder<S, T> {
-    fn build(self) -> dyn CommandNode<S>;
+    fn build(self) -> dyn CommandNode<S, T>;
 }
 
-impl<S, T> BaseArgumentBuilder<S, T>
-where
-    T: ArgumentBuilder<S, T>,
-{
-    pub fn then(&mut self, command: dyn CommandNode<S>) -> Result<&mut T, String> {
+impl<S, T> BaseArgumentBuilder<'_, S, T> {
+    pub fn then(&mut self, command: dyn CommandNode<S, T>) -> Result<&mut T, String> {
         if self.target.is_some() {
             return Err("Cannot add children to a redirected node".to_string());
         }
@@ -33,20 +31,20 @@ where
         Ok(self)
     }
 
-    pub fn arguments(&self) -> &Vec<dyn CommandNode<S>> {
+    pub fn arguments(&self) -> &Vec<&dyn CommandNode<S, T>> {
         &self.arguments.get_children()
     }
 
-    pub fn executes(&mut self, command: dyn Command<S>) -> &mut T {
+    pub fn executes(&mut self, command: dyn Command<S, T>) -> &mut T {
         self.command = command;
         self
     }
 
-    pub fn command(&self) -> dyn Command<S> {
+    pub fn command(&self) -> dyn Command<S, T> {
         self.command
     }
 
-    pub fn requires(&mut self, requirement: dyn Fn(&S) -> bool) -> &mut T {
+    pub fn requires(&mut self, requirement: &dyn Fn(&S) -> bool) -> &mut T {
         self.requirement = requirement;
         self
     }
@@ -55,14 +53,14 @@ where
         self.requirement
     }
 
-    pub fn redirect(&mut self, target: dyn CommandNode<S>) -> &mut T {
+    pub fn redirect(&mut self, target: &dyn CommandNode<S, T>) -> &mut T {
         self.forward(target, None, false)
     }
 
     pub fn redirect_modifier(
         &mut self,
-        target: dyn CommandNode<S>,
-        modifier: dyn SingleRedirectModifier<S>,
+        target: &dyn CommandNode<S, T>,
+        modifier: &dyn SingleRedirectModifier<S, T>,
     ) -> &mut T {
         // forward(target, modifier == null ? null : o -> Collections.singleton(modifier.apply(o)), false);
         self.forward(target, modifier.map(|m| |o| vec![m.apply(o)]), false)
@@ -70,16 +68,16 @@ where
 
     pub fn fork(
         &mut self,
-        target: dyn CommandNode<S>,
-        modifier: dyn RedirectModifier<S>,
+        target: &dyn CommandNode<S, T>,
+        modifier: &dyn RedirectModifier<S, T>,
     ) -> &mut T {
         self.forward(target, Some(modifier), true)
     }
 
     pub fn forward(
         &mut self,
-        target: dyn CommandNode<S>,
-        modifier: Option<dyn RedirectModifier<S>>,
+        target: &dyn CommandNode<S, T>,
+        modifier: Option<&dyn RedirectModifier<S, T>>,
         fork: bool,
     ) -> Result<&mut T, String> {
         if !self.arguments.get_children().is_empty() {
@@ -91,11 +89,11 @@ where
         Ok(self)
     }
 
-    pub fn get_redirect(&self) -> Option<&dyn CommandNode<S>> {
+    pub fn get_redirect(&self) -> Option<&dyn CommandNode<S, T>> {
         self.target.as_ref()
     }
 
-    pub fn get_redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
+    pub fn get_redirect_modifier(&self) -> Option<&dyn RedirectModifier<S, T>> {
         self.modifier.as_ref()
     }