wef 0.6.0

Wef is a Rust library for embedding WebView functionality using Chromium Embedded Framework (CEF3) with offscreen rendering support.
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

use std::{collections::HashMap, sync::Arc};

use futures_util::future::BoxFuture;

use crate::{
    AsyncFunctionType, FuncRegistry, FunctionType,
    func_registry::dyn_wrapper::{DynAsyncFunctionWrapper, DynFunctionType, DynFunctionWrapper},
};

/// A builder for creating a function registry.
#[derive(Default)]
pub struct FuncRegistryBuilder {
    functions: HashMap<String, Box<dyn DynFunctionType>>,
}

impl FuncRegistryBuilder {
    /// Registers a function with the given name.
    pub fn register<F, S, R>(mut self, name: &str, func: F) -> Self
    where
        F: FunctionType<S, R> + Send + Sync + 'static,
        S: Send + Sync + 'static,
        R: Send + Sync + 'static,
    {
        self.functions
            .insert(name.to_string(), Box::new(DynFunctionWrapper::new(func)));
        self
    }

    /// Consumes the builder and returns a new [`AsyncFuncRegistryBuilder`].
    pub fn with_spawner<S, R>(self, spawner: S) -> AsyncFuncRegistryBuilder
    where
        S: Fn(BoxFuture<'static, ()>) -> R + Send + Sync + 'static,
    {
        AsyncFuncRegistryBuilder {
            functions: self.functions,
            spawner: Arc::new(move |fut| {
                spawner(fut);
            }),
        }
    }

    /// Builds the [`FuncRegistry`].
    pub fn build(self) -> FuncRegistry {
        FuncRegistry {
            functions: Arc::new(self.functions),
            spawner: None,
        }
    }
}

/// A builder for creating an function registry with async functions.
pub struct AsyncFuncRegistryBuilder {
    functions: HashMap<String, Box<dyn DynFunctionType>>,
    spawner: Arc<dyn Fn(BoxFuture<'static, ()>) + Send + Sync>,
}

impl AsyncFuncRegistryBuilder {
    /// Registers a function with the given name.
    pub fn register<F, S, R>(mut self, name: &str, func: F) -> Self
    where
        F: FunctionType<S, R> + Send + Sync + 'static,
        S: Send + Sync + 'static,
        R: Send + Sync + 'static,
    {
        self.functions
            .insert(name.to_string(), Box::new(DynFunctionWrapper::new(func)));
        self
    }

    /// Registers a async function with the given name.
    pub fn register_async<F, S, R>(mut self, name: &str, func: F) -> Self
    where
        F: AsyncFunctionType<S, R> + Send + Sync + 'static,
        S: Send + Sync + 'static,
        R: Send + Sync + 'static,
    {
        self.functions.insert(
            name.to_string(),
            Box::new(DynAsyncFunctionWrapper::new(func)),
        );
        self
    }

    /// Builds the [`FuncRegistry`].
    pub fn build(self) -> FuncRegistry {
        FuncRegistry {
            functions: Arc::new(self.functions),
            spawner: Some(self.spawner),
        }
    }
}