rustium 0.1.4

A Rust application framework that values concurrency, performance, and scalability
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

//! TakeXImpl implementations for the surrealdb Object types.

use std::time::Duration;
use surrealdb::sql::{Object, Uuid};

use crate::{
    datastore::{idb_dal::IdThing, object::TakeXImpl},
    prelude::*,
};
// region: Implementations

impl TakeXImpl<String> for Object {
    fn take_x_impl(&mut self, k: &str) -> RustiumResult<Option<String>> {
        let v = self.remove(k).map(|v| Wrap(v).try_into());
        match v {
            None => Ok(None),
            Some(Ok(val)) => Ok(Some(val)),
            Some(Err(ex)) => Err(ex),
        }
    }
}

impl TakeXImpl<f64> for Object {
    fn take_x_impl(&mut self, k: &str) -> RustiumResult<Option<f64>> {
        let v = self.remove(k).map(|v| Wrap(v).try_into());
        match v {
            None => Ok(None),
            Some(Ok(val)) => Ok(Some(val)),
            Some(Err(ex)) => Err(ex),
        }
    }
}

impl TakeXImpl<i64> for Object {
    fn take_x_impl(&mut self, k: &str) -> RustiumResult<Option<i64>> {
        let v = self.remove(k).map(|v| Wrap(v).try_into());
        match v {
            None => Ok(None),
            Some(Ok(val)) => Ok(Some(val)),
            Some(Err(ex)) => Err(ex),
        }
    }
}

impl TakeXImpl<bool> for Object {
    fn take_x_impl(&mut self, k: &str) -> RustiumResult<Option<bool>> {
        Ok(self.remove(k).map(|v| v.is_true()))
    }
}

impl TakeXImpl<Uuid> for Object {
    fn take_x_impl(&mut self, k: &str) -> RustiumResult<Option<Uuid>> {
        let v = self.remove(k).map(|v| Wrap(v).try_into());
        match v {
            None => Ok(None),
            Some(Ok(val)) => Ok(Some(val)),
            Some(Err(e)) => Err(e),
        }
    }
}

impl TakeXImpl<Duration> for Object {
    fn take_x_impl(&mut self, k: &str) -> RustiumResult<Option<Duration>> {
        let v = self.remove(k).map(|v| Wrap(v).try_into());
        match v {
            None => Ok(None),
            Some(Ok(val)) => Ok(Some(val)),
            Some(Err(e)) => Err(e),
        }
    }
}

impl TakeXImpl<IdThing> for Object {
    fn take_x_impl(&mut self, k: &str) -> RustiumResult<Option<IdThing>> {
        let v = self.remove(k).map(|v| Wrap(v).try_into());
        match v {
            None => Ok(None),
            Some(Ok(val)) => Ok(Some(val)),
            Some(Err(e)) => Err(e),
        }
    }
}
// endregion: Implementations