From 6980fbf2f9fb4c599d8dc6ff549a8b3288eb24e9 Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Mon, 17 Aug 2026 02:29:30 +0800 Subject: refactor!: remove dynamic dispatcher registration API Dispatchers are now always registered at compile time, removing the `with_dispatcher` / `with_dispatchers` methods and the `PathfinderConfig` API. The `dispatch_tree` feature now only controls the matching strategy (trie vs linear list). --- mingling_core/src/asset/dispatcher.rs | 415 +--------------------------------- 1 file changed, 1 insertion(+), 414 deletions(-) (limited to 'mingling_core/src/asset') diff --git a/mingling_core/src/asset/dispatcher.rs b/mingling_core/src/asset/dispatcher.rs index d700405..1ab7bf6 100644 --- a/mingling_core/src/asset/dispatcher.rs +++ b/mingling_core/src/asset/dispatcher.rs @@ -1,6 +1,6 @@ use std::fmt::Display; -use crate::{ChainProcess, Program, ProgramCollect, asset::node::Node}; +use crate::{ChainProcess, asset::node::Node}; /// The entry logic of the Mingling program /// @@ -148,307 +148,6 @@ where } } -impl Program -where - C: ProgramCollect, -{ - /// Add a Dispatcher to the program - /// - /// This dynamically registers a Dispatcher into the program, used for command matching at program startup - /// - /// ``` - /// # use mingling_core::Program; - /// # use mingling_core::ChainProcess; - /// # use mingling_core::Dispatcher; - /// # use mingling_core::Grouped; - /// # use mingling_core::Routable; - /// # use mingling_core::Node; - /// # use mingling_core::MockProgramCollect as ThisProgram; - /// # unsafe impl Grouped for Foo { - /// # fn member_id() -> ThisProgram { ThisProgram::Foo } - /// # } - /// # struct CMDGreet; - /// # struct Foo { - /// # args: Vec - /// # } - /// # impl Dispatcher for CMDGreet { - /// # fn node(&self) -> Node { - /// # Node::default().join("greet") - /// # } - /// # fn begin(&self, args: Vec) -> ChainProcess { - /// # Routable::to_chain(Foo { args }) - /// # } - /// # fn clone_dispatcher(&self) -> Box> { - /// # Box::new(CMDGreet) - /// # } - /// # } - /// let mut program = Program::::new(); - /// program.with_dispatcher(CMDGreet); - /// ``` - #[cfg_attr( - feature = "dispatch_tree", - deprecated( - note = "When the `dispatch_tree` feature is enabled, the `dispatcher` field no longer exists inside Program. All types are collected at compile time by the `gen_program!()` macro, so the `with_dispatcher` function is no longer needed" - ) - )] - pub fn with_dispatcher(&mut self, dispatcher: Disp) -> &mut Self - where - Disp: Dispatcher + Send + Sync + 'static, - { - #[cfg(not(feature = "dispatch_tree"))] - { - self.dispatcher.push(Box::new(dispatcher)); - } - #[cfg(feature = "dispatch_tree")] - { - let _ = dispatcher; - } - self - } - - /// Add a group of Dispatchers to the program - /// - /// This dynamically registers a group of Dispatchers into the program, used for command matching at program startup - /// - /// ``` - /// # use mingling_core::Program; - /// # use mingling_core::ChainProcess; - /// # use mingling_core::Dispatcher; - /// # use mingling_core::Grouped; - /// # use mingling_core::Routable; - /// # use mingling_core::Node; - /// # use mingling_core::MockProgramCollect as ThisProgram; - /// # unsafe impl Grouped for Foo { - /// # fn member_id() -> ThisProgram { ThisProgram::Foo } - /// # } - /// # struct CMDGreet; - /// # struct Foo { - /// # args: Vec - /// # } - /// # impl Dispatcher for CMDGreet { - /// # fn node(&self) -> Node { - /// # Node::default().join("greet") - /// # } - /// # fn begin(&self, args: Vec) -> ChainProcess { - /// # Routable::to_chain(Foo { args }) - /// # } - /// # fn clone_dispatcher(&self) -> Box> { - /// # Box::new(CMDGreet) - /// # } - /// # } - /// let mut program = Program::::new(); - /// program.with_dispatchers((CMDGreet, /* Other Dispatchers */)); - /// ``` - #[deprecated( - note = "with_dispatchers is no longer the recommended way to register Dispatchers, please split into multiple with_dispatcher calls" - )] - #[allow(deprecated)] - pub fn with_dispatchers(&mut self, dispatchers: D) -> &mut Self - where - D: Into>, - { - #[cfg(not(feature = "dispatch_tree"))] - { - let dispatchers = dispatchers.into(); - self.dispatcher.extend(dispatchers.dispatcher); - } - #[cfg(feature = "dispatch_tree")] - { - let _ = dispatchers; - } - self - } -} - -/// Represents a group of Dispatchers -/// -/// It records a group of Dispatchers and implements conversion from tuples `(Disp, ..)` for this type, -/// allowing for simpler construction syntax when using `with_dispatchers` -/// -/// # Limits -/// -/// Dispatchers supports conversion from tuples of up to 7 Dispatchers -#[deprecated( - note = "with_dispatchers is no longer the recommended way to register Dispatchers, please split into multiple with_dispatcher calls" -)] -pub struct Dispatchers { - dispatcher: Vec + Send + Sync + 'static>>, -} - -#[allow(deprecated)] -impl From + Send + Sync>>> for Dispatchers { - fn from(dispatcher: Vec + Send + Sync>>) -> Self { - Self { dispatcher } - } -} - -#[allow(deprecated)] -impl From + Send + Sync>> for Dispatchers { - fn from(dispatcher: Box + Send + Sync>) -> Self { - Self { - dispatcher: vec![dispatcher], - } - } -} - -#[allow(deprecated)] -impl From<(D,)> for Dispatchers -where - D: Dispatcher + Send + Sync + 'static, - G: Display, -{ - fn from(dispatcher: (D,)) -> Self { - Self { - dispatcher: vec![Box::new(dispatcher.0)], - } - } -} - -#[allow(deprecated)] -impl From<(D1, D2)> for Dispatchers -where - D1: Dispatcher + Send + Sync + 'static, - D2: Dispatcher + Send + Sync + 'static, - G: Display, -{ - fn from(dispatchers: (D1, D2)) -> Self { - Self { - dispatcher: vec![Box::new(dispatchers.0), Box::new(dispatchers.1)], - } - } -} - -#[allow(deprecated)] -impl From<(D1, D2, D3)> for Dispatchers -where - D1: Dispatcher + Send + Sync + 'static, - D2: Dispatcher + Send + Sync + 'static, - D3: Dispatcher + Send + Sync + 'static, - G: Display, -{ - fn from(dispatchers: (D1, D2, D3)) -> Self { - Self { - dispatcher: vec![ - Box::new(dispatchers.0), - Box::new(dispatchers.1), - Box::new(dispatchers.2), - ], - } - } -} - -#[allow(deprecated)] -impl From<(D1, D2, D3, D4)> for Dispatchers -where - D1: Dispatcher + Send + Sync + 'static, - D2: Dispatcher + Send + Sync + 'static, - D3: Dispatcher + Send + Sync + 'static, - D4: Dispatcher + Send + Sync + 'static, - G: Display, -{ - fn from(dispatchers: (D1, D2, D3, D4)) -> Self { - Self { - dispatcher: vec![ - Box::new(dispatchers.0), - Box::new(dispatchers.1), - Box::new(dispatchers.2), - Box::new(dispatchers.3), - ], - } - } -} - -#[allow(deprecated)] -impl From<(D1, D2, D3, D4, D5)> for Dispatchers -where - D1: Dispatcher + Send + Sync + 'static, - D2: Dispatcher + Send + Sync + 'static, - D3: Dispatcher + Send + Sync + 'static, - D4: Dispatcher + Send + Sync + 'static, - D5: Dispatcher + Send + Sync + 'static, - G: Display, -{ - fn from(dispatchers: (D1, D2, D3, D4, D5)) -> Self { - Self { - dispatcher: vec![ - Box::new(dispatchers.0), - Box::new(dispatchers.1), - Box::new(dispatchers.2), - Box::new(dispatchers.3), - Box::new(dispatchers.4), - ], - } - } -} - -#[allow(deprecated)] -impl From<(D1, D2, D3, D4, D5, D6)> for Dispatchers -where - D1: Dispatcher + Send + Sync + 'static, - D2: Dispatcher + Send + Sync + 'static, - D3: Dispatcher + Send + Sync + 'static, - D4: Dispatcher + Send + Sync + 'static, - D5: Dispatcher + Send + Sync + 'static, - D6: Dispatcher + Send + Sync + 'static, - G: Display, -{ - fn from(dispatchers: (D1, D2, D3, D4, D5, D6)) -> Self { - Self { - dispatcher: vec![ - Box::new(dispatchers.0), - Box::new(dispatchers.1), - Box::new(dispatchers.2), - Box::new(dispatchers.3), - Box::new(dispatchers.4), - Box::new(dispatchers.5), - ], - } - } -} - -#[allow(deprecated)] -impl From<(D1, D2, D3, D4, D5, D6, D7)> for Dispatchers -where - D1: Dispatcher + Send + Sync + 'static, - D2: Dispatcher + Send + Sync + 'static, - D3: Dispatcher + Send + Sync + 'static, - D4: Dispatcher + Send + Sync + 'static, - D5: Dispatcher + Send + Sync + 'static, - D6: Dispatcher + Send + Sync + 'static, - D7: Dispatcher + Send + Sync + 'static, - G: Display, -{ - fn from(dispatchers: (D1, D2, D3, D4, D5, D6, D7)) -> Self { - Self { - dispatcher: vec![ - Box::new(dispatchers.0), - Box::new(dispatchers.1), - Box::new(dispatchers.2), - Box::new(dispatchers.3), - Box::new(dispatchers.4), - Box::new(dispatchers.5), - Box::new(dispatchers.6), - ], - } - } -} - -#[allow(deprecated)] -impl std::ops::Deref for Dispatchers { - type Target = Vec + Send + Sync + 'static>>; - - fn deref(&self) -> &Self::Target { - &self.dispatcher - } -} - -#[allow(deprecated)] -impl From> for Vec + Send + Sync + 'static>> { - fn from(val: Dispatchers) -> Self { - val.dispatcher - } -} - #[cfg(test)] mod tests { use super::*; @@ -484,118 +183,6 @@ mod tests { } } - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_single_tuple() { - let disp = MockDispatcher { name: "foo" }; - let dispatchers: Dispatchers = Dispatchers::from((disp,)); - assert_eq!(dispatchers.dispatcher.len(), 1); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_two_tuple() { - let d1 = MockDispatcher { name: "a" }; - let d2 = MockDispatcher { name: "b" }; - let dispatchers: Dispatchers = Dispatchers::from((d1, d2)); - assert_eq!(dispatchers.dispatcher.len(), 2); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_three_tuple() { - let d1 = MockDispatcher { name: "x" }; - let d2 = MockDispatcher { name: "y" }; - let d3 = MockDispatcher { name: "z" }; - let dispatchers: Dispatchers = Dispatchers::from((d1, d2, d3)); - assert_eq!(dispatchers.dispatcher.len(), 3); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_four_tuple() { - let d1 = MockDispatcher { name: "1" }; - let d2 = MockDispatcher { name: "2" }; - let d3 = MockDispatcher { name: "3" }; - let d4 = MockDispatcher { name: "4" }; - let dispatchers: Dispatchers = Dispatchers::from((d1, d2, d3, d4)); - assert_eq!(dispatchers.dispatcher.len(), 4); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_five_tuple() { - let d1 = MockDispatcher { name: "a" }; - let d2 = MockDispatcher { name: "b" }; - let d3 = MockDispatcher { name: "c" }; - let d4 = MockDispatcher { name: "d" }; - let d5 = MockDispatcher { name: "e" }; - let dispatchers: Dispatchers = Dispatchers::from((d1, d2, d3, d4, d5)); - assert_eq!(dispatchers.dispatcher.len(), 5); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_six_tuple() { - let d1 = MockDispatcher { name: "a" }; - let d2 = MockDispatcher { name: "b" }; - let d3 = MockDispatcher { name: "c" }; - let d4 = MockDispatcher { name: "d" }; - let d5 = MockDispatcher { name: "e" }; - let d6 = MockDispatcher { name: "f" }; - let dispatchers: Dispatchers = Dispatchers::from((d1, d2, d3, d4, d5, d6)); - assert_eq!(dispatchers.dispatcher.len(), 6); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_seven_tuple() { - let d1 = MockDispatcher { name: "a" }; - let d2 = MockDispatcher { name: "b" }; - let d3 = MockDispatcher { name: "c" }; - let d4 = MockDispatcher { name: "d" }; - let d5 = MockDispatcher { name: "e" }; - let d6 = MockDispatcher { name: "f" }; - let d7 = MockDispatcher { name: "g" }; - let dispatchers: Dispatchers = Dispatchers::from((d1, d2, d3, d4, d5, d6, d7)); - assert_eq!(dispatchers.dispatcher.len(), 7); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_vec_of_boxed() { - let d1: Box + Send + Sync> = Box::new(MockDispatcher { name: "a" }); - let d2: Box + Send + Sync> = Box::new(MockDispatcher { name: "b" }); - let dispatchers: Dispatchers = vec![d1, d2].into(); - assert_eq!(dispatchers.dispatcher.len(), 2); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_from_single_boxed() { - let d: Box + Send + Sync> = Box::new(MockDispatcher { name: "x" }); - let dispatchers: Dispatchers = d.into(); - assert_eq!(dispatchers.dispatcher.len(), 1); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_deref() { - let disp = MockDispatcher { name: "test" }; - let dispatchers: Dispatchers = Dispatchers::from((disp,)); - let inner: &Vec + Send + Sync + 'static>> = &dispatchers; - assert_eq!(inner.len(), 1); - } - - #[test] - #[allow(deprecated)] - fn test_dispatchers_into_vec() { - let disp = MockDispatcher { name: "foo" }; - let dispatchers: Dispatchers = Dispatchers::from((disp,)); - let vec: Vec + Send + Sync + 'static>> = dispatchers.into(); - assert_eq!(vec.len(), 1); - } - #[test] fn test_box_clone_dispatcher() { let disp: Box> = Box::new(MockDispatcher { name: "clonable" }); -- cgit