Improve creation of DirectoryRecords

src/Tools/psxcdgen_ex/src/encoder/psx.rs

@@ -78,6 +78,7 @@ pub fn encode_psx_image(cd_desc: CDDesc, sec_writer: &mut dyn SectorWriter) -> R
             Layout::SystemArea(system_area) => process_system_area(&system_area.borrow(), sec_writer)?,
             Layout::PVD(pvd)                => process_pvd(&pvd.borrow(), cd_desc.path_table.clone(), cd_desc.root.clone(), vol_sector_count, sec_writer)?,
             Layout::PathTables(path_table)  => process_path_table(&path_table.borrow(), cd_desc.root.clone(), sec_writer)?,
+            Layout::Directory(dir)          => process_directory_record(&dir.borrow(), sec_writer)?,
             _                               => ()
         }
     }
@@ -125,8 +126,7 @@ fn process_pvd(pvd: &PrimaryVolumeDescriptor, path_table: SharedPtr<PathTable>,
     cd_pvd.path_table_4.write(path_table.get_track_rel_lba_for(4, sector_count_mode2_form1) as u32);
 
     //Set Root Directory Record
-    let root_dir_record = unsafe{std::mem::transmute::<&mut [u8; 34], &mut DirectoryRecord>(&mut cd_pvd.root_dir_record)};
-    update_dir_record(root_dir_record, &root_dir)?;
+    update_dir_record_with_dir(&mut cd_pvd.root_dir_record, &root_dir)?;
 
     //Set other stuff
     cd_pvd.publisher_id  = AString::from_str(pvd.publisher.as_str())?;
@@ -175,6 +175,21 @@ fn process_path_table(path_table: &PathTable, root_dir: SharedPtr<Directory>, se
     Ok(())
 }
 
+fn process_directory_record(dir: &Directory, _sec_writer: &mut dyn SectorWriter) -> Result<(), Error> {
+    let mut dir_record = vec![0u8; dir.get_content_size()];
+    let     dir_length = dir_record.len();
+    let     raw_data   = &mut dir_record[0..dir_length];
+
+    for _member in dir.collect_member() {
+        let mut _dir_record = unsafe{std::mem::transmute::<&mut u8, &mut DirectoryRecord>(&mut raw_data[0])};
+
+
+    }
+
+
+    Err(Error::not_implemented("process_directory_record"))
+}
+
 fn validate_path_table(path_table: &PathTable) -> Result<(), Error> {
     if path_table.size_bytes > Mode2Form1::DATA_SIZE {
         Err(Error::from_text(format!("Path Tables are not allowed to be bigger then {} bytes - Path Table has {} bytes", Mode2Form1::DATA_SIZE, path_table.size_bytes)))
@@ -192,17 +207,6 @@ fn validate_and_unwrap_path_table(path_table: &SharedPtr<PathTable>) -> Result<s
     Ok(path_table)
 }
 
-fn update_dir_record(dir_record: &mut DirectoryRecord, dir: &Directory) -> Result<(), Error> {
-    unsafe{dir_record.new(dir.name.as_str().unwrap_or("\x00"), false)};
-
-    dir_record.data_block_number.write(dir.properties.track_rel_lba as u32);
-    dir_record.data_size.write(dir.get_size() as u32);
-    dir_record.time_stamp = SmallDate::now();
-    dir_record.set_directory();
-
-    Ok(())
-}
-
 fn update_path_table_entry(path_table_l: &mut PathTableL, path_table_b: &mut PathTableB, entry: PathTableMember) -> Result<usize, Error> {
     let name_len = entry.name.len();
     if name_len > 8 {
@@ -222,4 +226,32 @@ fn update_path_table_entry(path_table_l: &mut PathTableL, path_table_b: &mut Pat
     path_table_b.parent_table_id.write(entry.parent_table_id as u16);
 
     Ok(path_table_l.get_size())
+}
+
+fn create_dir_record_raw<'a>(dst: &'a mut [u8], name: Option<&str>, track_rel_lba: u32, size_bytes: u32) -> Result<&'a mut DirectoryRecord, Error> {
+    let name         = name.unwrap_or("\x00");
+    let bytes_needed = DirectoryRecord::calculate_size_for(name, false);
+
+    if dst.len() < bytes_needed {
+        return Err(Error::from_text(format!("DirectoryRecord for entry {} needs {} bytes but {} bytes were provided", name, bytes_needed, dst.len())));
+    }
+
+    unsafe {
+        let mut dir_record = std::mem::transmute::<&mut u8, &mut DirectoryRecord>(&mut dst[0]);
+        dir_record.new(name, false);
+
+
+        dir_record.data_block_number.write(track_rel_lba);
+        dir_record.data_size.write(size_bytes);
+        dir_record.time_stamp = SmallDate::now();
+        Ok(dir_record)
+    }
+}
+
+
+fn update_dir_record_with_dir(dir_record: &mut [u8], dir: &Directory) -> Result<(), Error> {
+    let dir_record = create_dir_record_raw(dir_record, dir.name.as_str(), dir.properties.track_rel_lba as u32, dir.get_size() as u32)?;
+
+    dir_record.set_directory();
+    Ok(())
 }

src/Tools/psxcdgen_ex/src/types/mod.rs

@@ -136,11 +136,18 @@ impl Directory {
         self.properties.get_size(self.size_bytes)
     }
 
+    pub(super) fn get_content_size(&self) -> usize {
+        self.size_bytes
+    }
+
+    pub(super) fn collect_member(&self) -> Vec<helper::DirectoryRecordMember>{
+        helper::collect_directory_record_member(&self.files, &self.dirs)
+    }
+
     pub(super) fn update_content_size(&mut self) {
-        let dir_member     = helper::collect_directory_record_member(&self.files, &self.dirs);
         let mut size_bytes = 0;
 
-        for member in dir_member {
+        for member in self.collect_member() {
             size_bytes += DirectoryRecord::calculate_size_for(member.get_name().as_str(), true);
         }