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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! TryFrom implementations for wrapped store-related types

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

use crate::{datastore::idb_dal::IdThing, prelude::*};

// region: Implementations

impl TryFrom<Wrap<Value>> for Object {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<Object> {
        match val.0 {
            Value::Object(obj) => Ok(obj),
            _ => Err(Self::Error::PropertyNotFound(String::from("Object"))),
        }
    }
}

impl TryFrom<Wrap<Value>> for Array {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<Array> {
        match val.0 {
            Value::Array(obj) => Ok(obj),
            _ => Err(Self::Error::PropertyNotFound(String::from("Array"))),
        }
    }
}

impl TryFrom<Wrap<Value>> for f64 {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<f64> {
        match val.0 {
            Value::Strand(obj) => Ok(obj.as_str().parse::<f64>().unwrap()),
            Value::Number(obj) => Ok(obj.as_float()),
            _ => Err(Self::Error::PropertyNotFound(String::from("f64"))),
        }
    }
}

impl TryFrom<Wrap<Value>> for Duration {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<Duration> {
        match val.0 {
            Value::Number(obj) => Ok(Duration::from_millis(obj.to_int() as u64)),
            _ => Err(Self::Error::PropertyNotFound(String::from("Duration"))),
        }
    }
}

impl TryFrom<Wrap<Value>> for i64 {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<i64> {
        match val.0 {
            Value::Strand(obj) => Ok(obj.as_str().parse::<i64>().unwrap()),
            Value::Number(obj) => Ok(obj.as_int()),
            _ => Err(Self::Error::PropertyNotFound(String::from("i64"))),
        }
    }
}

impl TryFrom<Wrap<Value>> for bool {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<bool> {
        match val.0 {
            Value::Bool(false) => Ok(false),
            Value::Bool(true) => Ok(true),
            _ => Err(Self::Error::PropertyNotFound(String::from("bool"))),
        }
    }
}

impl TryFrom<Wrap<Value>> for String {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<String> {
        match val.0 {
            Value::Strand(strand) => Ok(strand.as_string()),
            Value::Thing(thing) => Ok(thing.to_string()),
            _ => Err(Self::Error::PropertyNotFound(String::from("String"))),
        }
    }
}

impl TryFrom<Wrap<Value>> for Uuid {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<Uuid> {
        match val.0 {
            Value::Uuid(id) => Ok(id),
            _ => Err(Self::Error::PropertyNotFound(String::from("Uuid"))),
        }
    }
}

impl TryFrom<Wrap<Value>> for IdThing {
    type Error = RustiumError;
    fn try_from(val: Wrap<Value>) -> RustiumResult<IdThing> {
        match val.0 {
            Value::Thing(thing) => Ok(IdThing(thing.id.to_string())),
            _ => Err(Self::Error::PropertyNotFound(String::from("IdThing"))),
        }
    }
}
// endregion: Implementations