sim_derive, models: Group generated functions in SerializableModel trait

Author: kirushyk

Cargo.toml

@@ -35,6 +35,7 @@ serde_yaml = "0.8"
 thiserror = "1.0"
 wasm-bindgen = "0.2.63"
 web-sys = { version = "0.3", features = [ "console" ] }
+sim_derive = { path = "sim_derive" }
 
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires

sim_derive/Cargo.toml

@@ -4,3 +4,7 @@ version = "0.7.1"
 
 [lib]
 proc-macro = true
+
+[dependencies]
+syn = "*"
+quote = "*"

sim_derive/src/lib.rs

@@ -1,6 +1,32 @@
+extern crate proc_macro;
+extern crate quote;
+extern crate syn;
+
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput};
 use proc_macro::TokenStream;
 
-#[proc_macro]
-pub fn make_answer(_item: TokenStream) -> TokenStream {
-    "fn answer() -> u32 { 42 }".parse().unwrap()
+#[proc_macro_derive(SerializableModel)]
+pub fn model(item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as DeriveInput);
+    let name = input.ident;
+    let tokens = quote! {
+        impl #name {
+            pub fn from_value(value: serde_yaml::Value) -> Option<Box<dyn AsModel>> {
+                match serde_yaml::from_value::<Self>(value) {
+                    Ok(model) => Some(Box::new(model)),
+                    Err(_) => None
+                }
+            }
+        }
+        impl SerializableModel for #name {
+            fn get_type(&self) -> &'static str {
+                stringify!(#name)
+            }
+            fn serialize(&self) -> serde_yaml::Value {
+                serde_yaml::to_value(self).unwrap_or(serde_yaml::Value::Null)
+            }
+        }
+    };
+    tokens.into()
 }

src/models/exclusive_gateway.rs

@@ -2,19 +2,21 @@ use std::f64::INFINITY;
 
 use serde::{Deserialize, Serialize};
 
-use super::model_trait::AsModel;
+use super::model_trait::{AsModel, SerializableModel};
 use super::ModelMessage;
 use crate::input_modeling::random_variable::IndexRandomVariable;
 use crate::simulator::Services;
 use crate::utils::error::SimulationError;
 use crate::utils::{populate_history_port, populate_snapshot_port};
 
+use sim_derive::SerializableModel;
+
 /// The exclusive gateway splits a process flow into a set of possible paths.
 /// The process will only follow one of the possible paths. Path selection is
 /// determined by Weighted Index distribution random variates, so this atomic
 /// model exhibits stochastic behavior. The exclusive gateway is a BPMN
 /// concept.
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, SerializableModel)]
 #[serde(rename_all = "camelCase")]
 pub struct ExclusiveGateway {
     ports_in: PortsIn,
@@ -111,13 +113,6 @@ impl ExclusiveGateway {
         }
     }
 
-    pub fn from_value(value: serde_yaml::Value) -> Option<Box<dyn AsModel>> {
-        match serde_yaml::from_value::<Self>(value) {
-            Ok(model) => Some(Box::new(model)),
-            Err(_) => None
-        }
-    }
-
     fn need_snapshot_metrics(&self) -> bool {
         self.ports_in.snapshot.is_some() && self.ports_out.snapshot.is_some()
     }
@@ -130,14 +125,6 @@ impl ExclusiveGateway {
 }
 
 impl AsModel for ExclusiveGateway {
-    fn get_type(&self) -> &'static str {
-        "ExclusiveGateway"
-    }
-
-    fn serialize(&self) -> serde_yaml::Value {
-        serde_yaml::to_value(self).unwrap_or(serde_yaml::Value::Null)
-    }
-
     fn status(&self) -> String {
         String::from("Active")
     }

src/models/gate.rs

@@ -2,19 +2,21 @@ use std::f64::INFINITY;
 
 use serde::{Deserialize, Serialize};
 
-use super::model_trait::AsModel;
+use super::model_trait::{AsModel, SerializableModel};
 use super::ModelMessage;
 use crate::simulator::Services;
 use crate::utils::error::SimulationError;
 use crate::utils::{populate_history_port, populate_snapshot_port};
 
