musdk 0.1.0

mu Protocol app development SDK
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

use std::borrow::Cow;

use musdk_common::{
    incoming_message::{storage::Object, IncomingMessage as IM},
    outgoing_message::{storage::*, OutgoingMessage as OM},
};

use crate::{Error, Result};

pub struct StorageHandle<'a> {
    pub(super) context: &'a mut super::MuContext,
}

impl<'a> StorageHandle<'a> {
    fn request(&mut self, req: OM) -> Result<IM<'static>> {
        self.context.write_message(req)?;
        self.context.read_message()
    }

    pub fn delete(&mut self, storage_name: &str, key: &str) -> Result<()> {
        let req = StorageDelete {
            storage_name: Cow::Borrowed(storage_name),
            key: Cow::Borrowed(key),
        };

        let resp = self.request(OM::StorageDelete(req))?;
        from_empty_resp(resp, "StorageDelete")
    }

    pub fn search_by_prefix(&mut self, storage_name: &str, prefix: &str) -> Result<Vec<Object>> {
        let req = StorageList {
            storage_name: Cow::Borrowed(storage_name),
            prefix: Cow::Borrowed(prefix),
        };

        let resp = self.request(OM::StorageList(req))?;
        match resp {
            IM::ObjectListResult(x) => Ok(x.list),
            resp => resp_to_err(resp, "StorageList"),
        }
    }

    pub fn get(&mut self, storage_name: &str, key: &str) -> Result<Cow<[u8]>> {
        let req = StorageGet {
            storage_name: Cow::Borrowed(storage_name),
            key: Cow::Borrowed(key),
        };

        let resp = self.request(OM::StorageGet(req))?;

        match resp {
            IM::StorageGetResult(x) => Ok(x.data),
            resp => resp_to_err(resp, "StorageGet"),
        }
    }

    pub fn put(&mut self, storage_name: &str, key: &str, data: &[u8]) -> Result<()> {
        let req = StoragePut {
            storage_name: Cow::Borrowed(storage_name),
            key: Cow::Borrowed(key),
            reader: Cow::Borrowed(data),
        };

        let resp = self.request(OM::StoragePut(req))?;

        from_empty_resp(resp, "StoragePut")
    }
}

fn resp_to_err<T>(resp: IM, kind_name: &'static str) -> Result<T> {
    match resp {
        IM::StorageError(e) => Err(Error::StorageError(e.error.into_owned())),
        _ => Err(Error::UnexpectedMessageKind(kind_name)),
    }
}

fn from_empty_resp(resp: IM, kind_name: &'static str) -> Result<()> {
    match resp {
        IM::StorageEmptyResult(_) => Ok(()),
        resp => resp_to_err(resp, kind_name),
    }
}