a lot of setup and testing work for rust

src/rust/service_item_model.rs

@@ -0,0 +1,142 @@
+use cxx::{type_id, ExternType};
+use std::mem::MaybeUninit;
+
+// Define a QModelIndex that is trivial for CXX
+//
+// TODO: later this will likely be in cxx-qt-lib
+#[repr(C)]
+pub struct QModelIndex {
+    _space: MaybeUninit<[usize; 3]>,
+}
+
+// Safety:
+//
+// Static checks on the C++ side to ensure the size is the same.
+// TODO: later this will likely be in cxx-qt-lib
+unsafe impl ExternType for QModelIndex {
+    type Id = type_id!("QModelIndex");
+    type Kind = cxx::kind::Trivial;
+}
+
+// ANCHOR: book_macro_code
+#[cxx_qt::bridge(cxx_file_stem = "service_item_model")]
+mod service_item_model {
+    // ANCHOR: book_base_include
+    unsafe extern "C++" {
+        include!("serviceitemmodel.h");
+        // ANCHOR_END: book_base_include
+
+        include!("cxx-qt-lib/qvariant.h");
+        type QVariant = cxx_qt_lib::QVariant;
+
+        // Define the interface of the QModelIndex
+        type QModelIndex = super::QModelIndex;
+        fn row(self: &QModelIndex) -> i32;
+
+        #[cxx_name = "beginInsertRows"]
+        fn begin_insert_rows(self: Pin<&mut CustomBaseClassQt>, first: i32, last: i32);
+        #[cxx_name = "endInsertRows"]
+        fn end_insert_rows(self: Pin<&mut CustomBaseClassQt>);
+
+        #[cxx_name = "beginRemoveRows"]
+        fn begin_remove_rows(self: Pin<&mut CustomBaseClassQt>, first: i32, last: i32);
+        #[cxx_name = "endRemoveRows"]
+        fn end_remove_rows(self: Pin<&mut CustomBaseClassQt>);
+
+        #[cxx_name = "beginResetModel"]
+        fn begin_reset_model(self: Pin<&mut CustomBaseClassQt>);
+        #[cxx_name = "endResetModel"]
+        fn end_reset_model(self: Pin<&mut CustomBaseClassQt>);
+    }
+
+    // ANCHOR: book_qobject_base
+    #[cxx_qt::qobject(base = "ServiceItemModel")]
+    #[derive(Default)]
+    pub struct ServiceItemModel {
+        // ANCHOR_END: book_qobject_base
+        id: u32,
+        vector: Vec<(u32, f64)>,
+    }
+
+    impl qobject::ServiceItemModel {
+        #[qinvokable]
+        pub fn add(self: Pin<&mut Self>) {
+            self.add_cpp_context();
+        }
+
+        #[qinvokable]
+        pub fn add_on_thread(self: Pin<&mut Self>, mut counter: i32) {
+            let qt_thread = self.qt_thread();
+
+            std::thread::spawn(move || {
+                while counter > 0 {
+                    counter -= 1;
+                    std::thread::sleep(std::time::Duration::from_millis(250));
+
+                    // Use our add helper to add a row on the Qt event loop
+                    // as seen in the threading demo channels could be used to pass info
+                    qt_thread
+                        .queue(|custom_base_class| {
+                            custom_base_class.add_cpp_context();
+                        })
+                        .unwrap();
+                }
+            });
+        }
+
+        fn add_cpp_context(mut self: Pin<&mut Self>) {
+            let count = self.vector().len();
+            self.as_mut().begin_insert_rows(count as i32, count as i32);
+            let id = *self.id();
+            self.as_mut().set_id(id + 1);
+            self.as_mut().vector_mut().push((id, (id as f64) / 3.0));
+            self.as_mut().end_insert_rows();
+        }
+
+        #[qinvokable]
+        pub fn clear(mut self: Pin<&mut Self>) {
+            self.as_mut().begin_reset_model();
+            self.as_mut().set_id(0);
+            self.as_mut().vector_mut().clear();
+            self.as_mut().end_reset_model();
+        }
+
+        #[qinvokable]
+        pub fn remove(mut self: Pin<&mut Self>, index: i32) {
+            if index < 0 || (index as usize) >= self.vector().len() {
+                return;
+            }
+
+            self.as_mut().begin_remove_rows(index, index);
+            self.as_mut().vector_mut().remove(index as usize);
+            self.as_mut().end_remove_rows();
+        }
+    }
+
+    // QAbstractListModel implementation
+    impl qobject::ServiceItemModel {
+        #[qinvokable(cxx_override)]
+        fn data(&self, index: &QModelIndex, role: i32) -> QVariant {
+            if let Some((id, value)) = self.rust().vector.get(index.row() as usize) {
+                return match role {
+                    0 => QVariant::from(*id),
+                    1 => QVariant::from(*value),
+                    _ => QVariant::default(),
+                };
+            }
+
+            QVariant::default()
+        }
+
+        #[qinvokable(cxx_override)]
+        pub fn role_names_as_vec(&self) -> Vec<String> {
+            vec!["id".to_owned(), "value".to_owned()]
+        }
+
+        #[qinvokable(cxx_override)]
+        pub fn row_count(&self, _parent: &QModelIndex) -> i32 {
+            self.rust().vector.len() as i32
+        }
+    }
+}
+// ANCHOR_END: book_macro_code