+use sim_derive::SerializableModel;
+
 /// The gate model passes or blocks jobs, when it is in the open or closed
 /// state, respectively. The gate can be opened and closed throughout the
 /// course of a simulation. This model contains no stochastic behavior - job
 /// passing/blocking is based purely on the state of the model at that time
 /// in the simulation. A blocked job is a dropped job - it is not stored,
 /// queued, or redirected.
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, SerializableModel)]
 #[serde(rename_all = "camelCase")]
 pub struct Gate {
     ports_in: PortsIn,
@@ -136,13 +138,6 @@ impl Gate {
         }
     }
 
-    pub fn from_value(value: serde_yaml::Value) -> Option<Box<dyn AsModel>> {
-        match serde_yaml::from_value::<Self>(value) {
-            Ok(model) => Some(Box::new(model)),
-            Err(_) => None
-        }
-    }
-
     fn need_snapshot_metrics(&self) -> bool {
         self.ports_in.snapshot.is_some() && self.ports_out.snapshot.is_some()
     }
@@ -155,14 +150,6 @@ impl Gate {
 }
 
 impl AsModel for Gate {
-    fn get_type(&self) -> &'static str {
-        "Gate"
-    }
-
-    fn serialize(&self) -> serde_yaml::Value {
-        serde_yaml::to_value(self).unwrap_or(serde_yaml::Value::Null)
-    }
-    
     fn status(&self) -> String {
         match self.state.phase {
             Phase::Open => String::from("Listening"),

src/models/generator.rs

@@ -2,14 +2,16 @@ use std::f64::INFINITY;
 
 use serde::{Deserialize, Serialize};
 
-use super::model_trait::AsModel;
+use super::model_trait::{AsModel, SerializableModel};
 use super::ModelMessage;
 use crate::input_modeling::random_variable::ContinuousRandomVariable;
 use crate::input_modeling::Thinning;
 use crate::simulator::Services;
 use crate::utils::error::SimulationError;
 use crate::utils::{populate_history_port, populate_snapshot_port};
 
+use sim_derive::SerializableModel;
+
 /// The generator produces jobs based on a configured interarrival
 /// distribution. A normalized thinning function is used to enable
 /// non-stationary job generation. For non-stochastic generation of jobs, a
@@ -18,7 +20,7 @@ use crate::utils::{populate_history_port, populate_snapshot_port};
 /// produce jobs through perpetuity, and the generator does not receive
 /// messages or otherwise change behavior throughout a simulation (except
 /// through the thinning function).
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, SerializableModel)]
 #[serde(rename_all = "camelCase")]
 pub struct Generator {
     // Time between job generations
@@ -123,13 +125,6 @@ impl Generator {
             history: Default::default(),
         }
     }
-    
-    pub fn from_value(value: serde_yaml::Value) -> Option<Box<dyn AsModel>> {
-        match serde_yaml::from_value::<Self>(value) {
-            Ok(model) => Some(Box::new(model)),
-            Err(_) => None
-        }
-    }
 
     fn need_snapshot_metrics(&self) -> bool {
         self.ports_in.snapshot.is_some() && self.ports_out.snapshot.is_some()
@@ -143,14 +138,6 @@ impl Generator {
 }
 
 impl AsModel for Generator {
-    fn get_type(&self) -> &'static str {
-        "Generator"
-    }
-
-    fn serialize(&self) -> serde_yaml::Value {
-        serde_yaml::to_value(self).unwrap_or(serde_yaml::Value::Null)
-    }
-    
     fn status(&self) -> String {
         format!["Generating {}s", self.ports_out.job]
     }

src/models/load_balancer.rs

@@ -2,15 +2,17 @@ use std::f64::INFINITY;
 
 use serde::{Deserialize, Serialize};
 
-use super::model_trait::AsModel;
+use super::model_trait::{AsModel, SerializableModel};
 use super::ModelMessage;
 use crate::simulator::Services;
 use crate::utils::error::SimulationError;
 use crate::utils::{populate_history_port, populate_snapshot_port};
 
+use sim_derive::SerializableModel;
+
 /// The load balancer routes jobs to a set of possible process paths, using a
 /// round robin strategy. There is no stochastic behavior in this model.
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, SerializableModel)]
 #[serde(rename_all = "camelCase")]
 pub struct LoadBalancer {
     ports_in: PortsIn,
@@ -107,13 +109,6 @@ impl LoadBalancer {
             history: Default::default(),
         }
     }
