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

use concurrent_hashmap::{ ConcHashMap };
use libc::c_int;
use crate::bytes_vec::ZRFUBytesVec;
use crate::errno::{ZRFUErrBehavior, ZRFUErrNo, ZRFUErrPrefix};
use once_cell::sync::OnceCell;
use crate::proc::{ZRFUProcInstanceTrait, ZRFUProcResultCode};
use std::boxed::Box;
use ciborium::de;

struct ProcCaller {
    proc_registry: ConcHashMap<String, ProcEntity>,
}

impl ProcCaller {
    fn new() -> Self {
        ProcCaller{
            proc_registry: ConcHashMap::<String, ProcEntity>::new(),
        }
    }

    fn do_with_proc<F, R>(&self, name: &String, callback: F) -> Result<R, ZRFUErrNo>
    where
        F: FnOnce(&ProcEntity) -> Result<R, ZRFUErrNo>,
    {
        let find_res = self.proc_registry.find(name);
        let pe = match find_res {
            None => { return Result::Err(ZRFUErrBehavior::ProcNotFound.to_errno(ZRFUErrPrefix::ProcCallBasic)); },
            Some(t) => {
                t.get()
            },
        };
        callback(pe)
    }
}

pub trait  ProcCallerLibSide {
    fn register_proc(&self, name: String, factory_func: fn(name: String) -> Box<dyn ZRFUProcInstanceTrait>);
}

impl ProcCallerLibSide for ProcCaller{
    fn register_proc(&self, name: String, factory_func: fn(name: String) -> Box<dyn ZRFUProcInstanceTrait>) {
        let pe = ProcEntity{
            name: name.clone(),
            factory: factory_func,
        };
        self.proc_registry.insert(name, pe);
    }
}

struct ProcEntity {
    name: String,
    factory: fn(name: String) -> Box<dyn ZRFUProcInstanceTrait>,
}

static PROC_CALLER: OnceCell<ProcCaller> = OnceCell::new();

extern "C" {
    fn LibWithZRFU_Init(caller: &dyn ProcCallerLibSide);
}

#[no_mangle]
pub extern fn ZRFU_Proc_Init() -> c_int {
    let opc = PROC_CALLER.get();
    match opc {
        Some(_) => {return ZRFUErrNo::ProcCaller_ProcCallerRepeatlyInit.get_return_code(); },
        None => (),
    };
    let pcls = ProcCaller::new();
    unsafe { LibWithZRFU_Init(&pcls as &dyn ProcCallerLibSide); }
    let _ = PROC_CALLER.set(pcls);
    return 0;
}

#[no_mangle]
pub extern fn ZRFU_Proc_Call(name_hptr: *const u64, in_hptr: *const u64, out_hptr: *const u64) -> c_int {
    if name_hptr.is_null() {
        return ZRFUErrNo::ProcCallBasic_NullPointerHandle.get_return_code();
    }
    let name_h = unsafe{ name_hptr.read() };
    let name_res:Result<String, ZRFUErrBehavior> = ZRFUBytesVec::do_with_mut_object(name_h, |bv| {
        let res = de::from_reader(bv);
        match res {
            Ok(t) => Result::Ok(t),
            Err(e) => Result::Err(
                    ZRFUErrBehavior::CBORDecodeError
                        .with_complex_error(format!("CBOR Decode Error in ProcName Decoding: {:?}", e).as_str())
                ),

        }
    });
    let proc_name:String = match name_res {
        Ok(t) => t,
        Err(e) => {
            return e.to_errno(ZRFUErrPrefix::ProcCallBasic).get_return_code();
        },
    };
    //println!("ProcCall Test: ProcName={}", proc_name.as_str());
    let pc_opt= PROC_CALLER.get();
    let pc = match pc_opt {
        None => {
            return ZRFUErrNo::ProcCaller_ProcCallerNotInit.get_return_code();
        },
        Some(t) => t,
    };
    let proc_find_res = pc.do_with_proc(&proc_name, |pe| {
        let has_input = !in_hptr.is_null();
        let has_return = !out_hptr.is_null();
        let mut proc_inst = (pe.factory)(pe.name.clone());
        if has_input {
            let h = unsafe{ in_hptr.read() };
            let input_dec_res = ZRFUBytesVec::do_with_mut_object(h, |bv| {
                let res = proc_inst.decode_input(bv);
                if res != ZRFUProcResultCode::Ok {
                    Result::Err(ZRFUErrBehavior::from(res))
                }else{
                    Result::Ok(())
                }
            });
            match input_dec_res {
                Ok(_) => (),
                Err(e) => { return Result::Err(e.to_errno(ZRFUErrPrefix::ProcCallInput)); },
            }
        };
        let call_res = proc_inst.call();
        if call_res != ZRFUProcResultCode::Ok {
            return Result::Err(ZRFUErrBehavior::from(call_res).to_errno(ZRFUErrPrefix::ProcCalling))
        }
        if has_return {
            let h = unsafe{ out_hptr.read() };
            let return_enc_res = ZRFUBytesVec::do_with_mut_object(h, |bv| {
                let res = proc_inst.encode_return(bv);
                if res != ZRFUProcResultCode::Ok {
                    Result::Err(ZRFUErrBehavior::from(res))
                }else{
                    Result::Ok(())
                }
            });
            match return_enc_res {
                Ok(_) => (),
                Err(e) => { return Result::Err(e.to_errno(ZRFUErrPrefix::ProcCallReturn)); },
            }
        }
        return Result::Ok(());
    });
    let proc_res:c_int = match proc_find_res {
        Err(e) => {
            return e.get_return_code();
        },
        Ok(_) => 0,
    };
    proc_res
    /*
    if in_hptr.is_null() {
        return ZRFUErrNo::ProcCallInput_NullPointerHandle.get_return_code();
    }
    let in_h = unsafe { in_hptr.read() };
    let in_res = ZRFUBytesVec::do_with_object(in_h, |bv| {

    });
     */
}