model: Implement cloning of box with concrete Model object

Author: kirushyk

src/models/model.rs

@@ -1,10 +1,6 @@
 use serde::{Serialize, Serializer, Deserialize, Deserializer};
 use serde::ser::SerializeMap;
-use serde_json::Value;
 use serde::de::{self, Unexpected};
-use std::rc::Rc;
-use std::cell::RefCell;
-use std::collections::HashMap;
 
 use super::ModelMessage;
 use crate::input_modeling::UniformRNG;
@@ -13,13 +9,14 @@ use crate::utils::error::SimulationError;
 /// `Model` wraps `model_type` and provides common ID functionality (a struct
 /// field and associated accessor method).  The simulator requires all models
 /// to have an ID.
+#[derive(Clone)]
 pub struct Model {
     id: String,
-    inner: Rc<RefCell<dyn AsModel>>,
+    inner: Box<dyn AsModel>,
 }
 
 impl Model {
-    pub fn new(id: String, inner: Rc<RefCell<dyn AsModel>>) -> Self {
+    pub fn new(id: String, inner: Box<dyn AsModel>) -> Self {
         Self { id, inner }
     }
 
@@ -28,22 +25,31 @@ impl Model {
     }
 }
 
-impl Clone for Model {
-    fn clone(&self) -> Self {
-        // Fix self.inner cloning
-        Model {
-            id: self.id.clone(),
-            inner: self.inner.clone()
-        }
+pub trait ModelClone {
+    fn clone_box(&self) -> Box<dyn AsModel>;
+}
+
+impl<T> ModelClone for T
+where
+    T: 'static + AsModel + Clone,
+{
+    fn clone_box(&self) -> Box<dyn AsModel> {
+        Box::new(self.clone())
+    }
+}
+
+impl Clone for Box<dyn AsModel> {
+    fn clone(&self) -> Box<dyn AsModel> {
+        self.clone_box()
     }
 }
 
 impl Serialize for Model {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let extra_fields: serde_json::Value = self.inner.borrow().serialize();
+        let extra_fields: serde_json::Value = self.inner.serialize();
         let mut model = serializer.serialize_map(None)?;
         model.serialize_entry("id", &self.id)?;
-        model.serialize_entry("type", self.inner.borrow().get_type())?;
+        model.serialize_entry("type", self.inner.get_type())?;
         if let serde_json::Value::Object(map) = extra_fields {
             for (key, value) in map.iter() {
                 model.serialize_entry(&key, &value)?;
@@ -63,10 +69,11 @@ impl<'de> Deserialize<'de> for Model {
         match &model_extra.model_type[..] {
             "Generator" => {
                 if let Ok(generator) = serde_json::from_value::<super::Generator>(model_extra.extra) {
-                    Ok(Model::new(
+                    let model = Model::new(
                         model_extra.id,
-                        Rc::new(RefCell::new(generator))
-                    ))
+                        Box::new(generator)
+                    );
+                    Ok(model)
                 } else {
                     Err(de::Error::invalid_value(Unexpected::Other("Generator"), &"Generator"))
                 }
@@ -75,7 +82,7 @@ impl<'de> Deserialize<'de> for Model {
                 if let Ok(exclusive_gateway) = serde_json::from_value::<super::ExclusiveGateway>(model_extra.extra) {
                     Ok(Model::new(
                         model_extra.id,
-                        Rc::new(RefCell::new(exclusive_gateway))
+                        Box::new(exclusive_gateway)
                     ))
                 } else {
                     Err(de::Error::invalid_value(Unexpected::Other("ExclusiveGateway"), &"ExclusiveGateway"))
@@ -85,7 +92,7 @@ impl<'de> Deserialize<'de> for Model {
                 if let Ok(processor) = serde_json::from_value::<super::Processor>(model_extra.extra) {
                     Ok(Model::new(
                         model_extra.id,
-                        Rc::new(RefCell::new(processor))
+                        Box::new(processor)
                     ))
                 } else {
                     Err(de::Error::invalid_value(Unexpected::Other("Processor"), &"Processor"))
@@ -95,7 +102,7 @@ impl<'de> Deserialize<'de> for Model {
                 if let Ok(storage) = serde_json::from_value::<super::Storage>(model_extra.extra) {
                     Ok(Model::new(
                         model_extra.id,
-                        Rc::new(RefCell::new(storage))
+                        Box::new(storage)
                     ))
                 } else {
                     Err(de::Error::invalid_value(Unexpected::Other("Storage"), &"Storage"))
@@ -110,30 +117,30 @@ impl<'de> Deserialize<'de> for Model {
 
 impl AsModel for Model {
     fn status(&self) -> String {
-        self.inner.borrow().status()
+        self.inner.status()
     }
 
     fn events_ext(
         &mut self,
         uniform_rng: &mut UniformRNG,
         incoming_message: ModelMessage,
     ) -> Result<Vec<ModelMessage>, SimulationError> {
-        self.inner.borrow_mut().events_ext(uniform_rng, incoming_message)
+        self.inner.events_ext(uniform_rng, incoming_message)
     }
 
     fn events_int(
         &mut self,
         uniform_rng: &mut UniformRNG,
     ) -> Result<Vec<ModelMessage>, SimulationError> {
-        self.inner.borrow_mut().events_int(uniform_rng)
+        self.inner.events_int(uniform_rng)
     }
 
     fn time_advance(&mut self, time_delta: f64) {
-        self.inner.borrow_mut().time_advance(time_delta)
+        self.inner.time_advance(time_delta)
     }
 
     fn until_next_event(&self) -> f64 {
-        self.inner.borrow_mut().until_next_event()
+        self.inner.until_next_event()
     }
 }
 
@@ -143,7 +150,7 @@ impl AsModel for Model {
 /// `time_advance`, and `until_next_event`.  The additional `status` is for
 /// facilitation of simulation reasoning, reporting, and debugging.
 // #[enum_dispatch]
-pub trait AsModel {
+pub trait AsModel: ModelClone {
     fn get_type(&self) -> &'static str {
         ""
     }