rlay-backend 0.3.0

Common traits for Rlay (storage) backends
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
115
116
117
118
119
120
121
122

use ambassador::delegatable_trait;
use cid::Cid;
use failure::{err_msg, Error};
use futures::future::{err, BoxFuture, FutureExt};
use rlay_ontology::ontology::Entity;
use serde_json::Value;
use std::collections::HashMap;

#[delegatable_trait]
pub trait BackendRpcMethodGetEntity {
    #[allow(unused_variables)]
    fn get_entity(&mut self, cid: &str) -> BoxFuture<Result<Option<Entity>, Error>> {
        err(err_msg(
            "The requested backend does not support this RPC method.",
        ))
        .boxed()
    }
}

#[delegatable_trait]
pub trait BackendRpcMethodGetEntities {
    #[allow(unused_variables)]
    fn get_entities(&mut self, cids: Vec<String>) -> BoxFuture<Result<Vec<Entity>, Error>> {
        err(err_msg(
            "The requested backend does not support this RPC method.",
        ))
        .boxed()
    }
}

#[delegatable_trait]
pub trait BackendRpcMethodStoreEntity {
    #[allow(unused_variables)]
    fn store_entity(
        &mut self,
        entity: &Entity,
        options_object: &Value,
    ) -> BoxFuture<Result<Cid, Error>> {
        err(err_msg(
            "The requested backend does not support this RPC method.",
        ))
        .boxed()
    }
}

#[delegatable_trait]
pub trait BackendRpcMethodStoreEntities {
    #[allow(unused_variables)]
    fn store_entities(
        &mut self,
        entities: &Vec<Entity>,
        options_object: &Value,
    ) -> BoxFuture<Result<Vec<Cid>, Error>> {
        err(err_msg(
            "The requested backend does not support this RPC method.",
        ))
        .boxed()
    }
}

#[delegatable_trait]
pub trait BackendRpcMethodListCids {
    #[allow(unused_variables)]
    fn list_cids(&mut self, entity_kind: Option<&str>) -> BoxFuture<Result<Vec<String>, Error>> {
        err(err_msg(
            "The requested backend does not support this RPC method.",
        ))
        .boxed()
    }
}

#[delegatable_trait]
pub trait BackendRpcMethodNeo4jQuery {
    #[allow(unused_variables)]
    fn neo4j_query(&mut self, query: &str) -> BoxFuture<Result<Vec<String>, Error>> {
        err(err_msg(
            "The requested backend does not support this RPC method.",
        ))
        .boxed()
    }
}

#[delegatable_trait]
pub trait BackendRpcMethodResolveEntity {
    #[allow(unused_variables)]
    fn resolve_entity(
        &mut self,
        cid: &str,
    ) -> BoxFuture<Result<HashMap<String, Vec<Entity>>, Error>> {
        err(err_msg(
            "The requested backend does not support this RPC method.",
        ))
        .boxed()
    }
}

#[delegatable_trait]
pub trait BackendRpcMethodResolveEntities {
    #[allow(unused_variables)]
    fn resolve_entities(
        &mut self,
        cids: Vec<String>,
    ) -> BoxFuture<Result<HashMap<String, Vec<Entity>>, Error>> {
        err(err_msg(
            "The requested backend does not support this RPC method.",
        ))
        .boxed()
    }
}

pub trait BackendRpcMethods:
    Send
    + BackendRpcMethodGetEntity
    + BackendRpcMethodGetEntities
    + BackendRpcMethodStoreEntity
    + BackendRpcMethodStoreEntities
    + BackendRpcMethodResolveEntity
    + BackendRpcMethodResolveEntities
    + BackendRpcMethodListCids
    + BackendRpcMethodNeo4jQuery
{
}