qsingleton 0.1.0

Helper macros to generate singleton definitions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse::Parse, parse::ParseStream, parse_macro_input, Ident, ItemStruct};

struct SingletonArgs {
    use_arc: bool,
}

impl Parse for SingletonArgs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        if input.is_empty() {
            return Ok(SingletonArgs { use_arc: false });
        }

        let ident: Ident = input.parse()?;
        if ident == "arc" {
            Ok(SingletonArgs { use_arc: true })
        } else {
            Err(syn::Error::new(
                ident.span(),
                "Expected 'arc' or no arguments",
            ))
        }
    }
}

/// A macro to define a singleton struct.
///
/// There are two modes:
/// - Default(`#[singleton]`): Returns a static reference to `Self`.
/// - `#[singleton(arc)]`: Returns an `&'static Arc<Self>`, allowing for shared ownership across threads.
///
/// Usage:
/// ```
/// use qsingleton::singleton;
///
/// #[singleton]
/// #[derive(Debug)]
/// struct Config {
///    name: String,
///    version: String,
/// }  
///
/// #[singleton(arc)]
/// #[derive(Debug)]
/// struct Database {
///    connection_string: String,
///    pool_size: usize,
/// }
/// ```
#[proc_macro_attribute]
pub fn singleton(args: TokenStream, input: TokenStream) -> TokenStream {
    let args = parse_macro_input!(args as SingletonArgs);
    let input_struct = parse_macro_input!(input as ItemStruct);
    let name = &input_struct.ident;

    // Create unique global variable name to prevent conflicts
    let instance_name = syn::Ident::new(
        &format!("{}_INSTANCE", name.to_string().to_uppercase()),
        name.span(),
    );

    let impl_block = if args.use_arc {
        quote! {
            static #instance_name: ::std::sync::OnceLock<std::sync::Arc<#name>> = ::std::sync::OnceLock::new();
            impl #name {
                /// Get the global singleton instance as Arc
                pub fn global() -> &'static ::std::sync::Arc<Self> {
                    #instance_name.get().expect(&format!(
                        "Singleton '{}' not initialized. Call init() first.",
                        stringify!(#name)
                    ))
                }

                /// Initialize the singleton instance
                pub fn init(instance: Self) {
                    #instance_name.set(::std::sync::Arc::new(instance)).expect(&format!(
                        "Singleton '{}' already initialized",
                        stringify!(#name)
                    ))
                }
            }
        }
    } else {
        quote! {
            static #instance_name: ::std::sync::OnceLock<#name> = ::std::sync::OnceLock::new();
            impl #name {
                /// Get the global singleton instance
                pub fn global() -> &'static Self {
                    #instance_name.get().expect(&format!(
                        "Singleton '{}' not initialized. Call init() first.",
                        stringify!(#name)
                    ))
                }

                /// Initialize the singleton instance
                pub fn init(instance: Self) {
                    #instance_name.set(instance).expect(&format!(
                        "Singleton '{}' already initialized",
                        stringify!(#name)
                    ))
                }
            }
        }
    };

    let expanded = quote! {
        #input_struct
        #impl_block
    };

    TokenStream::from(expanded)
}