callback_cpp_rust.rs

#![recursion_limit = "512"]
use cpp::cpp;
use cpp::cpp_class;
use std::ffi::{CString, CStr};
use std::os::raw::c_char;

cpp!{{
    #include <iostream>
    #include "src/Test.cpp"
    using std::string;

    #include <iostream>

    class IEvents {
    public:
        virtual void eventOne() = 0;
    };

    class Engine {
    public:
        Engine(IEvents * events) {
            _events = events;
        }
        void fire() {
            _events->eventOne();
        }
    private:
        IEvents* _events;
    };

    class Sdk {
    public:
        Sdk(IEvents * events) {
            _engine = new Engine(events);
            _a = 10;
        }
        
        void setA(int a) {
            _a = a;
            _engine->fire();
        }

        int A() {
            return _a;
        }

    private:
        int _a;
        Engine* _engine;
    };

    struct CallbackPtr { void *a,*b; };
        
    class SdkEvents : public IEvents {
        public:
        CallbackPtr callback;
        virtual void eventOne() {
            rust!(EventOneImpl [callback : &mut dyn CallbackTrait as "CallbackPtr"] {
                callback.event_one(10)
            });
        }
    };
}}

pub trait CallbackTrait {
    fn event_one(&mut self, n: u32);
}

pub struct Sdk {
    pub rawptr: *mut u32,
}

pub struct Events {
    pub rawptr: *mut u32,
    callback: Box<dyn FnMut(u32)>,
}

impl CallbackTrait for Events {
    fn event_one(&mut self, n: u32) {
        (self.callback)(n);
    }
}

impl Events {
    pub fn new(callback: impl FnMut(u32) + 'static) -> Self {
        let rawptr = unsafe {
            cpp!([] -> *mut u32  as "IEvents*" {
                return new SdkEvents();
            })
        };

        Events {
            rawptr,
            callback: Box::new(callback)
        }
    }

    pub fn callback(&self) {
        let inst_ptr: &dyn CallbackTrait = self as &dyn CallbackTrait;    
        let rawptr = self.rawptr;
        unsafe {
            cpp!([  rawptr as "SdkEvents*",
                    inst_ptr as "CallbackPtr"] {
                rawptr->callback = inst_ptr;
            })
        } 
    }
    // pub fn set_callback(&mut self, callback: impl FnMut() + 'static) {
    //     self.callback = Some(Box::new(callback));
    // }
}

impl Sdk {
    pub fn new(events: &Events) -> Self {
        let rawptr = unsafe {
            let p = events.rawptr;
            cpp!([p as "IEvents*"] -> *mut u32  as "Sdk*" {
                return new Sdk(p);
            })
        };

        events.callback();

        Sdk {
            rawptr,
        }
    }

    pub fn set_a(&mut self, v: u32) {
        let me = self.rawptr;
        unsafe {
            cpp!([  me as "Sdk*",
                    v as "int"] {
                me->setA(v);
            })
        }    
    }

    pub fn a(&self) -> u32 {
        let me = self.rawptr;
        unsafe {
            cpp!([me as "Sdk*"] -> u32 as "int" {
                return me->A();
            })
        }
    } 
}

fn main() {
    
    let c = |n| {
        println!("callback -> {}", n);
    };
     
    let mut events = Events::new(c);
    let mut sdk = Sdk::new(&events);
    sdk.set_a(10);
}