deferred_loader: remove PhantomData using GATs

lib/bsp_loader/src/loader.rs

@@ -22,17 +22,17 @@ impl From<std::io::Error> for TextureError{
 	}
 }
 
-pub struct TextureLoader<'a>(std::marker::PhantomData<&'a ()>);
-impl TextureLoader<'_>{
+pub struct TextureLoader;
+impl TextureLoader{
 	pub fn new()->Self{
-		Self(std::marker::PhantomData)
+		Self
 	}
 }
-impl<'a> Loader for TextureLoader<'a>{
+impl Loader for TextureLoader{
 	type Error=TextureError;
-	type Index=Cow<'a,str>;
+	type Index<'a>=Cow<'a,str>;
 	type Resource=Texture;
-	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let file_name=format!("textures/{}.dds",index);
 		let mut file=std::fs::File::open(file_name)?;
 		let mut data=Vec::new();
@@ -100,30 +100,24 @@ impl<'bsp,'vpk> BspFinder<'bsp,'vpk>{
 	}
 }
 
-pub struct ModelLoader<'bsp,'vpk,'a>{
+pub struct ModelLoader<'bsp,'vpk>{
 	finder:BspFinder<'bsp,'vpk>,
-	life:core::marker::PhantomData<&'a ()>,
 }
-impl ModelLoader<'_,'_,'_>{
+impl ModelLoader<'_,'_>{
 	#[inline]
-	pub const fn new<'bsp,'vpk,'a>(
+	pub const fn new<'bsp,'vpk>(
 		finder:BspFinder<'bsp,'vpk>,
-	)->ModelLoader<'bsp,'vpk,'a>{
+	)->ModelLoader<'bsp,'vpk>{
 		ModelLoader{
 			finder,
-			life:core::marker::PhantomData,
 		}
 	}
 }
-impl<'bsp,'vpk,'a> Loader for ModelLoader<'bsp,'vpk,'a>
-	where
-		'bsp:'a,
-		'vpk:'a,
-{
+impl<'bsp,'vpk> Loader for ModelLoader<'bsp,'vpk>{
 	type Error=MeshError;
-	type Index=&'a str;
+	type Index<'a>=&'a str where Self:'a;
 	type Resource=vmdl::Model;
-	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&'a mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let mdl_path_lower=index.to_lowercase();
 		//.mdl, .vvd, .dx90.vtx
 		let path=std::path::PathBuf::from(mdl_path_lower.as_str());
@@ -143,31 +137,27 @@ impl<'bsp,'vpk,'a> Loader for ModelLoader<'bsp,'vpk,'a>
 	}
 }
 
