Update Rust crate quick-xml to 0.37.0

Cargo.toml

@@ -1,23 +1,9 @@
-[package]
+[workspace]
-name = "ui"
+resolver = "2"
-version = "0.1.0"
-authors = ["hodasemi <michaelh.95@t-online.de>"]
-edition = "2024"
 
-[dependencies]
+members = ["ui", "ui_proc_macro"]
-quick-xml = "0.31.0"
-serde = { version = "1.0.203", features = ["derive"] }
-serde_json = { version = "1.0.120" }
-paste = "1.0.15"
-anyhow = { version = "1.0.86", features = ["backtrace"] }
 
-vulkan-rs = { git = "https://gavania.de/hodasemi/vulkan_lib.git" }
+[workspace.dependencies]
-utilities = { git = "https://gavania.de/hodasemi/utilities.git" }
+syn = { version = "2.0.67", features = ["extra-traits", "full"] }
-assetpath = { git = "https://gavania.de/hodasemi/vulkan_lib.git" }
+quote = "1.0.35"
-ecs = { git = "https://gavania.de/hodasemi/ecs.git" }
+proc-macro2 = "1.0.86"
-
-# optional
-audio = { git = "https://gavania.de/hodasemi/audio.git", optional = true }
-
-[features]
-default = ["audio"]

ui/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "ui"
+version = "0.1.0"
+authors = ["hodasemi <michaelh.95@t-online.de>"]
+edition = "2024"
+
+[dependencies]
+quick-xml = "0.37.0"
+serde = { version = "1.0.203", features = ["derive"] }
+serde_json = { version = "1.0.120" }
+paste = "1.0.15"
+anyhow = { version = "1.0.86", features = ["backtrace"] }
+
+vulkan-rs = { git = "https://gavania.de/hodasemi/vulkan_lib.git" }
+utilities = { git = "https://gavania.de/hodasemi/utilities.git" }
+assetpath = { git = "https://gavania.de/hodasemi/vulkan_lib.git" }
+ecs = { git = "https://gavania.de/hodasemi/ecs.git" }
+
+# optional
+audio = { git = "https://gavania.de/hodasemi/audio.git", optional = true }
+
+[features]
+default = ["audio"]

ui/src/gui_handler/gui_handler.rs

@@ -936,12 +936,11 @@ impl GuiHandler {
     }
 
     pub fn process_callbacks(&mut self, commands: &mut Commands) -> Result<()> {
-        let callback_self = unsafe { remove_life_time_mut(self) };
         let callbacks = mem::take(&mut self.callback_list);
 
         callbacks
             .into_iter()
-            .try_for_each(|callback| callback(commands, callback_self))
+            .try_for_each(|callback| callback(commands, self))
     }
 
     fn render(

ui_proc_macro/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "ui_proc_macro"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { workspace = true }
+quote = { workspace = true }
+proc-macro2 = { workspace = true }
+update_macro_base = { git = "https://gavania.de/hodasemi/ecs" }

ui_proc_macro/src/lib.rs

@@ -0,0 +1,37 @@
+mod update;
+
+use update::update;
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{
+    DeriveInput, LitInt, Result,
+    parse::{Parse, ParseStream},
+    parse_macro_input,
+    token::Comma,
+};
+
+struct UpdateInfo {
+    max_components: usize,
+    max_resources: usize,
+}
+
+impl Parse for UpdateInfo {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let max_components = input.parse::<LitInt>()?.base10_parse()?;
+        input.parse::<Comma>()?;
+        let max_resources = input.parse::<LitInt>()?.base10_parse()?;
+
+        Ok(Self {
+            max_components,
+            max_resources,
+        })
+    }
+}
+
+#[proc_macro]
+pub fn implement_updates(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as UpdateInfo);
+
+    update(input.max_components, input.max_resources)
+}

ui_proc_macro/src/update.rs

@@ -0,0 +1,105 @@
+use proc_macro2::TokenStream as TokenStream2;
+use update_macro_base::*;
+
+fn resource_only_events_and_systems(update: &Update) -> TokenStream2 {
+    let resource_tokens = update.resourece_tokens();
+
+    let resource_types = &resource_tokens.resource_types;
+    let resource_type_impls = &resource_tokens.resource_type_impls;
+    let resources = &resource_tokens.resources;
+    let resource_requirement = &resource_tokens.resource_requirement;
+    let resource_store = &resource_tokens.resource_store;
+    let resource_idents = &resource_tokens.resource_idents;
+
+    todo!()
+}
+
+fn events_and_systems(update: &Update) -> TokenStream2 {
+    let query_tokens = update.query_tokens();
+
+    let filter_types = &query_tokens.filter_types;
+    let filter_type_impls = &query_tokens.filter_type_impls;
+    let query_types = &query_tokens.query_types;
+    let query_type_impls = &query_tokens.query_type_impls;
+    let queries = query_tokens.queries;
+    let filter_requirements = &query_tokens.filter_requirements;
+    let component_requirements = &query_tokens.component_requirements;
+    let query_count = query_tokens.query_count;
+    let verify_dedup = &query_tokens.verify_dedup;
+    let check_entities = &query_tokens.check_entities;
+    let component_stores = &query_tokens.component_stores;
+    let query_structs = &query_tokens.query_structs;
+    let query_idents = &query_tokens.query_idents;
+
+    let resource_tokens = update.resourece_tokens();
+
+    let resource_types = &resource_tokens.resource_types;
+    let resource_type_impls = &resource_tokens.resource_type_impls;
+    let resources = &resource_tokens.resources;
+    let resource_requirement = &resource_tokens.resource_requirement;
+    let resource_store = &resource_tokens.resource_store;
+    let resource_idents = &resource_tokens.resource_idents;
+
+    todo!()
+}
+
+fn update(max_components: usize, max_resources: usize) -> TokenStream2 {
+    let mut queries: Vec<Vec<usize>> = Vec::new();
+
+    for c in Update::MIN_COMPONENTS..=max_components {
+        queries.push(vec![c]);
+    }
+
+    for x in Update::MIN_COMPONENTS..=max_components {
+        for y in Update::MIN_COMPONENTS..=max_components {
+            queries.push(vec![x, y]);
+        }
+    }
+
+    for x in Update::MIN_COMPONENTS..=max_components {
+        for y in Update::MIN_COMPONENTS..=max_components {
+            for z in Update::MIN_COMPONENTS..=max_components {
+                queries.push(vec![x, y, z]);
+            }
+        }
+    }
+
+    let mut resources = Vec::new();
+
+    for resource in Update::MIN_RESOURCE..=max_resources {
+        resources.push(resource);
+    }
+
+    let mut updates = Vec::new();
+
+    for query in queries.iter() {
+        for resource_count in resources.iter() {
+            updates.push(events_and_systems(&Update::new(
+                query.iter().cloned(),
+                *resource_count,
+            )));
+        }
+    }
+
+    let mut events = Vec::new();
+
+    for resource_count in resources.iter() {
+        let q =
+            resource_only_events_and_systems(&Update::new(vec![1].into_iter(), *resource_count));
+
+        events.push(q);
+    }
+
+    // updates.push(Update::new(vec![1].into_iter(), 0));
+
+    // let q = quote! {
+    //     #( #updates )*
+    // };
+
+    // panic!("{q}");
+
+    TokenStream::from(quote! {
+        #( #updates )*
+        #( #events )*
+    })
+}