zry-rust-ffi-utils/zry-rust-ffi-utils/src/proc/mod.rs

use crate::bytes_vec::ZRFUBytesVec;
use ciborium::de;
use ciborium::ser;
use once_cell::sync::OnceCell;
use serde::de::DeserializeOwned;
use serde::Serialize;

pub trait ZRFUProcInstanceTrait {
    fn decode_input(&mut self, bv: &mut ZRFUBytesVec) -> ZRFUProcResultCode;
    fn call(&mut self) -> ZRFUProcResultCode;
    fn encode_return(&mut self, bv: &mut ZRFUBytesVec) -> ZRFUProcResultCode;
}

#[derive(Debug, PartialEq)]
pub enum ZRFUProcResultCode {
    Ok,
    NoArgsNeed,
    NoReturnProvided,
    ArgsCBORDecodeError(String),
    CanNotGetArgs,
    ReturnCBOREncodeError(String),
    NoDataToEncodeCBOR,
}

pub struct ZRFUProcArgs<T>
    where T: DeserializeOwned
{
    data: OnceCell<T>,
}

impl<T: DeserializeOwned> ZRFUProcArgs<T> {
    pub fn new() -> ZRFUProcArgs<T> {
        return ZRFUProcArgs{
            data: OnceCell::new(),
        };
    }

    pub fn cbor_deserialize(&self, bv: &mut ZRFUBytesVec) -> ZRFUProcResultCode {
        let res = de::from_reader(bv);
        let val:T = match res {
            Ok(t) => t,
            Err(e) => {
               return  ZRFUProcResultCode::ArgsCBORDecodeError(format!("CBOR Decode Error: {}", e.to_string()));
            },
        };
        let _ = self.data.set(val);
        return  ZRFUProcResultCode::Ok;
    }

    pub fn get_data(&self) -> Option<&T> {
        self.data.get()
    }
}

pub struct ZRFUProcReturn<T>
    where T: Serialize
{
    data: OnceCell<T>,
}

impl<T: Serialize> ZRFUProcReturn<T>{
    pub fn new() -> ZRFUProcReturn<T> {
        return ZRFUProcReturn{
            data: OnceCell::new(),
        };
    }

    pub fn set_data(&self, v: T) {
        let _ = self.data.set(v);
    }

    pub fn cbor_serialize(&self, bv: &mut ZRFUBytesVec) -> ZRFUProcResultCode {
        let v_res = self.data.get();
        let v = match v_res {
            None => {
                return ZRFUProcResultCode::NoDataToEncodeCBOR;
            },
            Some(t) => t,
        };
        let res = ser::into_writer(v, bv);
        match res {
            Ok(t) => t,
            Err(e) => {
                return  ZRFUProcResultCode::ReturnCBOREncodeError(format!("CBOR Encode Error: {}", e.to_string()))
            },
        };
        return ZRFUProcResultCode::Ok;
    }
}