Instantiating a cxx-qt QObject type on the Rust side

[SanderVocke]

Hi all,

I have the following quite simple cxx-qt Rust object, which works fine when used through QML:

#[cxx_qt::bridge]
pub mod qobject {
    unsafe extern "C++" {
        include!("cxx-qt-lib/qstring.h");
        type QString = cxx_qt_lib::QString;
    }

    unsafe extern "RustQt" {
        #[qobject]
        type OSUtils = super::OSUtilsRust;
    }

    unsafe extern "RustQt" {
        #[qinvokable]
        fn cause_abort(self: &OSUtils);

        #[qinvokable]
        fn cause_panic(self: &OSUtils);

        #[qinvokable]
        fn cause_segfault(self: &OSUtils);

        #[qinvokable]
        fn get_env_var(self: &OSUtils, var: &QString) -> QString;
    }
}

use std::env;
use cxx_qt_lib::QString;

#[derive(Default)]
pub struct OSUtilsRust {}

impl qobject::OSUtils {
    pub fn cause_abort(self: &qobject::OSUtils) {
        println!("OSUtils: triggering abort.");
        std::process::abort();
    }

    pub fn cause_segfault(self: &qobject::OSUtils) {
        println!("OSUtils: triggering segfault.");
        unsafe {
            let ptr: *const i32 = std::ptr::null();
            println!("{}", *ptr);
        }
    }

    pub fn cause_panic(self: &qobject::OSUtils) {
        println!("OSUtils: triggering panic.");
        panic!("");
    }

    pub fn get_env_var(self: &qobject::OSUtils, var: &QString) -> QString {
        match env::var(var.to_string()) {
            Ok (value) => return QString::from(&value),
            Err(_value) => return QString::default(),
        }
    }
}

Now I figured it would be nice to unit-test this class with the "cargo test" approach, because such tests would be faster than QML tests and wouldn't require writing C++:

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_invalid_env_var() {
        let os_utils = OSUtilsRust::default();
        assert!(os_utils.get_env_var(&QString::from("DEADBEEF")).is_null());
    }

    #[test]
    fn test_valid_env_var() {
        let os_utils = OSUtilsRust::default();
        let home = env::var("HOME").unwrap();
        assert_eq!(
            os_utils.get_env_var(&QString::from("HOME")),
            home
        );
    }
}

But running cargo test yields: "method get_env_var not found for this struct".
I have not found a way to directly instantiate a qobject::OSUtils in Rust (there is no Default or new() or {} possible for it).

Is there a way to either instantiate a OSUtils and call get_env_var on it, or somehow call get_env_var on the OSUtilsRust?

[SanderVocke]

Ok, so initially I didn't find any answer but on a closer search I stumbled on:

#694

This suggests there is no solution at the moment except manual solutions such as custom c++ factory functions exposed to rust, but it is a topic being worked on.

Edit: see workaround in the replies to this answer.

[LeonMatthesKDAB]

Hm, you may be able to make this work without writing any C++ if you're using the main branch of our repo. (or wait for 0.7)

cxx-qt-lib/common.h now includes a template for make_unique that allows you to instantiate any type in a unique_ptr:

cxx-qt/crates/cxx-qt-lib/include/common.h

Line 94 in 4ed6351

make_unique(Args... args)

You can use that in your bridge to create a binding to make_unique for your type.

extern "C++" {
    include!("cxx-qt-lib/common.h");

    #[rust_name="make_os_utils"]
    #[namespace="rust::cxxqtlib1"]
    fn make_unique() -> UniquePtr<OsUtils>
}

Then you should be able to call qobject::make_os_utils to get an instance of your qobject.

[SanderVocke]

Thanks @LeonMatthesKDAB. That is exactly the kind of solution I ended up doing, except manually with my own header:

#pragma once

#include <memory>

template<typename T>
inline std::unique_ptr<T> make_unique() {
    return std::make_unique<T>();
}

And then including it as such in the .rs:

unsafe extern "C++" {
        include!("cxx-shoop/make_unique.h");

        #[rust_name = "make_unique_osutils"]
        fn make_unique() -> UniquePtr<OSUtils>;
    }

And in build.rs:

 CxxQtBuilder::new()
        .cc_builder(|cc| {
            cc.include("src/cxx"); // Contains cxx-shoop folder
        })
        (....)

This also seems to work fine in 0.6 with the manual method, so I will keep it until 0.7 is released. Thanks for the quick reply!