polariton_server 0.6.0

Server functionality for the Photon packet system
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

use polariton::operation::{OperationResponse, ParameterTable};
use super::{Operation, OperationCode};

pub struct SimpleOpError {
    code: i16,
    message: Option<String>,
}

impl SimpleOpError {
    pub fn with_code(code: i16) -> Self {
        SimpleOpError { code, message: None }
    }

    pub fn with_message(code: i16, message: String) -> Self {
        SimpleOpError { code, message: Some(message) }
    }

    pub fn error_code(&self) -> i16 {
        self.code
    }

    pub fn error_msg(&self) -> Option<&'_ String> {
        self.message.as_ref()
    }
}

impl std::convert::From<i16> for SimpleOpError {
    fn from(value: i16) -> Self {
        Self::with_code(value)
    }
}

impl std::convert::From<SimpleOpError> for i16 {
    fn from(value: SimpleOpError) -> Self {
        value.code
    }
}

#[async_trait::async_trait]
pub trait SimpleOperation<C: Send + 'static = ()>: Send + Sync {
    type User: Sync;
    const CODE: u8;

    async fn handle(&self, params: ParameterTable<C>, user: &Self::User) -> Result<ParameterTable<C>, SimpleOpError>;
}

pub struct SimpleOpImpl<C: Send + 'static, U: Sync, O: SimpleOperation<C, User=U>> {
    inner: O,
    _c: std::marker::PhantomData<fn() -> C>,
    _u: std::marker::PhantomData<fn() -> U>,
}

impl<C: Send + 'static, U: Sync, O: SimpleOperation<C, User=U>> SimpleOpImpl<C, U, O> {
    pub fn new(op: O) -> Self {
        Self {
            inner: op,
            _c: Default::default(),
            _u: Default::default(),
        }
    }
}

#[async_trait::async_trait]
impl <C: Send + 'static, U: Sync, X: SimpleOperation<C, User=U>> Operation<C> for SimpleOpImpl<C, U, X> {
    type User = U;
    async fn handle_async(&self, params: ParameterTable<C>, user: &Self::User) -> OperationResponse<C> {
        let result = self.inner.handle(params, user).await;
        match result {
            Ok(p_out) => {
                OperationResponse {
                    code: X::CODE,
                    return_code: 0,
                    message: polariton::operation::Typed::Null,
                    params: p_out,
                }
            },
            Err(e) => {
                OperationResponse {
                    code: X::CODE,
                    return_code: e.code,
                    message: e.message.map(|s| polariton::operation::Typed::Str(s.into()))
                        .unwrap_or(polariton::operation::Typed::Null),
                    params: std::collections::HashMap::new().into(),
                }
            }
        }
    }
}

impl <C: Send + 'static, U: Sync, X: SimpleOperation<C, User=U>> OperationCode for SimpleOpImpl<C, U, X> {
    fn op_code() -> u8 {
        X::CODE
    }
}