wasmcloud-actor-graphdb 0.1.3

GraphDB Actor Interface for wasmCloud Actors
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
104
105
106
107
108
109
110
111
112
113
114

use crate::client_type_error;
use crate::errors::GraphResult;
use crate::generated::{Node, Relation, ResultSet, Scalar};
use crate::results::{get_node, get_relation, get_scalar, FromCell};

impl FromCell for Scalar {
    fn from_cell(result_set: &ResultSet, row_idx: usize, column_idx: usize) -> GraphResult<Self> {
        let scalar = get_scalar(result_set, row_idx, column_idx)?;
        Ok(scalar.clone())
    }
}

impl<T: FromCell> FromCell for Option<T> {
    fn from_cell(result_set: &ResultSet, row_idx: usize, column_idx: usize) -> GraphResult<Self> {
        let scalar = get_scalar(result_set, row_idx, column_idx)?;

        match scalar {
            _ => T::from_cell(result_set, row_idx, column_idx).map(Some),
        }
    }
}

impl FromCell for bool {
    fn from_cell(result_set: &ResultSet, row_idx: usize, column_idx: usize) -> GraphResult<Self> {
        let scalar = get_scalar(result_set, row_idx, column_idx)?;
        if let Some(boolean) = scalar.bool_value {
            Ok(boolean)
        } else {
            client_type_error!("failed to construct value: expected boolean, found None",)
        }
    }
}

// The following code and macros produce the requisite type "magic" to allow
// code in an actor to extract strongly-typed data from a result set in
// tuples (or vecs of tuples)

macro_rules! impl_from_scalar_for_integer {
    ($t:ty) => {
        impl FromCell for $t {
            fn from_cell(
                result_set: &ResultSet,
                row_idx: usize,
                column_idx: usize,
            ) -> GraphResult<Self> {
                let scalar = get_scalar(result_set, row_idx, column_idx)?;
                if let Some(int) = scalar.int_value {
                    Ok(int as $t)
                } else {
                    client_type_error!("failed to construct value: expected integer, found None",)
                }
            }
        }
    };
}

impl_from_scalar_for_integer!(u8);
impl_from_scalar_for_integer!(u16);
impl_from_scalar_for_integer!(u32);
impl_from_scalar_for_integer!(u64);
impl_from_scalar_for_integer!(usize);

impl_from_scalar_for_integer!(i8);
impl_from_scalar_for_integer!(i16);
impl_from_scalar_for_integer!(i32);
impl_from_scalar_for_integer!(i64);
impl_from_scalar_for_integer!(isize);

macro_rules! impl_from_scalar_for_float {
    ($t:ty) => {
        impl FromCell for $t {
            fn from_cell(
                result_set: &ResultSet,
                row_idx: usize,
                column_idx: usize,
            ) -> GraphResult<Self> {
                let scalar = get_scalar(result_set, row_idx, column_idx)?;
                if let Some(double) = scalar.double_value {
                    Ok(double as $t)
                } else {
                    client_type_error!("failed to construct value: expected double, found None",)
                }
            }
        }
    };
}

impl_from_scalar_for_float!(f32);
impl_from_scalar_for_float!(f64);

impl FromCell for String {
    fn from_cell(result_set: &ResultSet, row_idx: usize, column_idx: usize) -> GraphResult<Self> {
        let scalar = get_scalar(result_set, row_idx, column_idx)?;
        if let Some(data) = &scalar.string_value {
            Ok(data.clone())
        } else {
            client_type_error!("failed to construct value: expected string, found None",)
        }
    }
}

impl FromCell for Node {
    fn from_cell(result_set: &ResultSet, row_idx: usize, column_idx: usize) -> GraphResult<Self> {
        let node = get_node(result_set, row_idx, column_idx)?;
        Ok(node.clone())
    }
}

impl FromCell for Relation {
    fn from_cell(result_set: &ResultSet, row_idx: usize, column_idx: usize) -> GraphResult<Self> {
        let relation = get_relation(result_set, row_idx, column_idx)?;
        Ok(relation.clone())
    }
}