cxx-qt-gen: add support for multiple QObjects in writer/cpp

Author: ahayzen-kdab

cxx-qt-gen/src/gen_cpp.rs

@@ -10,7 +10,9 @@ use proc_macro2::TokenStream;
 use syn::Ident;
 
 use crate::extract::{Invokable, Parameter, ParameterType, Property, QObject, QtTypes, Signal};
-use crate::generator::cpp::{fragment::CppFragmentPair, GeneratedCppBlocks};
+use crate::generator::cpp::{
+    fragment::CppFragmentPair, qobject::GeneratedCppQObjectBlocks, GeneratedCppBlocks,
+};
 use crate::writer::cpp::write_cpp;
 
 /// A trait which we implement on QtTypes allowing retrieval of attributes of the enum value.
@@ -634,13 +636,11 @@ pub fn generate_qobject_cpp(obj: &QObject) -> Result<CppObject, TokenStream> {
     // TODO: later this will be shared with gen_rs in the generator phase
     let cxx_qt_thread_ident = format!("{}CxxQtThread", struct_ident_str);
 
-    // For now convert our gen_cpp code into the GeneratedCppBlocks struct
-    let generated = GeneratedCppBlocks {
-        cxx_stem: struct_ident_str.to_case(Case::Snake),
-        ident: struct_ident_str,
+    // For now we only create a single QObject
+    let qobjects = vec![GeneratedCppQObjectBlocks {
+        ident: struct_ident_str.clone(),
         rust_ident: rust_struct_ident,
         cxx_qt_thread_ident,
-        namespace: obj.namespace.clone(),
         namespace_internals: namespace_internals.join("::"),
         base_class: obj
             .base_class
@@ -651,6 +651,13 @@ pub fn generate_qobject_cpp(obj: &QObject) -> Result<CppObject, TokenStream> {
         slots,
         signals,
         members,
+    }];
+
+    // For now convert our gen_cpp code into the GeneratedCppBlocks struct
+    let generated = GeneratedCppBlocks {
+        cxx_stem: struct_ident_str.to_case(Case::Snake),
+        namespace: obj.namespace.clone(),
+        qobjects,
     };
 
     // Use our writer phase to convert to a string

cxx-qt-gen/src/generator/cpp/mod.rs

@@ -4,33 +4,14 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 pub mod fragment;
+pub mod qobject;
 
-use fragment::CppFragmentPair;
-
-/// Representation of the generated C++ code for a QObject
+/// Representation of the generated C++ code for a group of QObjects
 pub struct GeneratedCppBlocks {
     /// Stem of the CXX header to include
     pub cxx_stem: String,
-    /// Ident of the C++ QObject
-    pub ident: String,
-    /// Ident of the Rust object
-    pub rust_ident: String,
-    /// Ident of the CxxQtThread object
-    pub cxx_qt_thread_ident: String,
-    /// Ident of the namespace of the QObject
+    /// Ident of the common namespace of the QObjects
     pub namespace: String,
-    /// Ident of the namespace for CXX-Qt internals of the QObject
-    pub namespace_internals: String,
-    /// Base class of the QObject
-    pub base_class: String,
-    /// List of Qt Meta Object items (eg Q_PROPERTY)
-    pub metaobjects: Vec<String>,
-    /// List of public methods for the QObject
-    pub methods: Vec<CppFragmentPair>,
-    /// List of public Q_SLOTS for the QObject
-    pub slots: Vec<CppFragmentPair>,
-    /// List of public Q_SIGNALS for the QObject
-    pub signals: Vec<String>,
-    /// List of private members for the QObject
-    pub members: Vec<String>,
+    /// Generated QObject blocks
+    pub qobjects: Vec<qobject::GeneratedCppQObjectBlocks>,
 }

cxx-qt-gen/src/generator/cpp/qobject.rs

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company <[email protected]>
+// SPDX-FileContributor: Andrew Hayzen <[email protected]>
+//
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+use crate::generator::cpp::fragment::CppFragmentPair;
+
+pub struct GeneratedCppQObjectBlocks {
+    /// Ident of the C++ QObject
+    pub ident: String,
+    /// Ident of the Rust object
+    pub rust_ident: String,
+    /// Ident of the CxxQtThread object
+    pub cxx_qt_thread_ident: String,
+    /// Ident of the namespace for CXX-Qt internals of the QObject
+    pub namespace_internals: String,
+    /// Base class of the QObject
+    pub base_class: String,
+    /// List of Qt Meta Object items (eg Q_PROPERTY)
+    pub metaobjects: Vec<String>,
+    /// List of public methods for the QObject
+    pub methods: Vec<CppFragmentPair>,
+    /// List of public Q_SLOTS for the QObject
+    pub slots: Vec<CppFragmentPair>,
+    /// List of public Q_SIGNALS for the QObject
+    pub signals: Vec<String>,
+    /// List of private members for the QObject
+    pub members: Vec<String>,
+}

cxx-qt-gen/src/writer/cpp/header.rs

@@ -4,6 +4,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::generator::cpp::{fragment::CppFragmentPair, GeneratedCppBlocks};
+use crate::writer::cpp::namespace_pair;
 use indoc::formatdoc;
 
 /// Extract the header from a given CppFragmentPair
@@ -33,6 +34,91 @@ fn create_block(block: &str, items: &[&str]) -> String {
     }
 }
 
+/// For a given GeneratedCppBlocks write the forward declare
+fn forward_declare(generated: &GeneratedCppBlocks) -> Vec<String> {
+    let (namespace_start, namespace_end) = namespace_pair(generated);
+
+    generated
+        .qobjects
+        .iter()
+        .map(|qobject| {
+            formatdoc! { r#"
+                {namespace_start}
+                class {ident};
+                using {cxx_qt_thread_ident} = rust::cxxqtlib1::CxxQtThread<{ident}>;
+                {namespace_end}
+            "#,
+            ident = qobject.ident,
+            cxx_qt_thread_ident = qobject.cxx_qt_thread_ident,
+            namespace_start = namespace_start,
+            namespace_end = namespace_end,
+            }
+        })
+        .collect::<Vec<String>>()
+}
+
+/// For a given GeneratedCppBlocks write the classes
+fn qobjects_header(generated: &GeneratedCppBlocks) -> Vec<String> {
+    let (namespace_start, namespace_end) = namespace_pair(generated);
+
+    generated.qobjects.iter().map(|qobject| {
+        formatdoc! { r#"
+            {namespace_start}
+            class {ident} : public {base_class}
+            {{
+              Q_OBJECT
+              {metaobjects}
+
+            public:
+              explicit {ident}(QObject* parent = nullptr);
+              ~{ident}();
+              const {rust_ident}& unsafeRust() const;
+              {rust_ident}& unsafeRustMut();
+              std::unique_ptr<{cxx_qt_thread_ident}> qtThread() const;
+
+            {methods}
+            {slots}
+            {signals}
+            private:
+              rust::Box<{rust_ident}> m_rustObj;
+              std::shared_ptr<std::mutex> m_rustObjMutex;
+              bool m_initialised = false;
+              std::shared_ptr<rust::cxxqtlib1::CxxQtGuardedPointer<{ident}>> m_cxxQtThreadObj;
+
+              {members}
+            }};
+
+            static_assert(std::is_base_of<QObject, {ident}>::value, "{ident} must inherit from QObject");
+            {namespace_end}
+
+            namespace {namespace_internals} {{
+            std::unique_ptr<{ident}>
+            newCppObject();
+            }} // namespace {namespace_internals}
+
+            Q_DECLARE_METATYPE({metatype}*)
+        "#,
+        ident = qobject.ident,
+        cxx_qt_thread_ident = qobject.cxx_qt_thread_ident,
+        namespace_start = namespace_start,
+        namespace_end = namespace_end,
+        namespace_internals = qobject.namespace_internals,
+        rust_ident = qobject.rust_ident,
+        base_class = qobject.base_class,
+        metaobjects = qobject.metaobjects.join("\n  "),
+        methods = create_block("public", &qobject.methods.iter().map(pair_as_header).collect::<Vec<&str>>()),
+        slots = create_block("public Q_SLOTS", &qobject.slots.iter().map(pair_as_header).collect::<Vec<&str>>()),
+        signals = create_block("Q_SIGNALS", &qobject.signals.iter().map(AsRef::as_ref).collect::<Vec<&str>>()),
+        members = qobject.members.join("\n  "),
+        metatype = if generated.namespace.is_empty() {
+            qobject.ident.clone()
+        } else {
+            format!("{namespace}::{ident}", namespace = generated.namespace, ident = qobject.ident)
+        },
+        }
+    }).collect::<Vec<String>>()
+}
+
 /// For a given GeneratedCppBlocks write this into a C++ header
 pub fn write_cpp_header(generated: &GeneratedCppBlocks) -> String {
     formatdoc! {r#"
@@ -46,74 +132,14 @@ pub fn write_cpp_header(generated: &GeneratedCppBlocks) -> String {
         class CxxQtThread;
         }}
 
-        {namespace_start}
-        class {ident};
-        using {cxx_qt_thread_ident} = rust::cxxqtlib1::CxxQtThread<{ident}>;
-        {namespace_end}
-
+        {forward_declare}
         #include "cxx-qt-gen/include/{cxx_stem}.cxx.h"
 
-        {namespace_start}
-        class {ident} : public {base_class}
-        {{
-          Q_OBJECT
-          {metaobjects}
-
-        public:
-          explicit {ident}(QObject* parent = nullptr);
-          ~{ident}();
-          const {rust_ident}& unsafeRust() const;
-          {rust_ident}& unsafeRustMut();
-          std::unique_ptr<{cxx_qt_thread_ident}> qtThread() const;
-
-        {methods}
-        {slots}
-        {signals}
-        private:
-          rust::Box<{rust_ident}> m_rustObj;
-          std::shared_ptr<std::mutex> m_rustObjMutex;
-          bool m_initialised = false;
-          std::shared_ptr<rust::cxxqtlib1::CxxQtGuardedPointer<{ident}>> m_cxxQtThreadObj;
-
-          {members}
-        }};
-
-        static_assert(std::is_base_of<QObject, {ident}>::value, "{ident} must inherit from QObject");
-        {namespace_end}
-
-        namespace {namespace_internals} {{
-        std::unique_ptr<{ident}>
-        newCppObject();
-        }} // namespace {namespace_internals}
-
-        Q_DECLARE_METATYPE({metatype}*)
+        {qobjects}
     "#,
     cxx_stem = generated.cxx_stem,
-    ident = generated.ident,
-    cxx_qt_thread_ident = generated.cxx_qt_thread_ident,
-    namespace_start = if generated.namespace.is_empty() {
-        "".to_owned()
-    } else {
-        format!("namespace {namespace} {{", namespace = generated.namespace)
-    },
-    namespace_end = if generated.namespace.is_empty() {
-        "".to_owned()
-    } else {
-        format!("}} // namespace {namespace}", namespace = generated.namespace)
-    },
-    namespace_internals = generated.namespace_internals,
-    rust_ident = generated.rust_ident,
-    base_class = generated.base_class,
-    metaobjects = generated.metaobjects.join("\n  "),
-    methods = create_block("public", &generated.methods.iter().map(pair_as_header).collect::<Vec<&str>>()),
-    slots = create_block("public Q_SLOTS", &generated.slots.iter().map(pair_as_header).collect::<Vec<&str>>()),
-    signals = create_block("Q_SIGNALS", &generated.signals.iter().map(AsRef::as_ref).collect::<Vec<&str>>()),
-    members = generated.members.join("\n  "),
-    metatype = if generated.namespace.is_empty() {
-        generated.ident.clone()
-    } else {
-        format!("{namespace}::{ident}", namespace = generated.namespace, ident = generated.ident)
-    },
+    forward_declare = forward_declare(generated).join("\n"),
+    qobjects = qobjects_header(generated).join("\n"),
     }
 }
 
@@ -122,7 +148,8 @@ mod tests {
     use super::*;
 
     use crate::writer::cpp::tests::{
-        create_generated_cpp, create_generated_cpp_no_namespace, expected_header,
+        create_generated_cpp, create_generated_cpp_multi_qobjects,
+        create_generated_cpp_no_namespace, expected_header, expected_header_multi_qobjects,
         expected_header_no_namespace,
     };
     use indoc::indoc;
@@ -157,6 +184,13 @@ mod tests {
         assert_str_eq!(output, expected_header());
     }
 
+    #[test]
+    fn test_write_cpp_header_multi_qobjects() {
+        let generated = create_generated_cpp_multi_qobjects();
+        let output = write_cpp_header(&generated);
+        assert_str_eq!(output, expected_header_multi_qobjects());
+    }
+
     #[test]
     fn test_write_cpp_header_no_namespace() {
         let generated = create_generated_cpp_no_namespace();