Serialization changes

src/display/renderer.rs

@@ -183,7 +183,7 @@ impl<'a> Renderer<'a> {
 /// Trait for objects that can be rendered into a html page.
 /// Since this uses [minijinja] the [serde::Serialize] trait is also needed.
 /// Each object that implements this trait should have a corresponding template file in the templates folder.
-pub trait Renderable: Serialize + GameObjectDerived {
+pub trait Renderable: Serialize + Cullable {
     /// Returns the template file name.
     /// This method is used to retrieve the template from the [Environment] object in the [Renderer] object.
     fn get_template() -> &'static str;

src/display/timeline.rs

@@ -235,21 +235,19 @@ impl Serialize for Timeline {
         let ref_lifespans: Vec<(DerivedRef<Title>, Vec<(u32, u32)>)> = self
             .lifespans
             .iter()
-            .map(|(t, v)| (DerivedRef::from_derived(t.clone()), v.clone()))
+            .map(|(t, v)| (DerivedRef::from(t.clone()), v.clone()))
             .collect();
         state.serialize_field("lifespans", &ref_lifespans)?;
         state.serialize_field("latest_event", &self.latest_event)?;
         let mut ref_events = Vec::new();
         for events in &self.events {
             let (year, char, title, event_type, difference) = events;
-            let ref_char = DerivedRef::from_derived(char.clone());
-            let ref_title = DerivedRef::from_derived(title.clone());
+            let ref_char = DerivedRef::from(char.clone());
+            let ref_title = DerivedRef::from(title.clone());
             let ref_diff = match difference {
-                RealmDifference::Faith(f) => {
-                    RealmDifferenceRef::Faith(DerivedRef::from_derived(f.clone()))
-                }
+                RealmDifference::Faith(f) => RealmDifferenceRef::Faith(DerivedRef::from(f.clone())),
                 RealmDifference::Culture(c) => {
-                    RealmDifferenceRef::Culture(DerivedRef::from_derived(c.clone()))
+                    RealmDifferenceRef::Culture(DerivedRef::from(c.clone()))
                 }
             };
             ref_events.push((

src/parser/game_state.rs

@@ -139,7 +139,7 @@ impl GameState {
             let entry = self.contract_transform.get(contract_id).unwrap();
             entry.get_internal_mut().init(char);
         } else {
-            let r = Shared::wrap(DerivedRef::from_derived(char));
+            let r = Shared::wrap(DerivedRef::from(char));
             self.contract_transform.insert(*contract_id, r);
         }
     }

src/structures/artifact.rs

@@ -1,14 +1,41 @@
-use serde::{ser::SerializeStruct, Serialize};
+use serde::{ser::SerializeSeq, Serialize, Serializer};
 
 use super::{
     super::{
         display::{Cullable, Localizable, Localizer, RenderableType},
         parser::{GameId, GameObjectMap, GameState, GameString, ParsingError},
         types::{Shared, WrapperMut},
     },
-    Character, DerivedRef, DummyInit, GameObjectDerived,
+    serialize_ref, Character, DerivedRef, DummyInit, GameObjectDerived,
 };
 
+fn serialize_history<S: Serializer>(
+    val: &Vec<(
+        GameString,
+        GameString,
+        Option<Shared<Character>>,
+        Option<Shared<Character>>,
+    )>,
+    s: S,
+) -> Result<S::Ok, S::Error> {
+    let mut seq = s.serialize_seq(Some(val.len()))?;
+    for (r#type, date, actor, recipient) in val {
+        let actor = if let Some(actor) = actor {
+            Some(DerivedRef::from(actor.clone()))
+        } else {
+            None
+        };
+        let recipient = if let Some(recipient) = recipient {
+            Some(DerivedRef::from(recipient.clone()))
+        } else {
+            None
+        };
+        seq.serialize_element(&(r#type, date, actor, recipient))?;
+    }
+    seq.end()
+}
+
+#[derive(Serialize)]
 pub struct Artifact {
     id: GameId,
     name: Option<GameString>,
@@ -17,7 +44,9 @@ pub struct Artifact {
     rarity: Option<GameString>,
     quality: u32,
     wealth: u32,
+    #[serde(serialize_with = "serialize_ref")]
     owner: Option<Shared<Character>>,
+    #[serde(serialize_with = "serialize_history")]
     history: Vec<(
         GameString,
         GameString,
@@ -156,43 +185,6 @@ impl Artifact {
     }
 }
 
-impl Serialize for Artifact {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_struct("Artifact", 7)?;
-        state.serialize_field("id", &self.id)?;
-        state.serialize_field("name", &self.name)?;
-        state.serialize_field("description", &self.description)?;
-        state.serialize_field("type", &self.r#type)?;
-        state.serialize_field("rarity", &self.rarity)?;
-        state.serialize_field("quality", &self.quality)?;
-        state.serialize_field("wealth", &self.wealth)?;
-        let mut serialized_history: Vec<(
-            GameString,
-            GameString,
-            Option<DerivedRef<Character>>,
-            Option<DerivedRef<Character>>,
-        )> = Vec::new();
-        for h in self.history.iter() {
-            let actor = if let Some(actor) = &h.2 {
-                Some(DerivedRef::from_derived(actor.clone()))
-            } else {
-                None
-            };
-            let recipient = if let Some(recipient) = &h.3 {
-                Some(DerivedRef::from_derived(recipient.clone()))
-            } else {
-                None
-            };
-            serialized_history.push((h.0.clone(), h.1.clone(), actor, recipient));
-        }
-        state.serialize_field("history", &serialized_history)?;
-        state.end()
-    }
-}
-
 // Comparing implementations so that we can sort artifacts by quality and wealth
 
 impl PartialEq for Artifact {

src/structures/character.rs

@@ -10,8 +10,9 @@ use super::{
         parser::{GameObjectMap, GameState, GameString, ParsingError, SaveFileValue},
         types::{OneOrMany, Wrapper, WrapperMut},
     },
-    serialize_array, Artifact, Culture, DerivedRef, DummyInit, Dynasty, Faith, GameId,
-    GameObjectDerived, Memory, Shared, Title,
+    derived_ref::into_ref_array,
+    Artifact, Culture, DerivedRef, DummyInit, Dynasty, Faith, GameId, GameObjectDerived, Memory,
+    Shared, Title,
 };
 
 /// An enum that holds either a character or a reference to a character.
@@ -375,7 +376,7 @@ impl DummyInit for Character {
                     if let Ok(mut o) = liege_chr.try_get_internal_mut() {
                         o.add_vassal(game_state.get_character(&self.id));
                     }
-                    self.liege = Some(DerivedRef::<Character>::from_derived(liege_chr.clone()));
+                    self.liege = Some(DerivedRef::<Character>::from(liege_chr.clone()));
                 }
             }
         }
@@ -596,7 +597,7 @@ impl Serialize for Character {
         let mut faith = self.faith.clone();
         let mut culture = self.culture.clone();
         if let Some(house) = &self.house {
-            let rd = DerivedRef::<Dynasty>::from_derived(house.clone());
+            let rd = DerivedRef::from(house.clone());
             state.serialize_field("house", &rd)?;
             if faith.is_none() {
                 let o = house.get_internal();
@@ -608,51 +609,51 @@ impl Serialize for Character {
             }
         }
         if let Some(faith) = faith {
-            let rf = DerivedRef::<Faith>::from_derived(faith.clone());
+            let rf = DerivedRef::<Faith>::from(faith.clone());
             state.serialize_field("faith", &rf)?;
         }
         if let Some(culture) = culture {
-            let rc = DerivedRef::<Culture>::from_derived(culture.clone());
+            let rc = DerivedRef::<Culture>::from(culture.clone());
             state.serialize_field("culture", &rc)?;
         }
         state.serialize_field("skills", &self.skills)?;
         state.serialize_field("traits", &self.traits)?;
         state.serialize_field("recessive", &self.recessive)?;
         //serialize spouses as DerivedRef
-        let spouses = serialize_array::<Character>(&self.spouses);
+        let spouses = into_ref_array::<Character>(&self.spouses);
         state.serialize_field("spouses", &spouses)?;
         //serialize former as DerivedRef
-        let former = serialize_array::<Character>(&self.former);
+        let former = into_ref_array::<Character>(&self.former);
         state.serialize_field("former", &former)?;
         //serialize children as DerivedRef
-        let children = serialize_array::<Character>(&self.children);
+        let children = into_ref_array::<Character>(&self.children);
         state.serialize_field("children", &children)?;
         //serialize parents as DerivedRef
-        let parents = serialize_array::<Character>(&self.parents);
+        let parents = into_ref_array::<Character>(&self.parents);
         state.serialize_field("parents", &parents)?;
         state.serialize_field("dna", &self.dna)?;
         //serialize memories as DerivedRef
         state.serialize_field("memories", &self.memories)?;
         //serialize titles as DerivedRef
-        let titles = serialize_array::<Title>(&self.titles);
+        let titles = into_ref_array::<Title>(&self.titles);
         state.serialize_field("titles", &titles)?;
         state.serialize_field("gold", &self.gold)?;
         state.serialize_field("piety", &self.piety)?;
         state.serialize_field("prestige", &self.prestige)?;
         state.serialize_field("dread", &self.dread)?;
         state.serialize_field("strength", &self.strength)?;
         //serialize kills as DerivedRef
-        let kills = serialize_array::<Character>(&self.kills);
+        let kills = into_ref_array::<Character>(&self.kills);
         state.serialize_field("kills", &kills)?;
         state.serialize_field("languages", &self.languages)?;
         let mut vassals = Vec::new();
         for vassal in self.vassals.iter() {
             match vassal {
                 Vassal::Character(c) => {
-                    vassals.push(DerivedRef::from_derived(c.clone()));
+                    vassals.push(DerivedRef::from(c.clone()));
                 }
                 Vassal::Reference(c) => {
-                    vassals.push(DerivedRef::from_derived(c.get_internal().get_ref().clone()))
+                    vassals.push(DerivedRef::from(c.get_internal().get_ref().clone()))
                 }
             }
         }

src/structures/culture.rs

@@ -1,4 +1,4 @@
-use serde::{ser::SerializeStruct, Serialize};
+use serde::Serialize;
 
 use super::{
     super::{
@@ -10,18 +10,21 @@ use super::{
         parser::{GameId, GameObjectMap, GameState, GameString, ParsingError},
         types::{OneOrMany, Wrapper, WrapperMut},
     },
-    serialize_array, DummyInit, GameObjectDerived, Shared,
+    serialize_array_ref, DummyInit, GameObjectDerived, Shared,
 };
 
 /// A struct representing a culture in the game
+#[derive(Serialize)]
 pub struct Culture {
     id: GameId,
     name: Option<GameString>,
     ethos: Option<GameString>,
     heritage: Option<GameString>,
     martial: Option<GameString>,
     date: Option<GameString>,
+    #[serde(serialize_with = "serialize_array_ref")]
     children: Vec<Shared<Culture>>,
+    #[serde(serialize_with = "serialize_array_ref")]
     parents: Vec<Shared<Culture>>,
     traditions: Vec<GameString>,
     language: Option<GameString>,
@@ -119,28 +122,6 @@ impl Culture {
     }
 }
 
-impl Serialize for Culture {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_struct("Culture", 10)?;
-        state.serialize_field("id", &self.id)?;
-        state.serialize_field("name", &self.name)?;
-        state.serialize_field("ethos", &self.ethos)?;
-        state.serialize_field("heritage", &self.heritage)?;
-        state.serialize_field("martial", &self.martial)?;
-        state.serialize_field("date", &self.date)?;
-        let parents = serialize_array(&self.parents);
-        state.serialize_field("parents", &parents)?;
-        let children = serialize_array(&self.children);
-        state.serialize_field("children", &children)?;
-        state.serialize_field("traditions", &self.traditions)?;
-        state.serialize_field("language", &self.language)?;
-        state.end()
-    }
-}
-
 impl Renderable for Culture {
     fn get_template() -> &'static str {
         CUL_TEMPLATE_NAME