From 2a44ec3ffdcd78b23ac31b722b4312774d643c3a Mon Sep 17 00:00:00 2001 From: HampusM Date: Sat, 24 Sep 2022 16:14:45 +0200 Subject: refactor!: remove repetition of declaring factory interfaces BREAKING CHANGE: The to_default_factory method of the blocking and async DI containers now expect a function returning another function --- macros/src/factory/build_declare_interfaces.rs | 52 ++++++++++++++ macros/src/factory/mod.rs | 1 + macros/src/lib.rs | 99 +++++--------------------- 3 files changed, 70 insertions(+), 82 deletions(-) create mode 100644 macros/src/factory/build_declare_interfaces.rs (limited to 'macros') diff --git a/macros/src/factory/build_declare_interfaces.rs b/macros/src/factory/build_declare_interfaces.rs new file mode 100644 index 0000000..ac4ddd6 --- /dev/null +++ b/macros/src/factory/build_declare_interfaces.rs @@ -0,0 +1,52 @@ +use proc_macro2::TokenStream; +use quote::quote; + +use crate::fn_trait::FnTrait; + +pub fn build_declare_factory_interfaces( + factory_interface: &FnTrait, + is_threadsafe: bool, +) -> TokenStream +{ + if is_threadsafe { + quote! { + syrette::declare_interface!( + syrette::castable_factory::threadsafe::ThreadsafeCastableFactory< + (std::sync::Arc,), + #factory_interface + > -> syrette::interfaces::factory::IFactory< + (std::sync::Arc,), + #factory_interface + >, + async = true + ); + + syrette::declare_interface!( + syrette::castable_factory::threadsafe::ThreadsafeCastableFactory< + (std::sync::Arc,), + #factory_interface + > -> syrette::interfaces::any_factory::AnyThreadsafeFactory, + async = true + ); + } + } else { + quote! { + syrette::declare_interface!( + syrette::castable_factory::blocking::CastableFactory< + (std::rc::Rc,), + #factory_interface + > -> syrette::interfaces::factory::IFactory< + (std::rc::Rc,), + #factory_interface + > + ); + + syrette::declare_interface!( + syrette::castable_factory::blocking::CastableFactory< + (std::rc::Rc,), + #factory_interface + > -> syrette::interfaces::any_factory::AnyFactory + ); + } + } +} diff --git a/macros/src/factory/mod.rs b/macros/src/factory/mod.rs index a8947c5..18bad8f 100644 --- a/macros/src/factory/mod.rs +++ b/macros/src/factory/mod.rs @@ -1,3 +1,4 @@ +pub mod build_declare_interfaces; pub mod declare_default_args; pub mod macro_args; pub mod type_alias; diff --git a/macros/src/lib.rs b/macros/src/lib.rs index 390d239..07ee7a5 100644 --- a/macros/src/lib.rs +++ b/macros/src/lib.rs @@ -190,6 +190,7 @@ pub fn factory(args_stream: TokenStream, type_alias_stream: TokenStream) -> Toke use quote::ToTokens; use syn::Type; + use crate::factory::build_declare_interfaces::build_declare_factory_interfaces; use crate::factory::macro_args::FactoryMacroArgs; use crate::factory::type_alias::FactoryTypeAlias; @@ -239,47 +240,8 @@ pub fn factory(args_stream: TokenStream, type_alias_stream: TokenStream) -> Toke type_alias.ty = Box::new(Type::Verbatim(factory_interface.to_token_stream())); - let decl_interfaces = if is_threadsafe { - quote! { - syrette::declare_interface!( - syrette::castable_factory::threadsafe::ThreadsafeCastableFactory< - (std::sync::Arc,), - #factory_interface - > -> syrette::interfaces::factory::IFactory< - (std::sync::Arc,), - #factory_interface - >, - async = true - ); - - syrette::declare_interface!( - syrette::castable_factory::threadsafe::ThreadsafeCastableFactory< - (std::sync::Arc,), - #factory_interface - > -> syrette::interfaces::any_factory::AnyThreadsafeFactory, - async = true - ); - } - } else { - quote! { - syrette::declare_interface!( - syrette::castable_factory::blocking::CastableFactory< - (std::rc::Rc,), - #factory_interface - > -> syrette::interfaces::factory::IFactory< - (std::rc::Rc,), - #factory_interface - > - ); - - syrette::declare_interface!( - syrette::castable_factory::blocking::CastableFactory< - (std::rc::Rc,), - #factory_interface - > -> syrette::interfaces::any_factory::AnyFactory - ); - } - }; + let decl_interfaces = + build_declare_factory_interfaces(&factory_interface, is_threadsafe); quote! { #type_alias @@ -293,7 +255,7 @@ pub fn factory(args_stream: TokenStream, type_alias_stream: TokenStream) -> Toke /// /// A default factory is a factory that doesn't take any arguments. /// -/// The more tedious way to accomplish what this macro does would be by using +/// Another way to accomplish what this macro does would be by using /// the [`macro@factory`] macro. /// /// *This macro is only available if Syrette is built with the "factory" feature.* @@ -323,7 +285,9 @@ pub fn factory(args_stream: TokenStream, type_alias_stream: TokenStream) -> Toke #[cfg(feature = "factory")] pub fn declare_default_factory(args_stream: TokenStream) -> TokenStream { + use crate::factory::build_declare_interfaces::build_declare_factory_interfaces; use crate::factory::declare_default_args::DeclareDefaultFactoryMacroArgs; + use crate::fn_trait::FnTrait; let DeclareDefaultFactoryMacroArgs { interface, flags } = parse(args_stream).unwrap(); @@ -332,49 +296,20 @@ pub fn declare_default_factory(args_stream: TokenStream) -> TokenStream .find(|flag| flag.flag.to_string().as_str() == "threadsafe") .map_or(false, |flag| flag.is_on.value); - if is_threadsafe { - return quote! { - syrette::declare_interface!( - syrette::castable_factory::threadsafe::ThreadsafeCastableFactory< - (std::sync::Arc,), - #interface, - > -> syrette::interfaces::factory::IFactory< - (std::sync::Arc,), - #interface - >, - async = true - ); - - syrette::declare_interface!( - syrette::castable_factory::threadsafe::ThreadsafeCastableFactory< - (std::sync::Arc,), - #interface, - > -> syrette::interfaces::any_factory::AnyThreadsafeFactory, - async = true - ); + let mut factory_interface: FnTrait = parse( + quote! { + dyn Fn() -> syrette::ptr::TransientPtr<#interface> } - .into(); - } + .into(), + ) + .unwrap(); - quote! { - syrette::declare_interface!( - syrette::castable_factory::blocking::CastableFactory< - (std::rc::Rc,), - #interface, - > -> syrette::interfaces::factory::IFactory< - (std::rc::Rc,), - #interface - > - ); - - syrette::declare_interface!( - syrette::castable_factory::blocking::CastableFactory< - (std::rc::Rc,), - #interface, - > -> syrette::interfaces::any_factory::AnyFactory - ); + if is_threadsafe { + factory_interface.add_trait_bound(parse_str("Send").unwrap()); + factory_interface.add_trait_bound(parse_str("Sync").unwrap()); } - .into() + + build_declare_factory_interfaces(&factory_interface, is_threadsafe).into() } /// Declares the interface trait of a implementation. -- cgit v1.2.3-18-g5258