plux-rs 1.1.2

A modular and performant plugin system for Rust applications, enabling secure and stable extension of functionality through external plugins.
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

use std::fmt::Display;

use serde::{Deserialize, Serialize};

use crate::variable::VariableType;

/// Represents a function request that plugins must implement.
///
/// A Request defines the interface that plugins are expected to provide.
/// It specifies the function signature that plugins should implement,
/// including input and output types.
///
/// # Fields
///
/// * `name` - The name of the requested function
/// * `inputs` - List of input parameter types
/// * `output` - Optional output type (None for void functions)
///
/// # Examples
///
/// ```rust
/// use plux_rs::function::Request;
/// use plux_rs::variable::VariableType;
///
/// // Request a function that takes two integers and returns their sum
/// let add_request = Request::new(
///     "add",
///     vec![VariableType::I32, VariableType::I32],
///     Some(VariableType::I32)
/// );
///
/// // Request a logging function that takes a string and returns nothing
/// let log_request = Request::new(
///     "log",
///     vec![VariableType::String],
///     None
/// );
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Request {
    /// The name of the requested function
    pub name: String,
    /// List of input parameter types
    pub inputs: Vec<VariableType>,
    /// Optional output type (None for void functions)
    pub output: Option<VariableType>,
}

impl Request {
    /// Creates a new function request.
    ///
    /// # Parameters
    ///
    /// * `name` - The function name (will be converted to String)
    /// * `inputs` - Vector of input parameter types
    /// * `output` - Optional output type (None for void functions)
    ///
    /// # Returns
    ///
    /// Returns a new Request instance.
    ///
    /// # Type Parameters
    ///
    /// * `S` - Type that can be converted into String
    ///
    /// # Example
    ///
    /// ```rust
    /// use plux_rs::function::Request;
    /// use plux_rs::variable::VariableType;
    ///
    /// let request = Request::new(
    ///     "calculate_area",
    ///     vec![VariableType::F64, VariableType::F64], // width, height
    ///     Some(VariableType::F64) // area
    /// );
    /// ```
    pub fn new<S: Into<String>>(
        name: S,
        inputs: Vec<VariableType>,
        output: Option<VariableType>,
    ) -> Self {
        Self {
            name: name.into(),
            inputs,
            output,
        }
    }
}

impl Display for Request {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}({}) -> {}",
            self.name,
            self.inputs
                .iter()
                .map(|x| format!("{x}"))
                .collect::<Vec<_>>()
                .join(", "),
            match self.output {
                Some(x) => format!("{x}"),
                None => "void".to_string(),
            }
        )
    }
}