wasmcloud_actor_extras/
generated.rs

1extern crate rmp_serde as rmps;
2use rmps::{Deserializer, Serializer};
3use serde::{Deserialize, Serialize};
4use std::io::Cursor;
5
6#[cfg(feature = "guest")]
7extern crate wapc_guest as guest;
8#[cfg(feature = "guest")]
9use guest::prelude::*;
10
11#[cfg(feature = "guest")]
12pub struct Host {
13    binding: String,
14}
15
16#[cfg(feature = "guest")]
17impl Default for Host {
18    fn default() -> Self {
19        Host {
20            binding: "default".to_string(),
21        }
22    }
23}
24
25/// Creates a named host binding
26#[cfg(feature = "guest")]
27pub fn host(binding: &str) -> Host {
28    Host {
29        binding: binding.to_string(),
30    }
31}
32
33/// Creates the default host binding
34#[cfg(feature = "guest")]
35pub fn default() -> Host {
36    Host::default()
37}
38
39#[cfg(feature = "guest")]
40impl Host {
41    /// Request a Globally Unique Identifier
42    pub fn request_guid(&self, req: GeneratorRequest) -> HandlerResult<GeneratorResult> {
43        host_call(
44            &self.binding,
45            "wasmcloud:extras",
46            "RequestGuid",
47            &serialize(req)?,
48        )
49        .map(|vec| {
50            let resp = deserialize::<GeneratorResult>(vec.as_ref()).unwrap();
51            resp
52        })
53        .map_err(|e| e.into())
54    }
55    /// Request a random number with minimum and maximum parameters. Inclusivity depends
56    /// on implementation and is not guaranteed on either end
57    pub fn request_random(&self, req: GeneratorRequest) -> HandlerResult<GeneratorResult> {
58        host_call(
59            &self.binding,
60            "wasmcloud:extras",
61            "RequestRandom",
62            &serialize(req)?,
63        )
64        .map(|vec| {
65            let resp = deserialize::<GeneratorResult>(vec.as_ref()).unwrap();
66            resp
67        })
68        .map_err(|e| e.into())
69    }
70    /// Request the next number in a monotonically increasing sequence, starting at 0
71    pub fn request_sequence(&self, req: GeneratorRequest) -> HandlerResult<GeneratorResult> {
72        host_call(
73            &self.binding,
74            "wasmcloud:extras",
75            "RequestSequence",
76            &serialize(req)?,
77        )
78        .map(|vec| {
79            let resp = deserialize::<GeneratorResult>(vec.as_ref()).unwrap();
80            resp
81        })
82        .map_err(|e| e.into())
83    }
84}
85
86#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
87pub struct GeneratorResult {
88    #[serde(rename = "guid")]
89    pub guid: Option<String>,
90    #[serde(rename = "sequenceNumber")]
91    pub sequence_number: u64,
92    #[serde(rename = "random_number")]
93    pub random_number: u32,
94}
95
96#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
97pub struct GeneratorRequest {
98    #[serde(rename = "guid")]
99    pub guid: bool,
100    #[serde(rename = "sequence")]
101    pub sequence: bool,
102    #[serde(rename = "random")]
103    pub random: bool,
104    #[serde(rename = "min")]
105    pub min: u32,
106    #[serde(rename = "max")]
107    pub max: u32,
108}
109
110/// The standard function for serializing codec structs into a format that can be
111/// used for message exchange between actor and host. Use of any other function to
112/// serialize could result in breaking incompatibilities.
113pub fn serialize<T>(
114    item: T,
115) -> ::std::result::Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>>
116where
117    T: Serialize,
118{
119    let mut buf = Vec::new();
120    item.serialize(&mut Serializer::new(&mut buf).with_struct_map())?;
121    Ok(buf)
122}
123
124/// The standard function for de-serializing codec structs from a format suitable
125/// for message exchange between actor and host. Use of any other function to
126/// deserialize could result in breaking incompatibilities.
127pub fn deserialize<'de, T: Deserialize<'de>>(
128    buf: &[u8],
129) -> ::std::result::Result<T, Box<dyn std::error::Error + Send + Sync>> {
130    let mut de = Deserializer::new(Cursor::new(buf));
131    match Deserialize::deserialize(&mut de) {
132        Ok(t) => Ok(t),
133        Err(e) => Err(format!("Failed to de-serialize: {}", e).into()),
134    }
135}
wasmcloud_actor_extras/generated.rs

wasmcloud_actor_extras/
generated.rs
