genenums: support default & remove usage of HashMap as it doesn't kee…

…p insertion order and isn't consistent
DioxusLabs · Sep 2, 2024 · 1735861 · 1735861
1 parent efebe81
commit 1735861
Show file tree

Hide file tree

Showing 4 changed files with 164 additions and 130 deletions.
diff --git a/bindings/java/src/enums.rs b/bindings/java/src/enums.rs
@@ -1,179 +1,179 @@
+use taffy::AbsoluteAxis;
+use taffy::AlignItems;
+use taffy::AlignContent;
 use taffy::FlexDirection;
+use taffy::FlexWrap;
+use taffy::GridAutoFlow;
 use taffy::TextAlign;
-use taffy::Display;
-use taffy::Position;
+use taffy::Overflow;
 use taffy::BoxSizing;
+use taffy::Position;
 use taffy::BoxGenerationMode;
-use taffy::AlignItems;
-use taffy::AbsoluteAxis;
-use taffy::GridAutoFlow;
-use taffy::FlexWrap;
-use taffy::Overflow;
-use taffy::AlignContent;
+use taffy::Display;
 use crate::traits::FromJavaEnum;
 
-impl FromJavaEnum<AlignContent> for AlignContent {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AlignContent;";
+impl FromJavaEnum<Display> for Display {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Display;";
 
- fn from_ordinal(internal: i32) -> Option<AlignContent> {
+ fn from_ordinal(internal: i32) -> Option<Display> {
  Some(match internal {
- 0 => AlignContent::Start,
- 1 => AlignContent::End,
- 2 => AlignContent::FlexStart,
- 3 => AlignContent::FlexEnd,
- 4 => AlignContent::Center,
- 5 => AlignContent::Stretch,
- 6 => AlignContent::SpaceBetween,
- 7 => AlignContent::SpaceEvenly,
- 8 => AlignContent::SpaceAround,
- _ => panic!("Invalid value: {internal}"),
+ 0 => Display::Block,
+ 1 => Display::Flex,
+ 2 => Display::Grid,
+ 3 => Display::None,
+ _ => Display::default(),
  })
  }
 }
 
-impl FromJavaEnum<Overflow> for Overflow {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Overflow;";
+impl FromJavaEnum<BoxGenerationMode> for BoxGenerationMode {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/BoxGenerationMode;";
 
- fn from_ordinal(internal: i32) -> Option<Overflow> {
+ fn from_ordinal(internal: i32) -> Option<BoxGenerationMode> {
  Some(match internal {
- 0 => Overflow::Visible,
- 1 => Overflow::Clip,
- 2 => Overflow::Hidden,
- 3 => Overflow::Scroll,
- _ => panic!("Invalid value: {internal}"),
+ 0 => BoxGenerationMode::Normal,
+ 1 => BoxGenerationMode::None,
+ _ => BoxGenerationMode::default(),
  })
  }
 }
 
-impl FromJavaEnum<FlexWrap> for FlexWrap {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/FlexWrap;";
+impl FromJavaEnum<Position> for Position {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Position;";
 
- fn from_ordinal(internal: i32) -> Option<FlexWrap> {
+ fn from_ordinal(internal: i32) -> Option<Position> {
  Some(match internal {
- 0 => FlexWrap::NoWrap,
- 1 => FlexWrap::Wrap,
- 2 => FlexWrap::WrapReverse,
- _ => panic!("Invalid value: {internal}"),
+ 0 => Position::Relative,
+ 1 => Position::Absolute,
+ _ => Position::default(),
  })
  }
 }
 
-impl FromJavaEnum<GridAutoFlow> for GridAutoFlow {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/GridAutoFlow;";
+impl FromJavaEnum<BoxSizing> for BoxSizing {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/BoxSizing;";
 
- fn from_ordinal(internal: i32) -> Option<GridAutoFlow> {
+ fn from_ordinal(internal: i32) -> Option<BoxSizing> {
  Some(match internal {
- 0 => GridAutoFlow::Row,
- 1 => GridAutoFlow::Column,
- 2 => GridAutoFlow::RowDense,
- 3 => GridAutoFlow::ColumnDense,
- _ => panic!("Invalid value: {internal}"),
+ 0 => BoxSizing::BorderBox,
+ 1 => BoxSizing::ContentBox,
+ _ => BoxSizing::default(),
  })
  }
 }
 
-impl FromJavaEnum<AbsoluteAxis> for AbsoluteAxis {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AbsoluteAxis;";
+impl FromJavaEnum<Overflow> for Overflow {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Overflow;";
 
- fn from_ordinal(internal: i32) -> Option<AbsoluteAxis> {
+ fn from_ordinal(internal: i32) -> Option<Overflow> {
  Some(match internal {
- 0 => AbsoluteAxis::Horizontal,
- 1 => AbsoluteAxis::Vertical,
- _ => panic!("Invalid value: {internal}"),
+ 0 => Overflow::Visible,
+ 1 => Overflow::Clip,
+ 2 => Overflow::Hidden,
+ 3 => Overflow::Scroll,
+ _ => Overflow::default(),
  })
  }
 }
 
-impl FromJavaEnum<AlignItems> for AlignItems {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AlignItems;";
+impl FromJavaEnum<TextAlign> for TextAlign {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/TextAlign;";
 
- fn from_ordinal(internal: i32) -> Option<AlignItems> {
+ fn from_ordinal(internal: i32) -> Option<TextAlign> {
  Some(match internal {
- 0 => AlignItems::Start,
- 1 => AlignItems::End,
- 2 => AlignItems::FlexStart,
- 3 => AlignItems::FlexEnd,
- 4 => AlignItems::Center,
- 5 => AlignItems::Baseline,
- 6 => AlignItems::Stretch,
- _ => panic!("Invalid value: {internal}"),
+ 0 => TextAlign::Auto,
+ 1 => TextAlign::LegacyLeft,
+ 2 => TextAlign::LegacyRight,
+ 3 => TextAlign::LegacyCenter,
+ _ => TextAlign::default(),
  })
  }
 }
 
-impl FromJavaEnum<BoxGenerationMode> for BoxGenerationMode {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/BoxGenerationMode;";
+impl FromJavaEnum<GridAutoFlow> for GridAutoFlow {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/GridAutoFlow;";
 
- fn from_ordinal(internal: i32) -> Option<BoxGenerationMode> {
+ fn from_ordinal(internal: i32) -> Option<GridAutoFlow> {
  Some(match internal {
- 0 => BoxGenerationMode::Normal,
- 1 => BoxGenerationMode::None,
- _ => panic!("Invalid value: {internal}"),
+ 0 => GridAutoFlow::Row,
+ 1 => GridAutoFlow::Column,
+ 2 => GridAutoFlow::RowDense,
+ 3 => GridAutoFlow::ColumnDense,
+ _ => GridAutoFlow::default(),
  })
  }
 }
 
-impl FromJavaEnum<BoxSizing> for BoxSizing {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/BoxSizing;";
+impl FromJavaEnum<FlexWrap> for FlexWrap {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/FlexWrap;";
 
- fn from_ordinal(internal: i32) -> Option<BoxSizing> {
+ fn from_ordinal(internal: i32) -> Option<FlexWrap> {
  Some(match internal {
- 0 => BoxSizing::BorderBox,
- 1 => BoxSizing::ContentBox,
- _ => panic!("Invalid value: {internal}"),
+ 0 => FlexWrap::NoWrap,
+ 1 => FlexWrap::Wrap,
+ 2 => FlexWrap::WrapReverse,
+ _ => FlexWrap::default(),
  })
  }
 }
 
-impl FromJavaEnum<Position> for Position {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Position;";
+impl FromJavaEnum<FlexDirection> for FlexDirection {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/FlexDirection;";
 
- fn from_ordinal(internal: i32) -> Option<Position> {
+ fn from_ordinal(internal: i32) -> Option<FlexDirection> {
  Some(match internal {
- 0 => Position::Relative,
- 1 => Position::Absolute,
- _ => panic!("Invalid value: {internal}"),
+ 0 => FlexDirection::Row,
+ 1 => FlexDirection::Column,
+ 2 => FlexDirection::RowReverse,
+ 3 => FlexDirection::ColumnReverse,
+ _ => FlexDirection::default(),
  })
  }
 }
 
-impl FromJavaEnum<Display> for Display {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/Display;";
+impl FromJavaEnum<AlignContent> for AlignContent {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AlignContent;";
 
- fn from_ordinal(internal: i32) -> Option<Display> {
+ fn from_ordinal(internal: i32) -> Option<AlignContent> {
  Some(match internal {
- 0 => Display::Block,
- 1 => Display::Flex,
- 2 => Display::Grid,
- 3 => Display::None,
+ 0 => AlignContent::Start,
+ 1 => AlignContent::End,
+ 2 => AlignContent::FlexStart,
+ 3 => AlignContent::FlexEnd,
+ 4 => AlignContent::Center,
+ 5 => AlignContent::Stretch,
+ 6 => AlignContent::SpaceBetween,
+ 7 => AlignContent::SpaceEvenly,
+ 8 => AlignContent::SpaceAround,
  _ => panic!("Invalid value: {internal}"),
  })
  }
 }
 
-impl FromJavaEnum<TextAlign> for TextAlign {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/TextAlign;";
+impl FromJavaEnum<AlignItems> for AlignItems {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AlignItems;";
 
- fn from_ordinal(internal: i32) -> Option<TextAlign> {
+ fn from_ordinal(internal: i32) -> Option<AlignItems> {
  Some(match internal {
- 0 => TextAlign::Auto,
- 1 => TextAlign::LegacyLeft,
- 2 => TextAlign::LegacyRight,
- 3 => TextAlign::LegacyCenter,
+ 0 => AlignItems::Start,
+ 1 => AlignItems::End,
+ 2 => AlignItems::FlexStart,
+ 3 => AlignItems::FlexEnd,
+ 4 => AlignItems::Center,
+ 5 => AlignItems::Baseline,
+ 6 => AlignItems::Stretch,
  _ => panic!("Invalid value: {internal}"),
  })
  }
 }
 
-impl FromJavaEnum<FlexDirection> for FlexDirection {
- const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/FlexDirection;";
+impl FromJavaEnum<AbsoluteAxis> for AbsoluteAxis {
+ const JAVA_CLASS: &'static str = "Lcom/dioxuslabs/taffy/enums/AbsoluteAxis;";
 
- fn from_ordinal(internal: i32) -> Option<FlexDirection> {
+ fn from_ordinal(internal: i32) -> Option<AbsoluteAxis> {
  Some(match internal {
- 0 => FlexDirection::Row,
- 1 => FlexDirection::Column,
- 2 => FlexDirection::RowReverse,
- 3 => FlexDirection::ColumnReverse,
+ 0 => AbsoluteAxis::Horizontal,
+ 1 => AbsoluteAxis::Vertical,
  _ => panic!("Invalid value: {internal}"),
  })
  }

diff --git a/scripts/genenums/src/generators/java.rs b/scripts/genenums/src/generators/java.rs
@@ -1,7 +1,6 @@
 use std::fs;
 use std::fs::File;
 use std::io::Write;
-use std::path::Path;
 
 pub(crate) fn create_java_enum(name: &str, values: &[&str]) {
  use convert_case::{Case, Casing};

diff --git a/scripts/genenums/src/main.rs b/scripts/genenums/src/main.rs
@@ -1,34 +1,66 @@
-use std::collections::HashMap;
-use std::fs;
 use crate::generators::java::create_java_enum;
 use crate::transformers::java::create_java_tranformer;
+use std::fs;
 
 mod generators;
 mod transformers;
 
+struct RustEnum<'local> {
+ name: &'local str,
+ values: Vec<&'local str>,
+ default: bool,
+}
+
 fn main() {
  fs::remove_file("./bindings/java/src/enums.rs").expect("Error: Unable to remove java/src/enums.rs file");
 
- let mut enums: HashMap<&str, Vec<&str>> = HashMap::new();
- enums.insert("Display", vec!["Block", "Flex", "Grid", "None"]);
- enums.insert("BoxGenerationMode", vec!["Normal", "None"]);
- enums.insert("Position", vec!["Relative", "Absolute"]);
- enums.insert("BoxSizing", vec!["BorderBox", "ContentBox"]);
- enums.insert("Overflow", vec!["Visible", "Clip", "Hidden", "Scroll"]);
- enums.insert("TextAlign", vec!["Auto", "LegacyLeft", "LegacyRight", "LegacyCenter"]);
- enums.insert("GridAutoFlow", vec!["Row", "Column", "RowDense", "ColumnDense"]);
- enums.insert("FlexWrap", vec!["NoWrap", "Wrap", "WrapReverse"]);
- enums.insert("FlexDirection", vec!["Row", "Column", "RowReverse", "ColumnReverse"]);
- enums.insert(
- "AlignContent",
- vec!["Start", "End", "FlexStart", "FlexEnd", "Center", "Stretch", "SpaceBetween", "SpaceEvenly", "SpaceAround"],
- );
- enums.insert("AlignItems", vec!["Start", "End", "FlexStart", "FlexEnd", "Center", "Baseline", "Stretch"]);
- enums.insert("AbsoluteAxis", vec!["Horizontal", "Vertical"]);
-
- for (key, value) in enums.into_iter() {
- create_enum(key, &value);
- create_transformer(key, &value);
+ let mut enums: Vec<RustEnum> = Vec::new();
+ enums.push(RustEnum { name: "Display", values: vec!["Block", "Flex", "Grid", "None"], default: true });
+ enums.push(RustEnum { name: "BoxGenerationMode", values: vec!["Normal", "None"], default: true });
+ enums.push(RustEnum { name: "Position", values: vec!["Relative", "Absolute"], default: true });
+ enums.push(RustEnum { name: "BoxSizing", values: vec!["BorderBox", "ContentBox"], default: true });
+ enums.push(RustEnum { name: "Overflow", values: vec!["Visible", "Clip", "Hidden", "Scroll"], default: true });
+ enums.push(RustEnum {
+ name: "TextAlign",
+ values: vec!["Auto", "LegacyLeft", "LegacyRight", "LegacyCenter"],
+ default: true,
+ });
+ enums.push(RustEnum {
+ name: "GridAutoFlow",
+ values: vec!["Row", "Column", "RowDense", "ColumnDense"],
+ default: true,
+ });
+ enums.push(RustEnum { name: "FlexWrap", values: vec!["NoWrap", "Wrap", "WrapReverse"], default: true });
+ enums.push(RustEnum {
+ name: "FlexDirection",
+ values: vec!["Row", "Column", "RowReverse", "ColumnReverse"],
+ default: true,
+ });
+ enums.push(RustEnum {
+ name: "AlignContent",
+ values: vec![
+ "Start",
+ "End",
+ "FlexStart",
+ "FlexEnd",
+ "Center",
+ "Stretch",
+ "SpaceBetween",
+ "SpaceEvenly",
+ "SpaceAround",
+ ],
+ default: false,
+ });
+ enums.push(RustEnum {
+ name: "AlignItems",
+ values: vec!["Start", "End", "FlexStart", "FlexEnd", "Center", "Baseline", "Stretch"],
+ default: false,
+ });
+ enums.push(RustEnum { name: "AbsoluteAxis", values: vec!["Horizontal", "Vertical"], default: false });
+
+ for value in enums.into_iter() {
+ create_enum(value.name, &value.values);
+ create_transformer(value.name, &value.values, value.default);
  }
 }
 
@@ -40,8 +72,6 @@ fn create_enum(name: &str, values: &[&str]) {
 
 /// Transformer generators
 
-fn create_transformer(name: &str, values: &[&str]) {
- create_java_tranformer(name, values);
+fn create_transformer(name: &str, values: &[&str], default: bool) {
+ create_java_tranformer(name, values, default);
 }
-
-