D88FileIO 0.0.8

d88 File Access Lib.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::io::{BufReader, Read};
use std::io::{Seek, SeekFrom};
use std::mem;

use crate::format::D88_Header;
use crate::track::Track;

///
#[derive(Default, Debug)]
pub struct Disk {
    pub header: D88_Header,
    pub track_tbl: Vec<Track>,
}

impl Disk {
    /// Read Disk
    ///
    /// # Argument
    ///
    ///   * `reader` &mut BufReader<std::fs::File>
    ///
    /// # Return
    ///
    ///   * Ok(usize)  Disk Size
    ///   * Err(())    
    ///
    #[allow(clippy::result_unit_err)]
    pub fn preset(&mut self, reader: &mut BufReader<std::fs::File>) -> Result<usize, ()> {
        if reader.seek(SeekFrom::Start(0)).is_err() {
            return Err(());
        }

        let mut buf: [u8; mem::size_of::<D88_Header>()] = [0; mem::size_of::<D88_Header>()]; // Header Buffer
        if let Ok(read_size) = reader.read(&mut buf) {
            //
            if read_size != mem::size_of::<D88_Header>() {
                return Err(());
            }

            let header;
            unsafe {
                header = mem::transmute::<[u8; mem::size_of::<D88_Header>()], D88_Header>(buf);
            }
            self.header = header;

            self.preset_track(reader) // return Ok(disk_size :usize)
        } else {
            Err(())
        }
        //
    }

    ///
    ///
    pub fn get_disk_name(&self) -> String {
        let disk_name;
        unsafe {
            disk_name = String::from_utf8_unchecked(self.header.disk_name.to_vec());
        }
        format!("Name({})", disk_name)
    }

    ///
    ///
    pub fn get_disk_write_protect(&self) -> String {
        format!(
            "({})",
            match self.header.write_protect {
                0x10 => "Protected",
                0x00 => "No Protected",
                _ => "!! Illegal !!",
            }
        )
    }

    ///
    ///
    pub fn get_disk_type(&self) -> String {
        format!(
            "Type({} Disk)",
            match self.header.disk_type {
                0x00 => "2D",
                0x10 => "2DD",
                0x20 => "2HD",
                _ => "??",
            }
        )
    }

    ///
    ///
    pub fn get_disk_size(&self) -> String {
        format!("DiskSize({} byte)", self.header.disk_size)
    }

    /// Read Track and Sector
    ///
    /// # Argument
    ///
    ///   * `reader` &mut BufReader<std::fs::File>
    ///
    /// # Return
    ///
    ///   * Ok(usize)  Disk Size
    ///   * Err(())    
    ///
    #[allow(clippy::result_unit_err)]
    pub fn preset_track(&mut self, reader: &mut BufReader<std::fs::File>) -> Result<usize, ()> {
        let mut disk_size: usize = 0;

        for track_offset in self.header.track_offset_tbl {
            let mut track = Track::default();

            if let Ok(track_size) = track.preset(reader, track_offset as u64) {
                disk_size += track_size as usize;
            } else {
                break;
            }
            self.track_tbl.push(track);
        }

        if disk_size == 0 {
            return Err(());
        }
        //assert_eq!(num_of_track, 80); // 2D Disk
        Ok(disk_size)
    }
}