serde

card_game/src/lib.rs

@@ -469,15 +469,6 @@ impl<C: Default> Default for SessionConfig<C> {
 }
 
 #[derive(Clone, Debug)]
-#[cfg_attr(
-	feature = "serde",
-	derive(serde_derive::Deserialize, serde_derive::Serialize),
-	serde(bound = "
-		G: serde::Serialize + for <'a> serde::Deserialize<'a>,
-		G::Stats: serde::Serialize + for <'a> serde::Deserialize<'a>,
-		G::Config: serde::Serialize + for <'a> serde::Deserialize<'a>,
-	")
-)]
 pub struct Session<G: Game> {
 	stats: SessionStats<G::Stats>,
 	config: SessionConfig<G::Config>,
@@ -662,72 +653,85 @@ where
 	}
 }
 
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize),
+	serde(bound = "
+		G: serde::Deserialize<'de>,
+		SessionConfig<G::Config>: serde::Deserialize<'de>,
+		Vec<G::Instruction>: serde::Deserialize<'de>,
+	")
+)]
+struct SerializedSession<G: Game> {
+	config: SessionConfig<G::Config>,
+	state: G,
+	history: Vec<G::Instruction>,
+}
 #[cfg(feature = "serde")]
-impl<'de, G: Game> serde::de::DeserializeSeed<'de> for Session<G>
+impl<'de, G: Game<Score = i32>> serde::de::Deserialize<'de> for Session<G>
 where
-	G: serde::Deserialize<'de>,
+	G: serde::Deserialize<'de> + Clone + Eq + core::hash::Hash,
-	G::Instruction: serde::Deserialize<'de>,
+	G::Stats: Default,
+	G::Instruction: serde::Deserialize<'de> + Eq + core::hash::Hash,
+	SessionConfig<G::Config>: serde::Deserialize<'de>,
+	Vec<G::Instruction>: serde::Deserialize<'de>,
 {
-	type Value = SessionState<G>;
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-	fn deserialize<D>(deserializer: D) -> Result<Self::Value, D::Error>
 	where
 		D: serde::Deserializer<'de>,
 	{
-		struct SessionStateVisitor<G> {
+		let serialized = SerializedSession::deserialize(deserializer)?;
-			state: G,
+		let mut session = Session::new(serialized.state, serialized.config);
+		for instruction in serialized.history {
+			session.process_instruction(instruction);
 		}
-		impl<'de, G: Game> serde::de::Visitor<'de> for SessionStateVisitor<G>
+		Ok(session)
-		where
-			G: serde::Deserialize<'de>,
-			G::Instruction: serde::Deserialize<'de>,
-		{
-			type Value = SessionState<G>;
-			fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-				write!(f, "State History")
-			}
-			fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-			where
-				A: serde::de::SeqAccess<'de>,
-			{
-				let mut state = self.state.clone();
-				let mut history = match seq.size_hint() {
-					Some(capacity) => Vec::with_capacity(capacity),
-					None => Vec::new(),
-				};
-				while let Some(instruction) = seq.next_element::<G::Instruction>()? {
-					history.push(StateSnapshot {
-						state: state.clone(),
-						instruction: instruction.clone(),
-					});
-					state.process_instruction(stats, config, instruction);
-				}
-				Ok(SessionState { state, history })
-			}
-		}
-		let state = G::deserialize(deserializer)?;
-		deserializer.deserialize_seq(SessionStateVisitor { state })
 	}
 }
 #[cfg(feature = "serde")]
-impl<G: Game> serde::Serialize for SessionState<G>
+impl<G: Game> serde::Serialize for Session<G>
 where
 	G: serde::Serialize,
+	G::Config: serde::Serialize,
 	G::Instruction: serde::Serialize,
 {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		if let Some(state) = self.history.first() {
+		struct History<'a, G: Game>(&'a [StateSnapshot<G>]);
-			state.serialize(serializer)?;
+		impl<G: Game> serde::Serialize for History<'_, G>
+		where
+			G: serde::Serialize,
+			G::Instruction: serde::Serialize,
+		{
+			fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+			where
+				S: serde::Serializer,
+			{
+				let &History(history) = self;
+				use serde::ser::SerializeSeq;
+				let mut seq = serializer.serialize_seq(Some(history.len()))?;
+				for snapshot in history {
+					seq.serialize_element(&snapshot.instruction)?;
+				}
+				seq.end()
+			}
+		}
+
+		use serde::ser::SerializeMap;
+		let mut map = serializer.serialize_map(Some(2))?;
+		// serialize the initial state of the game.
+		// if there is history, it is the first snapshot's state,
+		// otherwise it is the current game state since there are no moves.
+		let state = if let Some(snapshot) = self.state.history.first() {
+			snapshot.state()
 		} else {
-			self.state.serialize(serializer)?;
+			&self.state.state
-		}
+		};
-		use serde::ser::SerializeSeq;
+		map.serialize_entry("config", &self.config)?;
-		let mut seq = serializer.serialize_seq(Some(self.history.len()))?;
+		map.serialize_entry("state", state)?;
-		for snapshot in &self.history {
+		map.serialize_entry("history", &History(&self.state.history))?;
-			seq.serialize_element(&snapshot.instruction)?;
+		map.end()
-		}
-		seq.end()
 	}
 }