marrub
/
rust-qt-binding-generator
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove QVariant and Variant from rust code

master
Jos van den Oever 2017-08-13 00:00:48 +02:00
parent 7707f28ee7
commit 4f39f27200
14 changed files with 54 additions and 672 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
demo/rust/src/implementation.rs
View File

@ -43,12 +43,11 @@ impl DirEntry {
}
impl Item for DirEntry {
fn data(&self, role: c_int) -> Variant {
if role != 0 {
return Variant::None;
}
let str = self.name.to_string_lossy().to_string();
Variant::from(str)
fn file_name(&self) -> String {
self.name.to_string_lossy().to_string()
}
fn file_permissions(&self) -> c_int {
42
}
fn retrieve(&self, parents: Vec<&DirEntry>) -> Vec<DirEntry> {
let path: PathBuf = parents.into_iter().map(|e| &e.name).collect();
@ -72,7 +71,8 @@ impl Default for DirEntry {
pub trait Item: Default {
fn retrieve(&self, parents: Vec<&Self>) -> Vec<Self>;
fn data(&self, role: c_int) -> Variant;
fn file_name(&self) -> String;
fn file_permissions(&self) -> c_int;
}
pub type RItemModel = RGeneralItemModel<DirEntry>;
@ -90,10 +90,9 @@ pub struct RGeneralItemModel<T: Item> {
}
impl<T: Item> RGeneralItemModel<T> {
fn get(&mut self, index: &QModelIndex) -> usize {
let p = if index.is_valid() {
let row = index.row() as usize;
self.entries[index.id() as usize].children.as_ref().unwrap()[row]
fn get(&mut self, row: c_int, parent: usize) -> usize {
let p = if parent > 0 {
self.entries[parent].children.as_ref().unwrap()[row as usize]
} else {
1
};
@ -161,11 +160,11 @@ impl<T: Item> RItemModelTrait<T> for RGeneralItemModel<T> {
2
}
fn row_count(&mut self, parent: QModelIndex) -> c_int {
let i = self.get(&parent);
let i = self.get(parent.row(), parent.id());
self.entries[i].children.as_ref().unwrap().len() as i32
}
fn index(&mut self, row: i32, column: i32, parent: QModelIndex) -> QModelIndex {
QModelIndex::create(row, column, self.get(&parent))
QModelIndex::create(row, column, self.get(parent.row(), parent.id()))
}
fn parent(&self, index: QModelIndex) -> QModelIndex {
if !index.is_valid() || index.id() == 1 {
@ -174,12 +173,12 @@ impl<T: Item> RItemModelTrait<T> for RGeneralItemModel<T> {
let e = &self.entries[index.id()];
QModelIndex::create(e.row as i32, 0, e.parent)
}
fn data(&mut self, index: QModelIndex, role: c_int) -> Variant {
let i = self.get(&index);
if index.column() == 0 {
self.entries[i].data.data(role)
} else {
Variant::Bool(true)
}
fn file_name(&mut self, row: c_int, parent: usize) -> String {
let i = self.get(row, parent);
self.entries[i].data.file_name()
}
fn file_permissions(&mut self, row: c_int, parent: usize) -> c_int {
let i = self.get(row,parent);
self.entries[i].data.file_permissions()
}
}

22
demo/rust/src/interface.rs
View File

@ -88,7 +88,8 @@ pub trait RItemModelTrait<T> {
fn row_count(&mut self, parent: QModelIndex) -> c_int;
fn index(&mut self, row: c_int, column: c_int, parent: QModelIndex) -> QModelIndex;
fn parent(&self, index: QModelIndex) -> QModelIndex;
fn data(&mut self, index: QModelIndex, role: c_int) -> Variant;
fn file_name(&mut self, row: c_int, parent: usize) -> String;
fn file_permissions(&mut self, row: c_int, parent: usize) -> c_int;
}
#[no_mangle]
@ -135,11 +136,16 @@ pub unsafe extern "C" fn ritemmodel_parent(ptr: *const RItemModel,
}
#[no_mangle]
pub unsafe extern "C" fn ritemmodel_data(ptr: *mut RItemModel,
index: QModelIndex,
role: c_int,
d: *mut c_void,
set: fn(*mut c_void, &QVariant)) {
let data = (&mut *ptr).data(index, role);
set(d, &QVariant::from(&data));
pub unsafe extern "C" fn ritemmodel_data_file_name(ptr: *mut RItemModel,
row: c_int, parent: usize,
d: *mut c_void,
set: fn(*mut c_void, QString)) {
let data = (&mut *ptr).file_name(row, parent);
set(d, QString::from(&data));
}
#[no_mangle]
pub unsafe extern "C" fn ritemmodel_data_file_permissions(ptr: *mut RItemModel,
row: c_int, parent: usize) -> c_int {
(&mut *ptr).file_permissions(row, parent)
}

6
demo/rust/src/testimplementation.rs
View File

@ -81,12 +81,12 @@ impl DirectoryTrait for Directory {
Vec::new()
}
fn file_path(&self, row: c_int) -> String {
String::from("file_path")
String::new()
}
fn file_name(&self, row: c_int) -> String {
String::from("file_name")
String::new()
}
fn file_permissions(&self, row: c_int) -> c_int {
row
0
}
}

120
demo/rust/src/types.rs
View File

@ -2,8 +2,6 @@
#![allow(dead_code)]
use std::slice;
use libc::{c_int, uint8_t, uint16_t};
use std::ptr::null;
use std::marker::PhantomData;
#[repr(C)]
pub struct QString {
@ -55,123 +53,6 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
}
}
#[derive(Clone)]
pub enum Variant {
None,
Bool(bool),
Int(c_int),
String(String),
ByteArray(Vec<u8>),
}
impl From<bool> for Variant {
fn from(value: bool) -> Variant {
Variant::Bool(value)
}
}
impl From<String> for Variant {
fn from(value: String) -> Variant {
Variant::String(value)
}
}
/* values from qvariant.h and qmetatype.h */
#[repr(u32)]
#[derive(Clone, Copy)]
enum VariantType {
Invalid = 0,
Bool = 1,
Int = 2,
String = 10,
ByteArray = 12,
}
#[repr(C)]
pub struct QVariant<'a> {
type_: VariantType,
value: c_int,
data: *const uint8_t,
phantom: PhantomData<&'a u8>,
}
impl<'a> QVariant<'a> {
pub fn type_(&self) -> u32 {
self.type_ as u32
}
pub fn convert(&self) -> Variant {
match self.type_ {
VariantType::Bool => {
Variant::Bool(self.value != 0)
},
VariantType::Int => {
Variant::Int(self.value)
},
VariantType::String => {
let data = unsafe {
let d = self.data as *const uint16_t;
slice::from_raw_parts(d, self.value as usize)
};
Variant::String(String::from_utf16_lossy(data))
}
VariantType::ByteArray => {
let data = unsafe {
slice::from_raw_parts(self.data, self.value as usize)
};
Variant::ByteArray(Vec::from(data))
}
_ => Variant::None
}
}
}
impl<'a> From<&'a Variant> for QVariant<'a> {
fn from(variant: &'a Variant) -> QVariant {
match *variant {
Variant::None => {
QVariant {
data: null(),
value: 0,
type_: VariantType::Invalid,
phantom: PhantomData,
}
}
Variant::Bool(v) => {
QVariant {
data: null(),
value: v as c_int,
type_: VariantType::Bool,
phantom: PhantomData,
}
}
Variant::Int(v) => {
QVariant {
data: null(),
value: v,
type_: VariantType::Int,
phantom: PhantomData,
}
}
Variant::String(ref v) => {
QVariant {
data: v.as_ptr(),
value: v.len() as c_int,
type_: VariantType::String,
phantom: PhantomData,
}
}
Variant::ByteArray(ref v) => {
QVariant {
data: v.as_ptr(),
value: v.len() as c_int,
type_: VariantType::ByteArray,
phantom: PhantomData,
}
}
}
}
}
#[repr(C)]
pub struct QModelIndex {
row: c_int,
@ -215,4 +96,3 @@ impl QModelIndex {
}
}

51
demo/src/DemoObject.cpp
View File

@ -30,38 +30,12 @@ namespace {
qmodelindex_t(const QModelIndex& m):
row(m.row()), column(m.column()), id(m.internalId()) {}
};
struct qvariant_t {
unsigned int type;
int value;
const char* data;
};
QVariant variant(const qvariant_t& v) {
switch (v.type) {
case QVariant::Bool: return QVariant((bool)v.value);
case QVariant::String: return QString::fromUtf8(v.data, v.value);
default:;
}
return QVariant();
}
/*
qvariant_t variant(const QVariant& v) {
auto t = v.type();
switch (t) {
case QVariant::Bool:
return { .type = t, .value = { .vbool = 0 } };
case QVariant::ByteArray:
return { .type = t, .value = { .vbool = 0 } };
case QVariant::String:
return { .type = t, .value = { .vbool = 0 } };
default:;
}
return { .type = QVariant::Invalid, .value = { .vbool = false } };
}
*/
}
typedef void (*qvariant_set)(void*, qvariant_t*);
typedef void (*qstring_set)(QString*, qstring_t*);
void set_qstring(QString* v, qstring_t* val) {
*v = *val;
}
extern "C" {
DemoObjectInterface* hello_new(DemoObject*, void (*)(DemoObject*));
@ -75,7 +49,8 @@ extern "C" {
int ritemmodel_row_count(RItemModelInterface*, qmodelindex_t parent);
qmodelindex_t ritemmodel_index(RItemModelInterface*, int row, int column, qmodelindex_t parent);
qmodelindex_t ritemmodel_parent(RItemModelInterface*, qmodelindex_t);
void ritemmodel_data(RItemModelInterface*, qmodelindex_t, int, QVariant*, qvariant_set);
void ritemmodel_data_file_name(RItemModelInterface*, int, quintptr, QString*, qstring_set);
int ritemmodel_data_file_permissions(RItemModelInterface*, int, quintptr);
}
DemoObject::DemoObject(QObject *parent):
@ -139,14 +114,18 @@ int RItemModel::rowCount(const QModelIndex &parent) const
return ritemmodel_row_count(d, parent);
}
void set_variant(void* v, qvariant_t* val) {
*static_cast<QVariant*>(v) = variant(*val);
}
QVariant RItemModel::data(const QModelIndex &index, int role) const
{
QVariant v;
ritemmodel_data(d, index, role, &v, set_variant);
if (role == Qt::DisplayRole) {
if (index.column() == 0) {
QString s;
ritemmodel_data_file_name(d, index.row(), index.internalId(), &s, set_qstring);
v = s;
} else if (index.column() == 1) {
v.setValue<int>(ritemmodel_data_file_permissions(d, index.row(), index.internalId()));
}
}
return v;
}
QModelIndex RItemModel::index(int row, int column, const QModelIndex &parent) const

8
demo/src/tmp.cpp
View File

@ -1,6 +1,5 @@
/* generated by rust_qt_binding_generator */
#include "tmp.h"
#include <QModelIndex>
namespace {
struct qbytearray_t {
@ -29,13 +28,6 @@ namespace {
return QString::fromUtf8(static_cast<const char*>(data), len);
}
};
struct qmodelindex_t {
int row;
int column;
uint64_t id;
qmodelindex_t(const QModelIndex& m):
row(m.row()), column(m.column()), id(m.internalId()) {}
};
}
typedef void (*qstring_set)(QString*, qstring_t*);
void set_qstring(QString* v, qstring_t* val) {

1
demo/src/tmp.h
View File

@ -3,7 +3,6 @@
#define TMP_H
#include <QObject>
#include <QVariant>
#include <QAbstractItemModel>
class PersonInterface;

135
rust_qt_binding_generator/rust_qt_binding_generator.cpp
View File

@ -498,7 +498,6 @@ void writeHeader(const Configuration& conf) {
#define %1
#include <QObject>
#include <QVariant>
#include <QAbstractItemModel>
)").arg(guard);
@ -514,7 +513,6 @@ void writeCpp(const Configuration& conf) {
QTextStream cpp(&w.buffer);
cpp << QString(R"(/* generated by rust_qt_binding_generator */
#include "%1"
#include <QModelIndex>
namespace {
struct qbytearray_t {
@ -543,13 +541,6 @@ namespace {
return QString::fromUtf8(static_cast<const char*>(data), len);
}
};
struct qmodelindex_t {
int row;
int column;
uint64_t id;
qmodelindex_t(const QModelIndex& m):
row(m.row()), column(m.column()), id(m.internalId()) {}
};
}
typedef void (*qstring_set)(QString*, qstring_t*);
void set_qstring(QString* v, qstring_t* val) {
@ -861,9 +852,9 @@ void writeRustImplementationObject(QTextStream& r, const Object& o) {
if (o.type == ObjectTypeList) {
r << " fn row_count(&self) -> c_int {\n 10\n }\n";
for (auto role: o.roles) {
r << QString(" fn %1(&self, row: c_int) -> Variant {\n")
.arg(snakeCase(role.name));
r << " Variant::Bool(row > 0)\n";
r << QString(" fn %1(&self, row: c_int) -> %2 {\n")
.arg(snakeCase(role.name), role.type.rustType);
r << " " << role.type.rustTypeInit << "\n";
r << " }\n";
}
}
@ -894,8 +885,6 @@ void writeRustTypes(const Configuration& conf) {
#![allow(dead_code)]
use std::slice;
use libc::{c_int, uint8_t, uint16_t};
use std::ptr::null;
use std::marker::PhantomData;
#[repr(C)]
pub struct QString {
@ -947,123 +936,6 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
}
}
#[derive(Clone)]
pub enum Variant {
None,
Bool(bool),
Int(c_int),
String(String),
ByteArray(Vec<u8>),
}
impl From<bool> for Variant {
fn from(value: bool) -> Variant {
Variant::Bool(value)
}
}
impl From<String> for Variant {
fn from(value: String) -> Variant {
Variant::String(value)
}
}
/* values from qvariant.h and qmetatype.h */
#[repr(u32)]
#[derive(Clone, Copy)]
enum VariantType {
Invalid = 0,
Bool = 1,
Int = 2,
String = 10,
ByteArray = 12,
}
#[repr(C)]
pub struct QVariant<'a> {
type_: VariantType,
value: c_int,
data: *const uint8_t,
phantom: PhantomData<&'a u8>,
}
impl<'a> QVariant<'a> {
pub fn type_(&self) -> u32 {
self.type_ as u32
}
pub fn convert(&self) -> Variant {
match self.type_ {
VariantType::Bool => {
Variant::Bool(self.value != 0)
},
VariantType::Int => {
Variant::Int(self.value)
},
VariantType::String => {
let data = unsafe {
let d = self.data as *const uint16_t;
slice::from_raw_parts(d, self.value as usize)
};
Variant::String(String::from_utf16_lossy(data))
}
VariantType::ByteArray => {
let data = unsafe {
slice::from_raw_parts(self.data, self.value as usize)
};
Variant::ByteArray(Vec::from(data))
}
_ => Variant::None
}
}
}
impl<'a> From<&'a Variant> for QVariant<'a> {
fn from(variant: &'a Variant) -> QVariant {
match *variant {
Variant::None => {
QVariant {
data: null(),
value: 0,
type_: VariantType::Invalid,
phantom: PhantomData,
}
}
Variant::Bool(v) => {
QVariant {
data: null(),
value: v as c_int,
type_: VariantType::Bool,
phantom: PhantomData,
}
}
Variant::Int(v) => {
QVariant {
data: null(),
value: v,
type_: VariantType::Int,
phantom: PhantomData,
}
}
Variant::String(ref v) => {
QVariant {
data: v.as_ptr(),
value: v.len() as c_int,
type_: VariantType::String,
phantom: PhantomData,
}
}
Variant::ByteArray(ref v) => {
QVariant {
data: v.as_ptr(),
value: v.len() as c_int,
type_: VariantType::ByteArray,
phantom: PhantomData,
}
}
}
}
}
#[repr(C)]
pub struct QModelIndex {
row: c_int,
@ -1107,7 +979,6 @@ impl QModelIndex {
}
}
)");
}

163
tests/rust_object/src/types.rs
View File

@ -2,8 +2,6 @@
#![allow(dead_code)]
use std::slice;
use libc::{c_int, uint8_t, uint16_t};
use std::ptr::null;
use std::marker::PhantomData;
#[repr(C)]
pub struct QString {
@ -55,164 +53,3 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
}
}
#[derive(Clone)]
pub enum Variant {
None,
Bool(bool),
Int(c_int),
String(String),
ByteArray(Vec<u8>),
}
impl From<bool> for Variant {
fn from(value: bool) -> Variant {
Variant::Bool(value)
}
}
impl From<String> for Variant {
fn from(value: String) -> Variant {
Variant::String(value)
}
}
/* values from qvariant.h and qmetatype.h */
#[repr(u32)]
#[derive(Clone, Copy)]
enum VariantType {
Invalid = 0,
Bool = 1,
Int = 2,
String = 10,
ByteArray = 12,
}
#[repr(C)]
pub struct QVariant<'a> {
type_: VariantType,
value: c_int,
data: *const uint8_t,
phantom: PhantomData<&'a u8>,
}
impl<'a> QVariant<'a> {
pub fn type_(&self) -> u32 {
self.type_ as u32
}
pub fn convert(&self) -> Variant {
match self.type_ {
VariantType::Bool => {
Variant::Bool(self.value != 0)
},
VariantType::Int => {
Variant::Int(self.value)
},
VariantType::String => {
let data = unsafe {
let d = self.data as *const uint16_t;
slice::from_raw_parts(d, self.value as usize)
};
Variant::String(String::from_utf16_lossy(data))
}
VariantType::ByteArray => {
let data = unsafe {
slice::from_raw_parts(self.data, self.value as usize)
};
Variant::ByteArray(Vec::from(data))
}
_ => Variant::None
}
}
}
impl<'a> From<&'a Variant> for QVariant<'a> {
fn from(variant: &'a Variant) -> QVariant {
match *variant {
Variant::None => {
QVariant {
data: null(),
value: 0,
type_: VariantType::Invalid,
phantom: PhantomData,
}
}
Variant::Bool(v) => {
QVariant {
data: null(),
value: v as c_int,
type_: VariantType::Bool,
phantom: PhantomData,
}
}
Variant::Int(v) => {
QVariant {
data: null(),
value: v,
type_: VariantType::Int,
phantom: PhantomData,
}
}
Variant::String(ref v) => {
QVariant {
data: v.as_ptr(),
value: v.len() as c_int,
type_: VariantType::String,
phantom: PhantomData,
}
}
Variant::ByteArray(ref v) => {
QVariant {
data: v.as_ptr(),
value: v.len() as c_int,
type_: VariantType::ByteArray,
phantom: PhantomData,
}
}
}
}
}
#[repr(C)]
pub struct QModelIndex {
row: c_int,
column: c_int,
internal_id: usize,
}
impl QModelIndex {
pub fn invalid() -> QModelIndex {
QModelIndex {
row: -1,
column: -1,
internal_id: 0,
}
}
pub fn create(row: c_int, column: c_int, id: usize) -> QModelIndex {
QModelIndex {
row: row,
column: column,
internal_id: id,
}
}
pub fn flat(row: c_int, column: c_int) -> QModelIndex {
QModelIndex {
row: row,
column: column,
internal_id: 1,
}
}
pub fn is_valid(&self) -> bool {
self.internal_id != 0 && self.row >= 0 && self.column >= 0
}
pub fn row(&self) -> c_int {
self.row
}
pub fn column(&self) -> c_int {
self.column
}
pub fn id(&self) -> usize {
self.internal_id
}
}

163
tests/rust_object_types/src/types.rs
View File

@ -2,8 +2,6 @@
#![allow(dead_code)]
use std::slice;
use libc::{c_int, uint8_t, uint16_t};
use std::ptr::null;
use std::marker::PhantomData;
#[repr(C)]
pub struct QString {
@ -55,164 +53,3 @@ impl<'a> From<&'a Vec<u8>> for QByteArray {
}
}
#[derive(Clone)]
pub enum Variant {
None,
Bool(bool),
Int(c_int),
String(String),
ByteArray(Vec<u8>),
}
impl From<bool> for Variant {
fn from(value: bool) -> Variant {
Variant::Bool(value)
}
}
impl From<String> for Variant {
fn from(value: String) -> Variant {
Variant::String(value)
}
}
/* values from qvariant.h and qmetatype.h */
#[repr(u32)]
#[derive(Clone, Copy)]
enum VariantType {
Invalid = 0,
Bool = 1,
Int = 2,
String = 10,
ByteArray = 12,
}
#[repr(C)]
pub struct QVariant<'a> {
type_: VariantType,
value: c_int,
data: *const uint8_t,
phantom: PhantomData<&'a u8>,
}
impl<'a> QVariant<'a> {
pub fn type_(&self) -> u32 {
self.type_ as u32
}
pub fn convert(&self) -> Variant {
match self.type_ {
VariantType::Bool => {
Variant::Bool(self.value != 0)
},
VariantType::Int => {
Variant::Int(self.value)
},
VariantType::String => {
let data = unsafe {
let d = self.data as *const uint16_t;
slice::from_raw_parts(d, self.value as usize)
};
Variant::String(String::from_utf16_lossy(data))
}
VariantType::ByteArray => {
let data = unsafe {
slice::from_raw_parts(self.data, self.value as usize)
};
Variant::ByteArray(Vec::from(data))
}
_ => Variant::None
}
}
}
impl<'a> From<&'a Variant> for QVariant<'a> {
fn from(variant: &'a Variant) -> QVariant {
match *variant {
Variant::None => {
QVariant {
data: null(),
value: 0,
type_: VariantType::Invalid,
phantom: PhantomData,
}
}
Variant::Bool(v) => {
QVariant {
data: null(),
value: v as c_int,
type_: VariantType::Bool,
phantom: PhantomData,
}
}
Variant::Int(v) => {
QVariant {
data: null(),
value: v,
type_: VariantType::Int,
phantom: PhantomData,
}
}
Variant::String(ref v) => {
QVariant {
data: v.as_ptr(),
value: v.len() as c_int,
type_: VariantType::String,
phantom: PhantomData,
}
}
Variant::ByteArray(ref v) => {
QVariant {
data: v.as_ptr(),
value: v.len() as c_int,
type_: VariantType::ByteArray,
phantom: PhantomData,
}
}
}
}
}
#[repr(C)]
pub struct QModelIndex {
row: c_int,
column: c_int,
internal_id: usize,
}
impl QModelIndex {
pub fn invalid() -> QModelIndex {
QModelIndex {
row: -1,
column: -1,
internal_id: 0,
}
}
pub fn create(row: c_int, column: c_int, id: usize) -> QModelIndex {
QModelIndex {
row: row,
column: column,
internal_id: id,
}
}
pub fn flat(row: c_int, column: c_int) -> QModelIndex {
QModelIndex {
row: row,
column: column,
internal_id: 1,
}
}
pub fn is_valid(&self) -> bool {
self.internal_id != 0 && self.row >= 0 && self.column >= 0
}
pub fn row(&self) -> c_int {
self.row
}
pub fn column(&self) -> c_int {
self.column
}
pub fn id(&self) -> usize {
self.internal_id
}
}

8
tests/test_object_rust.cpp
View File

@ -1,6 +1,5 @@
/* generated by rust_qt_binding_generator */
#include "test_object_rust.h"
#include <QModelIndex>
namespace {
struct qbytearray_t {
@ -29,13 +28,6 @@ namespace {
return QString::fromUtf8(static_cast<const char*>(data), len);
}
};
struct qmodelindex_t {
int row;
int column;
uint64_t id;
qmodelindex_t(const QModelIndex& m):
row(m.row()), column(m.column()), id(m.internalId()) {}
};
}
typedef void (*qstring_set)(QString*, qstring_t*);
void set_qstring(QString* v, qstring_t* val) {

1
tests/test_object_rust.h
View File

@ -3,7 +3,6 @@
#define TEST_OBJECT_RUST_H
#include <QObject>
#include <QVariant>
#include <QAbstractItemModel>
class PersonInterface;

8
tests/test_object_types_rust.cpp
View File

@ -1,6 +1,5 @@
/* generated by rust_qt_binding_generator */
#include "test_object_types_rust.h"
#include <QModelIndex>
namespace {
struct qbytearray_t {
@ -29,13 +28,6 @@ namespace {
return QString::fromUtf8(static_cast<const char*>(data), len);
}
};
struct qmodelindex_t {
int row;
int column;
uint64_t id;
qmodelindex_t(const QModelIndex& m):
row(m.row()), column(m.column()), id(m.internalId()) {}
};
}
typedef void (*qstring_set)(QString*, qstring_t*);
void set_qstring(QString* v, qstring_t* val) {

1
tests/test_object_types_rust.h
View File

@ -3,7 +3,6 @@
#define TEST_OBJECT_TYPES_RUST_H
#include <QObject>
#include <QVariant>
#include <QAbstractItemModel>
class ObjectInterface;