886 lines
25 KiB
C++
886 lines
25 KiB
C++
#include "structs.h"
|
|
#include "helper.h"
|
|
|
|
template <typename T>
|
|
QString rustType(const T& p)
|
|
{
|
|
if (p.optional) {
|
|
return "Option<" + p.type.rustType + ">";
|
|
}
|
|
return p.type.rustType;
|
|
}
|
|
|
|
template <typename T>
|
|
QString rustReturnType(const T& p)
|
|
{
|
|
QString type = p.type.rustType;
|
|
if (type == "String" && !p.rustByValue) {
|
|
type = "str";
|
|
}
|
|
if (type == "Vec<u8>" && !p.rustByValue) {
|
|
type = "[u8]";
|
|
}
|
|
if (p.type.isComplex() && !p.rustByValue) {
|
|
type = "&" + type;
|
|
}
|
|
if (p.optional) {
|
|
return "Option<" + type + ">";
|
|
}
|
|
return type;
|
|
}
|
|
|
|
template <typename T>
|
|
QString rustCType(const T& p)
|
|
{
|
|
if (p.optional) {
|
|
return "COption<" + p.type.rustType + ">";
|
|
}
|
|
return p.type.rustType;
|
|
}
|
|
|
|
template <typename T>
|
|
QString rustTypeInit(const T& p)
|
|
{
|
|
if (p.optional) {
|
|
return "None";
|
|
}
|
|
return p.type.rustTypeInit;
|
|
}
|
|
|
|
void rConstructorArgsDecl(QTextStream& r, const QString& name, const Object& o, const Configuration& conf) {
|
|
r << QString(" %2: *mut %1QObject").arg(o.name, snakeCase(name));
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
r << QString(",\n");
|
|
rConstructorArgsDecl(r, p.name, conf.findObject(p.type.name), conf);
|
|
} else {
|
|
r << QString(",\n %2_changed: fn(*const %1QObject)")
|
|
.arg(o.name, snakeCase(p.name));
|
|
}
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
r << QString(",\n %2_new_data_ready: fn(*const %1QObject)")
|
|
.arg(o.name, snakeCase(o.name));
|
|
} else if (o.type == ObjectType::Tree) {
|
|
r << QString(",\n %2_new_data_ready: fn(*const %1QObject, item: usize, valid: bool)")
|
|
.arg(o.name, snakeCase(o.name));
|
|
}
|
|
if (o.type != ObjectType::Object) {
|
|
QString indexDecl;
|
|
if (o.type == ObjectType::Tree) {
|
|
indexDecl = " item: usize, valid: bool,";
|
|
}
|
|
r << QString(R"(,
|
|
%3_data_changed: fn(*const %1QObject, usize, usize),
|
|
%3_begin_reset_model: fn(*const %1QObject),
|
|
%3_end_reset_model: fn(*const %1QObject),
|
|
%3_begin_insert_rows: fn(*const %1QObject,%2 usize, usize),
|
|
%3_end_insert_rows: fn(*const %1QObject),
|
|
%3_begin_remove_rows: fn(*const %1QObject,%2 usize, usize),
|
|
%3_end_remove_rows: fn(*const %1QObject))").arg(o.name, indexDecl,
|
|
snakeCase(o.name));
|
|
}
|
|
}
|
|
|
|
void rConstructorArgs(QTextStream& r, const QString& name, const Object& o, const Configuration& conf) {
|
|
const QString lcname(snakeCase(o.name));
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
rConstructorArgs(r, p.name, conf.findObject(p.type.name), conf);
|
|
}
|
|
}
|
|
r << QString(R"( let %2_emit = %1Emitter {
|
|
qobject: Arc::new(Mutex::new(%2)),
|
|
)").arg(o.name, snakeCase(name));
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) continue;
|
|
r << QString(" %1_changed: %1_changed,\n").arg(snakeCase(p.name));
|
|
}
|
|
if (o.type != ObjectType::Object) {
|
|
r << QString(" new_data_ready: %1_new_data_ready,\n")
|
|
.arg(snakeCase(o.name));
|
|
}
|
|
QString model = "";
|
|
if (o.type != ObjectType::Object) {
|
|
const QString type = o.type == ObjectType::List ? "List" : "Tree";
|
|
model = ", model";
|
|
r << QString(R"( };
|
|
let model = %1%2 {
|
|
qobject: %3,
|
|
data_changed: %4_data_changed,
|
|
begin_reset_model: %4_begin_reset_model,
|
|
end_reset_model: %4_end_reset_model,
|
|
begin_insert_rows: %4_begin_insert_rows,
|
|
end_insert_rows: %4_end_insert_rows,
|
|
begin_remove_rows: %4_begin_remove_rows,
|
|
end_remove_rows: %4_end_remove_rows,
|
|
)").arg(o.name, type, snakeCase(name), snakeCase(o.name));
|
|
}
|
|
r << QString(" };\n let d_%3 = %1::create(%3_emit%2")
|
|
.arg(o.name, model, snakeCase(name));
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
r << ",\n d_" << snakeCase(p.name);
|
|
}
|
|
}
|
|
r << ");\n";
|
|
}
|
|
|
|
void writeRustInterfaceObject(QTextStream& r, const Object& o, const Configuration& conf) {
|
|
const QString lcname(snakeCase(o.name));
|
|
r << QString(R"(
|
|
pub struct %1QObject {}
|
|
|
|
#[derive(Clone)]
|
|
pub struct %1Emitter {
|
|
qobject: Arc<Mutex<*const %1QObject>>,
|
|
)").arg(o.name);
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
continue;
|
|
}
|
|
r << QString(" %2_changed: fn(*const %1QObject),\n")
|
|
.arg(o.name, snakeCase(p.name));
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
r << QString(" new_data_ready: fn(*const %1QObject),\n")
|
|
.arg(o.name);
|
|
} else if (o.type == ObjectType::Tree) {
|
|
r << QString(" new_data_ready: fn(*const %1QObject, item: usize, valid: bool),\n")
|
|
.arg(o.name);
|
|
}
|
|
r << QString(R"(}
|
|
|
|
unsafe impl Send for %1Emitter {}
|
|
|
|
impl %1Emitter {
|
|
fn clear(&self) {
|
|
*self.qobject.lock().unwrap() = null();
|
|
}
|
|
)").arg(o.name);
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
continue;
|
|
}
|
|
r << QString(R"( pub fn %1_changed(&self) {
|
|
let ptr = *self.qobject.lock().unwrap();
|
|
if !ptr.is_null() {
|
|
(self.%1_changed)(ptr);
|
|
}
|
|
}
|
|
)").arg(snakeCase(p.name));
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
r << R"( pub fn new_data_ready(&self) {
|
|
let ptr = *self.qobject.lock().unwrap();
|
|
if !ptr.is_null() {
|
|
(self.new_data_ready)(ptr);
|
|
}
|
|
}
|
|
)";
|
|
} else if (o.type == ObjectType::Tree) {
|
|
r << R"( pub fn new_data_ready(&self, item: Option<usize>) {
|
|
let ptr = *self.qobject.lock().unwrap();
|
|
if !ptr.is_null() {
|
|
(self.new_data_ready)(ptr, item.unwrap_or(13), item.is_some());
|
|
}
|
|
}
|
|
)";
|
|
}
|
|
|
|
QString modelStruct = "";
|
|
if (o.type != ObjectType::Object) {
|
|
QString type = o.type == ObjectType::List ? "List" : "Tree";
|
|
modelStruct = ", model: " + o.name + type;
|
|
QString index;
|
|
QString indexDecl;
|
|
QString indexCDecl;
|
|
if (o.type == ObjectType::Tree) {
|
|
indexDecl = " item: Option<usize>,";
|
|
indexCDecl = " item: usize, valid: bool,";
|
|
index = " item.unwrap_or(13), item.is_some(),";
|
|
}
|
|
r << QString(R"(}
|
|
|
|
pub struct %1%2 {
|
|
qobject: *const %1QObject,
|
|
data_changed: fn(*const %1QObject, usize, usize),
|
|
begin_reset_model: fn(*const %1QObject),
|
|
end_reset_model: fn(*const %1QObject),
|
|
begin_insert_rows: fn(*const %1QObject,%5 usize, usize),
|
|
end_insert_rows: fn(*const %1QObject),
|
|
begin_remove_rows: fn(*const %1QObject,%5 usize, usize),
|
|
end_remove_rows: fn(*const %1QObject),
|
|
}
|
|
|
|
impl %1%2 {
|
|
pub fn data_changed(&self, first: usize, last: usize) {
|
|
(self.data_changed)(self.qobject, first, last);
|
|
}
|
|
pub fn begin_reset_model(&self) {
|
|
(self.begin_reset_model)(self.qobject);
|
|
}
|
|
pub fn end_reset_model(&self) {
|
|
(self.end_reset_model)(self.qobject);
|
|
}
|
|
pub fn begin_insert_rows(&self,%3 first: usize, last: usize) {
|
|
(self.begin_insert_rows)(self.qobject,%4 first, last);
|
|
}
|
|
pub fn end_insert_rows(&self) {
|
|
(self.end_insert_rows)(self.qobject);
|
|
}
|
|
pub fn begin_remove_rows(&self,%3 first: usize, last: usize) {
|
|
(self.begin_remove_rows)(self.qobject,%4 first, last);
|
|
}
|
|
pub fn end_remove_rows(&self) {
|
|
(self.end_remove_rows)(self.qobject);
|
|
}
|
|
)").arg(o.name, type, indexDecl, index, indexCDecl);
|
|
}
|
|
|
|
r << QString(R"(}
|
|
|
|
pub trait %1Trait {
|
|
fn create(emit: %1Emitter%2)").arg(o.name, modelStruct);
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
r << ",\n " << snakeCase(p.name) << ": " << p.type.name;
|
|
}
|
|
}
|
|
r << QString(R"() -> Self;
|
|
fn emit(&self) -> &%1Emitter;
|
|
)").arg(o.name);
|
|
for (const Property& p: o.properties) {
|
|
const QString lc(snakeCase(p.name));
|
|
if (p.type.type == BindingType::Object) {
|
|
r << QString(" fn %1(&self) -> &%2;\n").arg(lc, rustType(p));
|
|
r << QString(" fn %1_mut(&mut self) -> &mut %2;\n").arg(lc, rustType(p));
|
|
} else {
|
|
r << QString(" fn %1(&self) -> %2;\n").arg(lc, rustReturnType(p));
|
|
if (p.write) {
|
|
r << QString(" fn set_%1(&mut self, value: %2);\n").arg(lc, rustType(p));
|
|
}
|
|
}
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
r << R"( fn row_count(&self) -> usize;
|
|
fn can_fetch_more(&self) -> bool {
|
|
false
|
|
}
|
|
fn fetch_more(&mut self) {}
|
|
fn sort(&mut self, u8, SortOrder) {}
|
|
)";
|
|
} else if (o.type == ObjectType::Tree) {
|
|
r << R"( fn row_count(&self, Option<usize>) -> usize;
|
|
fn can_fetch_more(&self, Option<usize>) -> bool {
|
|
false
|
|
}
|
|
fn fetch_more(&mut self, Option<usize>) {}
|
|
fn sort(&mut self, u8, SortOrder) {}
|
|
fn index(&self, item: Option<usize>, row: usize) -> usize;
|
|
fn parent(&self, item: usize) -> Option<usize>;
|
|
fn row(&self, item: usize) -> usize;
|
|
)";
|
|
}
|
|
if (o.type != ObjectType::Object) {
|
|
for (auto ip: o.itemProperties) {
|
|
r << QString(" fn %1(&self, item: usize) -> %2;\n")
|
|
.arg(snakeCase(ip.name), rustReturnType(ip));
|
|
if (ip.write) {
|
|
r << QString(" fn set_%1(&mut self, item: usize, %2) -> bool;\n")
|
|
.arg(snakeCase(ip.name), rustType(ip));
|
|
}
|
|
}
|
|
}
|
|
|
|
r << QString(R"(}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn %1_new(
|
|
)").arg(lcname);
|
|
rConstructorArgsDecl(r, lcname, o, conf);
|
|
r << QString(",\n) -> *mut %1 {\n").arg(o.name);
|
|
rConstructorArgs(r, lcname, o, conf);
|
|
r << QString(R"( Box::into_raw(Box::new(d_%2))
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_free(ptr: *mut %1) {
|
|
Box::from_raw(ptr).emit().clear();
|
|
}
|
|
)").arg(o.name, lcname);
|
|
for (const Property& p: o.properties) {
|
|
const QString base = QString("%1_%2").arg(lcname, snakeCase(p.name));
|
|
QString ret = ") -> " + rustType(p);
|
|
if (p.type.type == BindingType::Object) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_get(ptr: *mut %1) -> *mut %4 {
|
|
(&mut *ptr).%3_mut()
|
|
}
|
|
)").arg(o.name, base, snakeCase(p.name), rustType(p));
|
|
|
|
} else if (p.type.isComplex() && !p.optional) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_get(
|
|
ptr: *const %1,
|
|
p: *mut c_void,
|
|
set: fn(*mut c_void, %4),
|
|
) {
|
|
let data = (&*ptr).%3();
|
|
set(p, %5data.into());
|
|
}
|
|
)").arg(o.name, base, snakeCase(p.name), p.type.name,
|
|
p.rustByValue ?"&" :"");
|
|
if (p.write) {
|
|
const QString type = p.type.name == "QString" ? "QStringIn" : p.type.name;
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_set(ptr: *mut %1, v: %4) {
|
|
(&mut *ptr).set_%3(v.convert());
|
|
}
|
|
)").arg(o.name, base, snakeCase(p.name), type);
|
|
}
|
|
} else if (p.type.isComplex()) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_get(
|
|
ptr: *const %1,
|
|
p: *mut c_void,
|
|
set: fn(*mut c_void, %4),
|
|
) {
|
|
let data = (&*ptr).%3();
|
|
if let Some(data) = data {
|
|
set(p, %5data.into());
|
|
}
|
|
}
|
|
)").arg(o.name, base, snakeCase(p.name), p.type.name,
|
|
p.rustByValue ?"&" :"");
|
|
if (p.write) {
|
|
const QString type = p.type.name == "QString" ? "QStringIn" : p.type.name;
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_set(ptr: *mut %1, v: %4) {
|
|
(&mut *ptr).set_%3(Some(v.convert()));
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_set_none(ptr: *mut %1) {
|
|
(&mut *ptr).set_%3(None);
|
|
}
|
|
)").arg(o.name, base, snakeCase(p.name), type);
|
|
}
|
|
} else {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_get(ptr: *const %1) -> %4 {
|
|
(&*ptr).%3()
|
|
}
|
|
)").arg(o.name, base, snakeCase(p.name), rustType(p));
|
|
if (p.write) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_set(ptr: *mut %1, v: %4) {
|
|
(&mut *ptr).set_%3(v);
|
|
}
|
|
)").arg(o.name, base, snakeCase(p.name), rustType(p));
|
|
}
|
|
}
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_row_count(ptr: *const %1) -> c_int {
|
|
(&*ptr).row_count() as c_int
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_can_fetch_more(ptr: *const %1) -> bool {
|
|
(&*ptr).can_fetch_more()
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_fetch_more(ptr: *mut %1) {
|
|
(&mut *ptr).fetch_more()
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_sort(
|
|
ptr: *mut %1,
|
|
column: u8,
|
|
order: SortOrder,
|
|
) {
|
|
(&mut *ptr).sort(column, order)
|
|
}
|
|
)").arg(o.name, lcname);
|
|
} else if (o.type == ObjectType::Tree) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_row_count(
|
|
ptr: *const %1,
|
|
item: usize,
|
|
valid: bool,
|
|
) -> c_int {
|
|
if valid {
|
|
(&*ptr).row_count(Some(item)) as c_int
|
|
} else {
|
|
(&*ptr).row_count(None) as c_int
|
|
}
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_can_fetch_more(
|
|
ptr: *const %1,
|
|
item: usize,
|
|
valid: bool,
|
|
) -> bool {
|
|
if valid {
|
|
(&*ptr).can_fetch_more(Some(item))
|
|
} else {
|
|
(&*ptr).can_fetch_more(None)
|
|
}
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_fetch_more(ptr: *mut %1, item: usize, valid: bool) {
|
|
if valid {
|
|
(&mut *ptr).fetch_more(Some(item))
|
|
} else {
|
|
(&mut *ptr).fetch_more(None)
|
|
}
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_sort(
|
|
ptr: *mut %1,
|
|
column: u8,
|
|
order: SortOrder
|
|
) {
|
|
(&mut *ptr).sort(column, order)
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_index(
|
|
ptr: *const %1,
|
|
item: usize,
|
|
valid: bool,
|
|
row: c_int,
|
|
) -> usize {
|
|
if !valid {
|
|
(&*ptr).index(None, row as usize)
|
|
} else {
|
|
(&*ptr).index(Some(item), row as usize)
|
|
}
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_parent(ptr: *const %1, index: usize) -> QModelIndex {
|
|
if let Some(parent) = (&*ptr).parent(index) {
|
|
QModelIndex {
|
|
row: (&*ptr).row(parent) as c_int,
|
|
internal_id: parent,
|
|
}
|
|
} else {
|
|
QModelIndex {
|
|
row: -1,
|
|
internal_id: 0,
|
|
}
|
|
}
|
|
}
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_row(ptr: *const %1, item: usize) -> c_int {
|
|
(&*ptr).row(item) as c_int
|
|
}
|
|
)").arg(o.name, lcname);
|
|
}
|
|
if (o.type != ObjectType::Object) {
|
|
QString indexDecl = ", row: c_int";
|
|
QString index = "row as usize";
|
|
if (o.type == ObjectType::Tree) {
|
|
indexDecl = ", item: usize";
|
|
index = "item";
|
|
}
|
|
for (auto ip: o.itemProperties) {
|
|
if (ip.type.isComplex() && !ip.optional) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_data_%3(
|
|
ptr: *const %1%5,
|
|
d: *mut c_void,
|
|
set: fn(*mut c_void, %4),
|
|
) {
|
|
let data = (&*ptr).%3(%6);
|
|
set(d, (%7data).into());
|
|
}
|
|
)").arg(o.name, lcname, snakeCase(ip.name), ip.type.name, indexDecl, index,
|
|
ip.rustByValue ?"&" :"");
|
|
} else if (ip.type.isComplex()) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_data_%3(
|
|
ptr: *const %1%5,
|
|
d: *mut c_void,
|
|
set: fn(*mut c_void, %4),
|
|
) {
|
|
let data = (&*ptr).%3(%6);
|
|
if let Some(data) = data {
|
|
set(d, %4::from(&data));
|
|
}
|
|
}
|
|
)").arg(o.name, lcname, snakeCase(ip.name), ip.type.name, indexDecl, index);
|
|
} else {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_data_%3(ptr: *const %1%5) -> %4 {
|
|
(&*ptr).%3(%6).into()
|
|
}
|
|
)").arg(o.name, lcname, snakeCase(ip.name), rustCType(ip), indexDecl, index);
|
|
}
|
|
if (ip.write) {
|
|
QString val = "v";
|
|
QString type = ip.type.rustType;
|
|
if (ip.type.isComplex()) {
|
|
val = val + ".convert()";
|
|
type = ip.type.name == "QString" ? "QStringIn" : ip.type.name;
|
|
}
|
|
if (ip.optional) {
|
|
val = "Some(" + val + ")";
|
|
}
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_set_data_%3(
|
|
ptr: *mut %1%4,
|
|
v: %6,
|
|
) -> bool {
|
|
(&mut *ptr).set_%3(%5, %7)
|
|
}
|
|
)").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index, type, val);
|
|
}
|
|
if (ip.write && ip.optional) {
|
|
r << QString(R"(
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn %2_set_data_%3_none(ptr: *mut %1, row: c_int%4) -> bool {
|
|
(&mut *ptr).set_%3(%5row as usize, None)
|
|
}
|
|
)").arg(o.name, lcname, snakeCase(ip.name), indexDecl, index);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
QString rustFile(const QDir rustdir, const QString& module) {
|
|
QDir src(rustdir.absoluteFilePath("src"));
|
|
QString modulePath = src.absoluteFilePath(module + "/mod.rs");
|
|
if (QFile::exists(modulePath)) {
|
|
return modulePath;
|
|
}
|
|
return src.absoluteFilePath(module + ".rs");
|
|
}
|
|
|
|
void writeRustTypes(const Configuration& conf, QTextStream& r) {
|
|
bool hasOption = false;
|
|
bool hasString = false;
|
|
bool hasStringWrite = false;
|
|
bool hasByteArray = false;
|
|
bool hasListOrTree = false;
|
|
|
|
for (auto o: conf.objects) {
|
|
hasListOrTree |= o.type != ObjectType::Object;
|
|
for (auto p: o.properties) {
|
|
hasOption |= p.optional;
|
|
hasString |= p.type.type == BindingType::QString;
|
|
hasStringWrite |= p.type.type == BindingType::QString
|
|
&& p.write;
|
|
hasByteArray |= p.type.type == BindingType::QByteArray;
|
|
}
|
|
for (auto p: o.itemProperties) {
|
|
hasOption |= p.optional;
|
|
hasString |= p.type.type == BindingType::QString;
|
|
hasByteArray |= p.type.type == BindingType::QByteArray;
|
|
}
|
|
}
|
|
|
|
if (hasOption || hasListOrTree) {
|
|
r << R"(
|
|
|
|
#[repr(C)]
|
|
pub struct COption<T> {
|
|
data: T,
|
|
some: bool,
|
|
}
|
|
|
|
impl<T> From<Option<T>> for COption<T>
|
|
where
|
|
T: Default,
|
|
{
|
|
fn from(t: Option<T>) -> COption<T> {
|
|
if let Some(v) = t {
|
|
COption {
|
|
data: v,
|
|
some: true,
|
|
}
|
|
} else {
|
|
COption {
|
|
data: T::default(),
|
|
some: false,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
)";
|
|
}
|
|
if (hasString) {
|
|
r << R"(
|
|
|
|
#[repr(C)]
|
|
pub struct QString {
|
|
data: *const uint8_t,
|
|
len: c_int,
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct QStringIn {
|
|
data: *const uint16_t,
|
|
len: c_int,
|
|
}
|
|
|
|
impl QStringIn {
|
|
fn convert(&self) -> String {
|
|
let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
|
|
String::from_utf16_lossy(data)
|
|
}
|
|
}
|
|
|
|
impl<'a> From<&'a str> for QString {
|
|
fn from(string: &'a str) -> QString {
|
|
QString {
|
|
len: string.len() as c_int,
|
|
data: string.as_ptr(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> From<&'a String> for QString {
|
|
fn from(string: &'a String) -> QString {
|
|
QString {
|
|
len: string.len() as c_int,
|
|
data: string.as_ptr(),
|
|
}
|
|
}
|
|
}
|
|
)";
|
|
}
|
|
if (hasByteArray) {
|
|
r << R"(
|
|
|
|
#[repr(C)]
|
|
pub struct QByteArray {
|
|
data: *const uint8_t,
|
|
len: c_int,
|
|
}
|
|
|
|
impl QByteArray {
|
|
fn convert(&self) -> Vec<u8> {
|
|
let data = unsafe { slice::from_raw_parts(self.data, self.len as usize) };
|
|
Vec::from(data)
|
|
}
|
|
}
|
|
|
|
impl<'a> From<&'a [u8]> for QByteArray {
|
|
fn from(value: &'a [u8]) -> QByteArray {
|
|
QByteArray {
|
|
len: value.len() as c_int,
|
|
data: value.as_ptr(),
|
|
}
|
|
}
|
|
}
|
|
)";
|
|
}
|
|
if (hasListOrTree) {
|
|
r << R"(
|
|
|
|
#[repr(C)]
|
|
pub enum SortOrder {
|
|
Ascending = 0,
|
|
Descending = 1,
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct QModelIndex {
|
|
row: c_int,
|
|
internal_id: usize,
|
|
}
|
|
)";
|
|
}
|
|
}
|
|
|
|
void writeRustInterface(const Configuration& conf) {
|
|
DifferentFileWriter w(rustFile(conf.rustdir, conf.interfaceModule));
|
|
QTextStream r(&w.buffer);
|
|
r << QString(R"(/* generated by rust_qt_binding_generator */
|
|
#![allow(unknown_lints)]
|
|
#![allow(mutex_atomic, needless_pass_by_value)]
|
|
use libc::{c_int, c_void, uint8_t, uint16_t};
|
|
use std::slice;
|
|
|
|
use std::sync::{Arc, Mutex};
|
|
use std::ptr::null;
|
|
|
|
use %1::*;
|
|
)").arg(conf.implementationModule);
|
|
|
|
writeRustTypes(conf, r);
|
|
|
|
for (auto object: conf.objects) {
|
|
writeRustInterfaceObject(r, object, conf);
|
|
}
|
|
}
|
|
|
|
void writeRustImplementationObject(QTextStream& r, const Object& o) {
|
|
const QString lcname(snakeCase(o.name));
|
|
if (o.type != ObjectType::Object) {
|
|
r << "#[derive(Default, Clone)]\n";
|
|
r << QString("struct %1Item {\n").arg(o.name);
|
|
for (auto ip: o.itemProperties) {
|
|
const QString lc(snakeCase(ip.name));
|
|
r << QString(" %1: %2,\n").arg(lc, ip.type.rustType);
|
|
}
|
|
r << "}\n\n";
|
|
}
|
|
QString modelStruct = "";
|
|
r << QString("pub struct %1 {\n emit: %1Emitter,\n").arg((o.name));
|
|
if (o.type == ObjectType::List) {
|
|
modelStruct = ", model: " + o.name + "List";
|
|
r << QString(" model: %1List,\n").arg(o.name);
|
|
} else if (o.type == ObjectType::Tree) {
|
|
modelStruct = ", model: " + o.name + "Tree";
|
|
r << QString(" model: %1Tree,\n").arg(o.name);
|
|
}
|
|
for (const Property& p: o.properties) {
|
|
const QString lc(snakeCase(p.name));
|
|
r << QString(" %1: %2,\n").arg(lc, rustType(p));
|
|
}
|
|
if (o.type != ObjectType::Object) {
|
|
r << QString(" list: Vec<%1Item>,\n").arg(o.name);
|
|
}
|
|
r << "}\n\n";
|
|
for (const Property& p: o.properties) {
|
|
if (p.type.type == BindingType::Object) {
|
|
modelStruct += ", " + p.name + ": " + p.type.name;
|
|
}
|
|
}
|
|
r << QString(R"(impl %1Trait for %1 {
|
|
fn create(emit: %1Emitter%2) -> %1 {
|
|
%1 {
|
|
emit: emit,
|
|
)").arg(o.name, modelStruct);
|
|
if (o.type != ObjectType::Object) {
|
|
r << QString(" model: model,\n");
|
|
}
|
|
for (const Property& p: o.properties) {
|
|
const QString lc(snakeCase(p.name));
|
|
if (p.type.type == BindingType::Object) {
|
|
r << QString(" %1: %1,\n").arg(lc);
|
|
} else {
|
|
r << QString(" %1: %2,\n").arg(lc, rustTypeInit(p));
|
|
}
|
|
}
|
|
if (o.type != ObjectType::Object) {
|
|
r << QString(" list: vec![%1Item::default(); 10],\n")
|
|
.arg(o.name);
|
|
}
|
|
r << QString(R"( }
|
|
}
|
|
fn emit(&self) -> &%1Emitter {
|
|
&self.emit
|
|
}
|
|
)").arg(o.name);
|
|
for (const Property& p: o.properties) {
|
|
const QString lc(snakeCase(p.name));
|
|
if (p.type.type == BindingType::Object) {
|
|
r << QString(R"( fn %1(&self) -> &%2 {
|
|
&self.%1
|
|
}
|
|
fn %1_mut(&mut self) -> &mut %2 {
|
|
&mut self.%1
|
|
}
|
|
)").arg(lc, rustReturnType(p));
|
|
} else {
|
|
r << QString(" fn %1(&self) -> %2 {\n").arg(lc, rustReturnType(p));
|
|
if (p.type.isComplex()) {
|
|
if (p.optional) {
|
|
/*
|
|
if (rustType(p) == "Option<String>") {
|
|
r << QString(" self.%1.as_ref().map(|p|p.as_str())\n").arg(lc);
|
|
} else {
|
|
}
|
|
*/
|
|
r << QString(" self.%1.as_ref().map(|p|&p[..])\n").arg(lc);
|
|
} else {
|
|
r << QString(" &self.%1\n").arg(lc);
|
|
}
|
|
} else {
|
|
r << QString(" self.%1\n").arg(lc);
|
|
}
|
|
r << " }\n";
|
|
if (p.write) {
|
|
r << QString(R"( fn set_%1(&mut self, value: %2) {
|
|
self.%1 = value;
|
|
self.emit.%1_changed();
|
|
}
|
|
)").arg(lc, rustType(p));
|
|
}
|
|
}
|
|
}
|
|
if (o.type == ObjectType::List) {
|
|
r << " fn row_count(&self) -> usize {\n self.list.len()\n }\n";
|
|
} else if (o.type == ObjectType::Tree) {
|
|
r << R"( fn row_count(&self, item: Option<usize>) -> usize {
|
|
self.list.len()
|
|
}
|
|
fn index(&self, item: Option<usize>, row: usize) -> usize {
|
|
0
|
|
}
|
|
fn parent(&self, item: usize) -> Option<usize> {
|
|
None
|
|
}
|
|
fn row(&self, item: usize) -> usize {
|
|
item
|
|
}
|
|
)";
|
|
}
|
|
if (o.type != ObjectType::Object) {
|
|
QString index;
|
|
if (o.type == ObjectType::Tree) {
|
|
index = ", item: usize";
|
|
}
|
|
for (auto ip: o.itemProperties) {
|
|
const QString lc(snakeCase(ip.name));
|
|
r << QString(" fn %1(&self, item: usize) -> %2 {\n")
|
|
.arg(lc, rustReturnType(ip));
|
|
if (ip.type.isComplex()) {
|
|
r << " &self.list[item]." << lc << "\n";
|
|
} else {
|
|
r << " self.list[item]." << lc << "\n";
|
|
}
|
|
r << " }\n";
|
|
if (ip.write) {
|
|
r << QString(" fn set_%1(&mut self, item: usize, v: %2) -> bool {\n")
|
|
.arg(snakeCase(ip.name), rustType(ip));
|
|
r << " self.list[item]." << lc << " = v;\n";
|
|
r << " true\n";
|
|
r << " }\n";
|
|
}
|
|
}
|
|
}
|
|
r << "}\n\n";
|
|
}
|
|
|
|
void writeRustImplementation(const Configuration& conf) {
|
|
DifferentFileWriter w(rustFile(conf.rustdir, conf.implementationModule),
|
|
conf.overwriteImplementation);
|
|
QTextStream r(&w.buffer);
|
|
r << QString(R"(#![allow(unused_imports)]
|
|
#![allow(unused_variables)]
|
|
#![allow(dead_code)]
|
|
use %1::*;
|
|
|
|
)").arg(conf.interfaceModule);
|
|
|
|
for (auto object: conf.objects) {
|
|
writeRustImplementationObject(r, object);
|
|
}
|
|
}
|