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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

/// Struct which stores .csv file data.
///
/// If you need more detail about .csv data, you might want to see "zle::ust::CsvExUst" .  
#[derive(Clone)]
pub struct CsvEx {
    pub plane:Vec<Vec<String>>,
    pub line: Vec<String>,
    pub y_len: usize,
    pub x_len: usize,
}

impl CsvEx {
    ///　Create instance from .csv file you assigned by path.
    pub fn new(path: String) -> Self {
        let raw = std::fs::read_to_string(path).expect("From Csv_Ex : Failed read file");

        let mut x_lens: Vec<i32> = Vec::new();
        let mut ylen = 0;
        //let mut y_lens:Vec<i32>=Vec::new();
        let mut x_temp = 1;

        let mut lined_contents: Vec<String> = Vec::new();
        let mut planed_contents: Vec<Vec<String>> = Vec::new();
        let mut line_temp = String::new();
        let mut plane_temp: Vec<String> = Vec::new();

        for run in raw.chars() {
            match run {
                '\n' => {
                    ylen += 1;
                    x_lens.push(x_temp);
                    x_temp = 1;
                    lined_contents.push(line_temp.clone() + "\n");
                    plane_temp.push(line_temp.clone());
                    planed_contents.push(plane_temp.clone());
                    //    lined_contents.push(  line_temp.clone().push('\n')   );
                    line_temp.clear();
                    plane_temp.clear();
                }
                '\r' => {
                    ylen += 1;
                    x_lens.push(x_temp);
                    x_temp = 1;
                    lined_contents.push(line_temp.clone() + "\n");
                    plane_temp.push(line_temp.clone());
                    planed_contents.push(plane_temp.clone());
                    //    lined_contents.push(  line_temp.clone().push('\n')   );
                    line_temp.clear();
                    plane_temp.clear();
                }
                ',' => {
                    x_temp += 1;
                    lined_contents.push(line_temp.clone());
                    plane_temp.push(line_temp.clone());
                    line_temp.clear();
                }
                _ => {
                    line_temp.push(run);
                }
            }
        }

        CsvEx {
            plane: planed_contents,
            line: lined_contents,
            y_len: ylen,
            x_len: super::cont::vec_max(&x_lens).unwrap_or(0) as usize,
        }
    }
    pub fn read_check(&self,x:i32,y:i32)->bool{
        match self.plane[y as usize].get(x as usize){
            Some(_a)=>{
                if self.plane[y as usize][x as usize].is_empty(){
                    false
                }else{
                    true
                }
            },
            None=>{
                false
            },

        }
    }

    pub fn read_str(&self,x:i32,y:i32)->String{
        self.plane[y as usize][x as usize].clone()
    }
    pub fn read_int(&self,x:i32,y:i32)->i32{
        self.plane[y as usize][x as usize].clone().parse().unwrap()
    }
    pub fn read_double(&self,x:i32,y:i32)->f64{
        self.plane[y as usize][x as usize].clone().parse().unwrap()
    }

    pub fn u_read_str(&self,x:usize,y:usize)->String{
        self.plane[y][x].clone()
    }
    pub fn u_read_int(&self,x:usize,y:usize)->i32{
        self.plane[y][x].clone().parse().unwrap()
    }
    pub fn u_read_double(&self,x:usize,y:usize)->f64{
        self.plane[y][x].clone().parse().unwrap()
    }
    pub fn u_read_check(&self,x:usize,y:usize)->bool{
        match self.plane[y as usize].get(x as usize){
            Some(_a)=>{
                if self.plane[y as usize][x as usize].is_empty(){
                    false
                }else{
                    true
                }
            },
            None=>{
                false
            },

        }
    }
    pub fn safe_str(&self,x:usize,y:usize)->Option<String>{
        match self.plane[y].get(x){
            Some(a)=>{
                if self.plane[y as usize][x as usize].is_empty(){
                    None
                }else{
                    Some(a.clone())
                } 
            },
            None=>{
                None
            }
        }
    }
    pub fn safe_int(&self,x:usize,y:usize)->Option<i32>{
        match self.plane[y].get(x){
            Some(a)=>{
                if self.plane[y as usize][x as usize].is_empty(){
                    None
                }else{
                    Some(a.clone().parse().unwrap())
                } 
            },
            None=>{
                None
            }
        }
    }

    


}