rpc-rs 0.1.1

A blazingly fast, lightweight, and type-safe RPC/IPC framework for Rust and Web/Tauri-based applications, based on `specta`.
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

//! The [`ModuleBuilder`] module.

use crate::{proc::GenericProcedure, util::TripleS};

use super::module::Module;

/// A builder for a [`Module`].
pub struct ModuleBuilder<Cx: TripleS + Clone> {
    /// The handler for [`rpc_rs::Method::Create`] calls.
    pub(crate) create: Option<Box<dyn GenericProcedure<Cx> + TripleS>>,

    /// The handler for [`rpc_rs::Method::Read`] calls.
    pub(crate) read: Option<Box<dyn GenericProcedure<Cx> + TripleS>>,

    /// The handler for [`rpc_rs::Method::Update`] calls.
    pub(crate) update: Option<Box<dyn GenericProcedure<Cx> + TripleS>>,

    /// The handler for [`rpc_rs::Method::Delete`] calls.
    pub(crate) delete: Option<Box<dyn GenericProcedure<Cx> + TripleS>>,
}

impl<Cx: TripleS + Clone> Default for ModuleBuilder<Cx> {
    fn default() -> Self {
        Self {
            create: None,
            read: None,
            update: None,
            delete: None,
        }
    }
}

impl<Cx: TripleS + Clone> ModuleBuilder<Cx> {
    /// Attach a handler for [`rpc_rs::Method::Create`].
    pub fn create<Proc: GenericProcedure<Cx> + TripleS>(mut self, proc: Proc) -> Self {
        self.create = Some(Box::new(proc));
        self
    }

    /// Attach a handler for [`rpc_rs::Method::Read`].
    pub fn read<Proc: GenericProcedure<Cx> + TripleS>(mut self, proc: Proc) -> Self {
        self.read = Some(Box::new(proc));
        self
    }

    /// Attach a handler for [`rpc_rs::Method::Update`].
    pub fn update<Proc: GenericProcedure<Cx> + TripleS>(mut self, proc: Proc) -> Self {
        self.update = Some(Box::new(proc));
        self
    }

    /// Attach a handler for [`rpc_rs::Method::Delete`].
    pub fn delete<Proc: GenericProcedure<Cx> + TripleS>(mut self, proc: Proc) -> Self {
        self.delete = Some(Box::new(proc));
        self
    }

    /// Build this [`ModuleBuilder`], converting it into a [`Module`].
    pub fn build(self) -> Module<Cx> {
        Module::new(self)
    }
}