-    
-    pub fn from_value(value: serde_yaml::Value) -> Option<Box<dyn AsModel>> {
-        match serde_yaml::from_value::<Self>(value) {
-            Ok(model) => Some(Box::new(model)),
-            Err(_) => None
-        }
-    }
 
     fn need_snapshot_metrics(&self) -> bool {
         self.ports_in.snapshot.is_some() && self.ports_out.snapshot.is_some()
@@ -127,14 +122,6 @@ impl LoadBalancer {
 }
 
 impl AsModel for LoadBalancer {
-    fn get_type(&self) -> &'static str {
-        "LoadBalancer"
-    }
-    
-    fn serialize(&self) -> serde_yaml::Value {
-        serde_yaml::to_value(self).unwrap_or(serde_yaml::Value::Null)
-    }
-    
     fn status(&self) -> String {
         format!["Listening for {}s", self.ports_in.job]
     }

src/models/model.rs

@@ -1,7 +1,7 @@
 use serde::{Serialize, Serializer, Deserialize, Deserializer};
 use serde::ser::SerializeMap;
 
-use super::model_trait::AsModel;
+use super::model_trait::{AsModel, SerializableModel};
 use super::ModelMessage;
 use crate::simulator::Services;
 use crate::utils::error::SimulationError;
@@ -48,6 +48,8 @@ impl<'de> Deserialize<'de> for Model {
     }
 }
 
+impl SerializableModel for Model {}
+
 impl AsModel for Model {
     fn status(&self) -> String {
         self.inner.status()

src/models/model_trait.rs

@@ -21,19 +21,22 @@ impl Clone for Box<dyn AsModel> {
     }
 }
 
+pub trait SerializableModel {
+    fn get_type(&self) -> &'static str {
+        "Model"
+    }
+    fn serialize(&self) -> serde_yaml::Value {
+        serde_yaml::Value::Null
+    }
+}
+
 /// The `AsModel` trait defines everything required for a model to operate
 /// within the discrete event simulation.  The simulator formalism (Discrete
 /// Event System Specification) requires `events_ext`, `events_int`,
 /// `time_advance`, and `until_next_event`.  The additional `status` is for
 /// facilitation of simulation reasoning, reporting, and debugging.
 // #[enum_dispatch]
-pub trait AsModel: ModelClone {
-    fn get_type(&self) -> &'static str {
-        ""
-    }
-    fn serialize(&self) -> serde_yaml::Value {
-        serde_yaml::Value::Null
-    }
+pub trait AsModel: ModelClone + SerializableModel {
     fn status(&self) -> String;
     fn events_ext(
         &mut self,

src/models/parallel_gateway.rs

@@ -3,17 +3,19 @@ use std::f64::INFINITY;
 
 use serde::{Deserialize, Serialize};
 
-use super::model_trait::AsModel;
+use super::model_trait::{AsModel, SerializableModel};
 use super::ModelMessage;
 use crate::simulator::Services;
 use crate::utils::error::SimulationError;
 use crate::utils::{populate_history_port, populate_snapshot_port};
 
+use sim_derive::SerializableModel;
+
 /// The parallel gateway splits a job across multiple processing paths. The
 /// job is duplicated across every one of the processing paths. In addition
 /// to splitting the process, a second parallel gateway can be used to join
 /// the split paths. The parallel gateway is a BPMN concept.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, SerializableModel)]
 #[serde(rename_all = "camelCase")]
 pub struct ParallelGateway {
     ports_in: PortsIn,
@@ -113,13 +115,6 @@ impl ParallelGateway {
             history: Default::default(),
         }
     }
-    
-    pub fn from_value(value: serde_yaml::Value) -> Option<Box<dyn AsModel>> {
-        match serde_yaml::from_value::<Self>(value) {
-            Ok(model) => Some(Box::new(model)),
-            Err(_) => None
-        }
-    }
 
     fn need_snapshot_metrics(&self) -> bool {
         self.ports_in.snapshot.is_some() && self.ports_out.snapshot.is_some()
@@ -133,14 +128,6 @@ impl ParallelGateway {
 }
 
 impl AsModel for ParallelGateway {
-    fn get_type(&self) -> &'static str {
-        "ParallelGateway"
-    }
-    
-    fn serialize(&self) -> serde_yaml::Value {
-        serde_yaml::to_value(self).unwrap_or(serde_yaml::Value::Null)
-    }
-    
     fn status(&self) -> String {
         String::from("Active")
     }