-pub struct MeshLoader<'bsp,'vpk,'load,'a>{
+pub struct MeshLoader<'bsp,'vpk,'load,'str>{
 	finder:BspFinder<'bsp,'vpk>,
-	deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'a,str>>,
+	deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'str,str>>,
 }
 impl MeshLoader<'_,'_,'_,'_>{
 	#[inline]
-	pub const fn new<'bsp,'vpk,'load,'a>(
+	pub const fn new<'bsp,'vpk,'load,'str>(
 		finder:BspFinder<'bsp,'vpk>,
-		deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'a,str>>,
-	)->MeshLoader<'bsp,'vpk,'load,'a>{
+		deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'str,str>>,
+	)->MeshLoader<'bsp,'vpk,'load,'str>{
 		MeshLoader{
 			finder,
 			deferred_loader
 		}
 	}
 }
-impl<'bsp,'vpk,'load,'a> Loader for MeshLoader<'bsp,'vpk,'load,'a>
-	where
-		'bsp:'a,
-		'vpk:'a,
-{
+impl<'str,'bsp,'vpk,'load> Loader for MeshLoader<'bsp,'vpk,'load,'str>{
 	type Error=MeshError;
-	type Index=&'a str;
+	type Index<'a>=&'a str where Self:'a;
 	type Resource=Mesh;
-	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&'a mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let model=ModelLoader::new(self.finder).load(index)?;
 		let mesh=crate::mesh::convert_mesh(model,&mut self.deferred_loader);
 		Ok(mesh)

lib/deferred_loader/src/deferred_loader.rs

@@ -45,7 +45,7 @@ impl<H:core::hash::Hash+Eq> RenderConfigDeferredLoader<H>{
 	pub fn into_indices(self)->impl Iterator<Item=H>{
 		self.render_config_id_from_asset_id.into_keys().flatten()
 	}
-	pub fn into_render_configs<L:Loader<Resource=Texture,Index=H>>(mut self,loader:&mut L,failure_mode:LoadFailureMode)->Result<RenderConfigs,L::Error>{
+	pub fn into_render_configs<'a,L:Loader<Resource=Texture,Index<'a>=H>+'a>(mut self,loader:&mut L,failure_mode:LoadFailureMode)->Result<RenderConfigs,L::Error>{
 		let mut sorted_textures=vec![None;self.texture_count as usize];
 		for (index_option,render_config_id) in self.render_config_id_from_asset_id{
 			let render_config=&mut self.render_configs[render_config_id.get() as usize];
@@ -93,7 +93,7 @@ impl<H:core::hash::Hash+Eq> MeshDeferredLoader<H>{
 	pub fn into_indices(self)->impl Iterator<Item=H>{
 		self.mesh_id_from_asset_id.into_keys()
 	}
-	pub fn into_meshes<L:Loader<Resource=Mesh,Index=H>>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes,L::Error>{
+	pub fn into_meshes<'a,L:Loader<Resource=Mesh,Index<'a>=H>+'a>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes,L::Error>{
 		let mut mesh_list=vec![None;self.mesh_id_from_asset_id.len()];
 		for (index,mesh_id) in self.mesh_id_from_asset_id{
 			let resource_result=loader.load(index);

lib/deferred_loader/src/loader.rs

@@ -2,7 +2,7 @@ use std::error::Error;
 
 pub trait Loader{
 	type Error:Error;
-	type Index;
+	type Index<'a> where Self:'a;
 	type Resource;
-	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>;
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>;
 }

lib/rbx_loader/src/loader.rs

@@ -36,17 +36,17 @@ impl From<RobloxAssetIdParseErr> for TextureError{
 	}
 }
 
-pub struct TextureLoader<'a>(std::marker::PhantomData<&'a ()>);
-impl TextureLoader<'_>{
+pub struct TextureLoader;
+impl TextureLoader{
 	pub fn new()->Self{
-		Self(std::marker::PhantomData)
+		Self
 	}
 }
-impl<'a> Loader for TextureLoader<'a>{
+impl Loader for TextureLoader{
 	type Error=TextureError;
-	type Index=&'a str;
+	type Index<'a>=&'a str;
 	type Resource=Texture;
-	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let RobloxAssetId(asset_id)=index.parse()?;
 		let file_name=format!("textures/{}.dds",asset_id);
 		let data=read_entire_file(file_name)?;
@@ -138,17 +138,17 @@ impl MeshIndex<'_>{
 	}
 }
 
-pub struct MeshLoader<'a>(std::marker::PhantomData<&'a ()>);
-impl MeshLoader<'_>{
+pub struct MeshLoader;
+impl MeshLoader{
 	pub fn new()->Self{
-		Self(std::marker::PhantomData)
+		Self
 	}
 }
-impl<'a> Loader for MeshLoader<'a>{
+impl Loader for MeshLoader{
 	type Error=MeshError;
-	type Index=MeshIndex<'a>;
+	type Index<'a>=MeshIndex<'a>;
 	type Resource=Mesh;
-	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let mesh=match index.mesh_type{
 			MeshType::FileMesh=>{
 				let RobloxAssetId(asset_id)=index.content.parse()?;