cmdreg 0.1.4

A lightweight string-keyed command dispatcher with axum-style extractors for Rust
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

use anyhow::{anyhow, Result};
use std::sync::{Arc, LazyLock, RwLock};

use crate::command_map::CommandMap;
use crate::context::CommandContext;
use crate::handler::CommandHandler;
use crate::response::CommandResult;

type HandlerValue = Box<dyn Fn(&str, CommandContext) -> CommandResult + Send + Sync>;

type SyncMap = CommandMap<&'static str, HandlerValue>;

static COMMANDS: LazyLock<Arc<RwLock<SyncMap>>> =
    LazyLock::new(|| Arc::new(RwLock::new(SyncMap::new())));

/// Register a sync command handler.
pub fn reg_command<T, H>(command: &'static str, handler: H) -> Result<()>
where
    H: CommandHandler<T>,
{
    match COMMANDS.write() {
        Ok(mut commands) => {
            let wrapped_fn =
                move |key: &str, ctx: CommandContext| -> CommandResult { handler.call(key, ctx) };
            commands.reg(command, Box::new(wrapped_fn));
            Ok(())
        }
        Err(err) => Err(anyhow!(err.to_string())),
    }
}

/// Unregister a sync command.
pub fn unreg_command(command: &'static str) -> Result<()> {
    match COMMANDS.write() {
        Ok(mut commands) => {
            commands.unreg(&command);
            Ok(())
        }
        Err(err) => Err(anyhow!(err.to_string())),
    }
}

/// Clear all registered sync commands.
pub fn clear_commands() -> Result<()> {
    match COMMANDS.write() {
        Ok(mut commands) => {
            commands.clear();
            Ok(())
        }
        Err(err) => Err(anyhow!(err.to_string())),
    }
}

/// Get all registered sync command keys.
pub fn get_command_keys() -> Result<Vec<String>> {
    match COMMANDS.read() {
        Ok(commands) => Ok(commands.keys()),
        Err(err) => Err(anyhow!(err.to_string())),
    }
}

/// Get the number of registered sync commands.
pub fn get_command_len() -> Result<usize> {
    match COMMANDS.read() {
        Ok(commands) => Ok(commands.len()),
        Err(err) => Err(anyhow!(err.to_string())),
    }
}

/// Invoke a sync command by key.
pub fn invoke_command(key: &str, ctx: CommandContext) -> CommandResult {
    match COMMANDS.read() {
        Ok(commands) => {
            if let Some(cmd) = commands.get(&key) {
                cmd(key, ctx)
            } else {
                Err(anyhow!("command not found: {}", key))
            }
        }
        Err(err) => Err(anyhow!(err.to_string())),
    }
}