common: delete updatable trait

lib/common/src/gameplay_modes.rs

@@ -1,7 +1,6 @@
 use std::collections::{HashSet,HashMap};
 use crate::model::ModelId;
 use crate::gameplay_style;
-use crate::updatable::Updatable;
 
 #[derive(Clone)]
 pub struct StageElement{
@@ -312,10 +311,10 @@ pub struct StageUpdate{
 	ordered_checkpoints:HashMap<CheckpointId,ModelId>,
 	unordered_checkpoints:HashSet<ModelId>,
 }
-impl Updatable<StageUpdate> for Stage{
-	fn update(&mut self,update:StageUpdate){
-		self.ordered_checkpoints.extend(update.ordered_checkpoints);
-		self.unordered_checkpoints.extend(update.unordered_checkpoints);
+impl StageUpdate{
+	fn apply_to(self,stage:&mut Stage){
+		stage.ordered_checkpoints.extend(self.ordered_checkpoints);
+		stage.unordered_checkpoints.extend(self.unordered_checkpoints);
 	}
 }
 
@@ -327,15 +326,15 @@ pub struct ModeUpdate{
 	//mutually exlusive stage element behaviour
 	elements:Option<(ModelId,StageElement)>,
 }
-impl Updatable<ModeUpdate> for Mode{
-	fn update(&mut self,update:ModeUpdate){
-		self.zones.extend(update.zones);
-		if let Some((StageId(stage_id),stage_update))=update.stages{
-			if let Some(stage)=self.stages.get_mut(stage_id as usize){
-				stage.update(stage_update);
+impl ModeUpdate{
+	fn apply_to(self,mode:&mut Mode){
+		mode.zones.extend(self.zones);
+		if let Some((StageId(stage_id),stage_update))=self.stages{
+			if let Some(stage)=mode.stages.get_mut(stage_id as usize){
+				stage_update.apply_to(stage);
 			}
 		}
-		self.elements.extend(update.elements);
+		mode.elements.extend(self.elements);
 	}
 }
 impl ModeUpdate{
@@ -369,11 +368,11 @@ impl ModeUpdate{
 pub struct ModesUpdate{
 	modes:HashMap<ModeId,ModeUpdate>,
 }
-impl Updatable<ModesUpdate> for Modes{
-	fn update(&mut self,update:ModesUpdate){
-		for (ModeId(mode_id),mode_update) in update.modes{
-			if let Some(mode)=self.modes.get_mut(mode_id as usize){
-				mode.update(mode_update);
+impl ModesUpdate{
+	fn apply_to(self,modes:&mut Modes){
+		for (ModeId(mode_id),mode_update) in self.modes{
+			if let Some(mode)=modes.modes.get_mut(mode_id as usize){
+				mode_update.apply_to(mode);
 			}
 		}
 	}
@@ -426,7 +425,7 @@ impl ModesBuilder{
 				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
 					if let Some(&final_stage_id)=mode.stage_id_map.get(&builder_stage_id){
 						if let Some(stage)=mode.mode.get_stage_mut(final_stage_id){
-							stage.update(stage_update);
+							stage_update.apply_to(stage);
 						}
 					}
 				}
@@ -447,7 +446,7 @@ impl ModesBuilder{
 							mode.stage_id_map.get(&StageId::new(builder_stage_id)).copied()
 						).unwrap_or(StageId::FIRST)
 					);
-					mode.mode.update(mode_update);
+					mode_update.apply_to(&mut mode.mode);
 				}
 			}
 		}

lib/common/src/lib.rs

@@ -9,7 +9,6 @@ pub mod timer;
 pub mod integer;
 pub mod physics;
 pub mod session;
-pub mod updatable;
 pub mod instruction;
 pub mod gameplay_attributes;
 pub mod gameplay_modes;

lib/common/src/updatable.rs

@@ -1,57 +0,0 @@
-// This whole thing should be a drive macro
-
-pub trait Updatable<Updater>{
-	fn update(&mut self,update:Updater);
-}
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-struct InnerId(u32);
-#[derive(Clone)]
-struct Inner{
-	id:InnerId,
-	enabled:bool,
-}
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-struct OuterId(u32);
-struct Outer{
-	id:OuterId,
-	inners:std::collections::HashMap<InnerId,Inner>,
-}
-
-enum Update<I,U>{
-	Insert(I),
-	Update(U),
-	Remove
-}
-
-struct InnerUpdate{
-	//#[updatable(Update)]
-	enabled:Option<bool>,
-}
-struct OuterUpdate{
-	//#[updatable(Insert,Update,Remove)]
-	inners:std::collections::HashMap<InnerId,Update<Inner,InnerUpdate>>,
-	//#[updatable(Update)]
-	//inners:std::collections::HashMap<InnerId,InnerUpdate>,
-}
-impl Updatable<InnerUpdate> for Inner{
-	fn update(&mut self,update:InnerUpdate){
-		if let Some(enabled)=update.enabled{
-			self.enabled=enabled;
-		}
-	}
-}
-impl Updatable<OuterUpdate> for Outer{
-	fn update(&mut self,update:OuterUpdate){
-		for (id,up) in update.inners{
-			match up{
-				Update::Insert(new_inner)=>self.inners.insert(id,new_inner),
-				Update::Update(inner_update)=>self.inners.get_mut(&id).map(|inner|{
-					let old=inner.clone();
-					inner.update(inner_update);
-					old
-				}),
-				Update::Remove=>self.inners.remove(&id),
-			};
-		}
-	}
-}