wasmcloud_actor_keyvalue/
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    /// Gets a value for a specified key. If the key doesn't exist, this function will
42    /// not panic, instead the response type will indicate that it does not exist.
43    pub fn get(&self, key: String) -> HandlerResult<GetResponse> {
44        let input_args = GetArgs { key };
45        host_call(
46            &self.binding,
47            "wasmcloud:keyvalue",
48            "Get",
49            &serialize(input_args)?,
50        )
51        .map(|vec| {
52            let resp = deserialize::<GetResponse>(vec.as_ref()).unwrap();
53            resp
54        })
55        .map_err(|e| e.into())
56    }
57    /// Add a given numeric value to a key
58    pub fn add(&self, key: String, value: i32) -> HandlerResult<AddResponse> {
59        let input_args = AddArgs { key, value };
60        host_call(
61            &self.binding,
62            "wasmcloud:keyvalue",
63            "Add",
64            &serialize(input_args)?,
65        )
66        .map(|vec| {
67            let resp = deserialize::<AddResponse>(vec.as_ref()).unwrap();
68            resp
69        })
70        .map_err(|e| e.into())
71    }
72    /// Sets the string value of a key
73    pub fn set(&self, key: String, value: String, expires: i32) -> HandlerResult<SetResponse> {
74        let input_args = SetArgs {
75            key,
76            value,
77            expires,
78        };
79        host_call(
80            &self.binding,
81            "wasmcloud:keyvalue",
82            "Set",
83            &serialize(input_args)?,
84        )
85        .map(|vec| {
86            let resp = deserialize::<SetResponse>(vec.as_ref()).unwrap();
87            resp
88        })
89        .map_err(|e| e.into())
90    }
91    /// Delete a key
92    pub fn del(&self, key: String) -> HandlerResult<DelResponse> {
93        let input_args = DelArgs { key };
94        host_call(
95            &self.binding,
96            "wasmcloud:keyvalue",
97            "Del",
98            &serialize(input_args)?,
99        )
100        .map(|vec| {
101            let resp = deserialize::<DelResponse>(vec.as_ref()).unwrap();
102            resp
103        })
104        .map_err(|e| e.into())
105    }
106    /// Clear a list of its values. Depending on the provider implementation, this may
107    /// delete the list entirely
108    pub fn clear(&self, key: String) -> HandlerResult<DelResponse> {
109        let input_args = ClearArgs { key };
110        host_call(
111            &self.binding,
112            "wasmcloud:keyvalue",
113            "Clear",
114            &serialize(input_args)?,
115        )
116        .map(|vec| {
117            let resp = deserialize::<DelResponse>(vec.as_ref()).unwrap();
118            resp
119        })
120        .map_err(|e| e.into())
121    }
122    /// Retrieve a range of values from a list. Depending on the provider
123    /// implementation, start  and stop may or may not be inclusive.
124    pub fn range(&self, key: String, start: i32, stop: i32) -> HandlerResult<ListRangeResponse> {
125        let input_args = RangeArgs { key, start, stop };
126        host_call(
127            &self.binding,
128            "wasmcloud:keyvalue",
129            "Range",
130            &serialize(input_args)?,
131        )
132        .map(|vec| {
133            let resp = deserialize::<ListRangeResponse>(vec.as_ref()).unwrap();
134            resp
135        })
136        .map_err(|e| e.into())
137    }
138    /// Push a value onto a list
139    pub fn push(&self, key: String, value: String) -> HandlerResult<ListResponse> {
140        let input_args = PushArgs { key, value };
141        host_call(
142            &self.binding,
143            "wasmcloud:keyvalue",
144            "Push",
145            &serialize(input_args)?,
146        )
147        .map(|vec| {
148            let resp = deserialize::<ListResponse>(vec.as_ref()).unwrap();
149            resp
150        })
151        .map_err(|e| e.into())
152    }
153    /// Delete an item from a list
154    pub fn list_item_delete(&self, key: String, value: String) -> HandlerResult<ListResponse> {
155        let input_args = ListItemDeleteArgs { key, value };
156        host_call(
157            &self.binding,
158            "wasmcloud:keyvalue",
159            "ListItemDelete",
160            &serialize(input_args)?,
161        )
162        .map(|vec| {
163            let resp = deserialize::<ListResponse>(vec.as_ref()).unwrap();
164            resp
165        })
166        .map_err(|e| e.into())
167    }
168    /// Add an item into a set
169    pub fn set_add(&self, key: String, value: String) -> HandlerResult<SetOperationResponse> {
170        let input_args = SetAddArgs { key, value };
171        host_call(
172            &self.binding,
173            "wasmcloud:keyvalue",
174            "SetAdd",
175            &serialize(input_args)?,
176        )
177        .map(|vec| {
178            let resp = deserialize::<SetOperationResponse>(vec.as_ref()).unwrap();
179            resp
180        })
181        .map_err(|e| e.into())
182    }
183    /// Remove an item from a set
184    pub fn set_remove(&self, key: String, value: String) -> HandlerResult<SetOperationResponse> {
185        let input_args = SetRemoveArgs { key, value };
186        host_call(
187            &self.binding,
188            "wasmcloud:keyvalue",
189            "SetRemove",
190            &serialize(input_args)?,
191        )
192        .map(|vec| {
193            let resp = deserialize::<SetOperationResponse>(vec.as_ref()).unwrap();
194            resp
195        })
196        .map_err(|e| e.into())
197    }
198    /// Perform and return a set union on a given list of keys
199    pub fn set_union(&self, keys: Vec<String>) -> HandlerResult<SetQueryResponse> {
200        let input_args = SetUnionArgs { keys };
201        host_call(
202            &self.binding,
203            "wasmcloud:keyvalue",
204            "SetUnion",
205            &serialize(input_args)?,
206        )
207        .map(|vec| {
208            let resp = deserialize::<SetQueryResponse>(vec.as_ref()).unwrap();
209            resp
210        })
211        .map_err(|e| e.into())
212    }
213    /// Perform and return a set intersect on a given list of keys
214    pub fn set_intersection(&self, keys: Vec<String>) -> HandlerResult<SetQueryResponse> {
215        let input_args = SetIntersectionArgs { keys };
216        host_call(
217            &self.binding,
218            "wasmcloud:keyvalue",
219            "SetIntersection",
220            &serialize(input_args)?,
221        )
222        .map(|vec| {
223            let resp = deserialize::<SetQueryResponse>(vec.as_ref()).unwrap();
224            resp
225        })
226        .map_err(|e| e.into())
227    }
228    /// Retrieve a list of items stored in a set
229    pub fn set_query(&self, key: String) -> HandlerResult<SetQueryResponse> {
230        let input_args = SetQueryArgs { key };
231        host_call(
232            &self.binding,
233            "wasmcloud:keyvalue",
234            "SetQuery",
235            &serialize(input_args)?,
236        )
237        .map(|vec| {
238            let resp = deserialize::<SetQueryResponse>(vec.as_ref()).unwrap();
239            resp
240        })
241        .map_err(|e| e.into())
242    }
243    /// Indicates if a key exists
244    pub fn key_exists(&self, key: String) -> HandlerResult<GetResponse> {
245        let input_args = KeyExistsArgs { key };
246        host_call(
247            &self.binding,
248            "wasmcloud:keyvalue",
249            "KeyExists",
250            &serialize(input_args)?,
251        )
252        .map(|vec| {
253            let resp = deserialize::<GetResponse>(vec.as_ref()).unwrap();
254            resp
255        })
256        .map_err(|e| e.into())
257    }
258}
259
260#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
261pub struct GetArgs {
262    #[serde(rename = "key")]
263    pub key: String,
264}
265
266#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
267pub struct AddArgs {
268    #[serde(rename = "key")]
269    pub key: String,
270    #[serde(rename = "value")]
271    pub value: i32,
272}
273
274#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
275pub struct SetArgs {
276    #[serde(rename = "key")]
277    pub key: String,
278    #[serde(rename = "value")]
279    pub value: String,
280    #[serde(rename = "expires")]
281    pub expires: i32,
282}
283
284#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
285pub struct DelArgs {
286    #[serde(rename = "key")]
287    pub key: String,
288}
289
290#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
291pub struct ClearArgs {
292    #[serde(rename = "key")]
293    pub key: String,
294}
295
296#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
297pub struct RangeArgs {
298    #[serde(rename = "key")]
299    pub key: String,
300    #[serde(rename = "start")]
301    pub start: i32,
302    #[serde(rename = "stop")]
303    pub stop: i32,
304}
305
306#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
307pub struct PushArgs {
308    #[serde(rename = "key")]
309    pub key: String,
310    #[serde(rename = "value")]
311    pub value: String,
312}
313
314#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
315pub struct ListItemDeleteArgs {
316    #[serde(rename = "key")]
317    pub key: String,
318    #[serde(rename = "value")]
319    pub value: String,
320}
321
322#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
323pub struct SetAddArgs {
324    #[serde(rename = "key")]
325    pub key: String,
326    #[serde(rename = "value")]
327    pub value: String,
328}
329
330#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
331pub struct SetRemoveArgs {
332    #[serde(rename = "key")]
333    pub key: String,
334    #[serde(rename = "value")]
335    pub value: String,
336}
337
338#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
339pub struct SetUnionArgs {
340    #[serde(rename = "keys")]
341    pub keys: Vec<String>,
342}
343
344#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
345pub struct SetIntersectionArgs {
346    #[serde(rename = "keys")]
347    pub keys: Vec<String>,
348}
349
350#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
351pub struct SetQueryArgs {
352    #[serde(rename = "key")]
353    pub key: String,
354}
355
356#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
357pub struct KeyExistsArgs {
358    #[serde(rename = "key")]
359    pub key: String,
360}
361
362/// Response type for Get operations
363#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
364pub struct GetResponse {
365    #[serde(rename = "value")]
366    pub value: String,
367    #[serde(rename = "exists")]
368    pub exists: bool,
369}
370
371/// Response type for Add operations
372#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
373pub struct AddResponse {
374    #[serde(rename = "value")]
375    pub value: i32,
376}
377
378/// Response type for Delete operations
379#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
380pub struct DelResponse {
381    #[serde(rename = "key")]
382    pub key: String,
383}
384
385/// Response type for list range operations
386#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
387pub struct ListRangeResponse {
388    #[serde(rename = "values")]
389    pub values: Vec<String>,
390}
391
392/// Response type for list push operations
393#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
394pub struct ListResponse {
395    #[serde(rename = "newCount")]
396    pub new_count: i32,
397}
398
399/// Response type for the Set operation, not to be confused with the set data
400/// structure
401#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
402pub struct SetResponse {
403    #[serde(rename = "value")]
404    pub value: String,
405}
406
407/// Response type for set add operations
408#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
409pub struct SetOperationResponse {
410    #[serde(rename = "new_count")]
411    pub new_count: i32,
412}
413
414/// Response type for set query operations
415#[derive(Debug, PartialEq, Deserialize, Serialize, Default, Clone)]
416pub struct SetQueryResponse {
417    #[serde(rename = "values")]
418    pub values: Vec<String>,
419}
420
421/// The standard function for serializing codec structs into a format that can be
422/// used for message exchange between actor and host. Use of any other function to
423/// serialize could result in breaking incompatibilities.
424pub fn serialize<T>(
425    item: T,
426) -> ::std::result::Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>>
427where
428    T: Serialize,
429{
430    let mut buf = Vec::new();
431    item.serialize(&mut Serializer::new(&mut buf).with_struct_map())?;
432    Ok(buf)
433}
434
435/// The standard function for de-serializing codec structs from a format suitable
436/// for message exchange between actor and host. Use of any other function to
437/// deserialize could result in breaking incompatibilities.
438pub fn deserialize<'de, T: Deserialize<'de>>(
439    buf: &[u8],
440) -> ::std::result::Result<T, Box<dyn std::error::Error + Send + Sync>> {
441    let mut de = Deserializer::new(Cursor::new(buf));
442    match Deserialize::deserialize(&mut de) {
443        Ok(t) => Ok(t),
444        Err(e) => Err(format!("Failed to de-serialize: {}", e).into()),
445    }
446}
wasmcloud_actor_keyvalue/generated.rs

wasmcloud_actor_keyvalue/
generated.rs
