zoozle 0.1.0

Some I/O macros like C++ cout/cin.
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
129
130
131
132
133
134
135
136
137
138

//csv.rs

///Struct which stores .csv file data.
pub struct CsvEx{
    pub sheet:Vec<Vec<String>>,
    pub line :Vec<String>,
    pub ylength:i32,
    pub xlength:i32,
   }
  
    impl CsvEx{
     pub  fn new(path:String)->Self{
           let contents = std::fs::read_to_string(path)
           .expect("From Csv_Ex : Failed read file");
           let mut line = 0;
          
  
           for run in contents.chars(){
               if '\n'==run {
                   line+=1;
               }else if '\r'==run {
                   line+=1;
               }
           }
  
           let mut max_x:Vec<i32>=Vec::with_capacity(line);
           max_x.push(1);
  
           let mut max_now=0;
           let mut xvalue=1;
           for run in contents.chars(){
               match run{
                   '\n'=>{
                       max_now+=1;
                       max_x.push(1);
                       xvalue+=1;
                   },
                   '\r'=>{
                       max_now+=1;
                       max_x.push(1);
                       xvalue+=1;
                   },
                   ','=>{
                       max_x[max_now]+=1;
                       xvalue+=1;
                   }
                   _=>{
          
                   },
               }
           }
  
           let mut temp1=max_x[0];
           let mut ii=0;
  
           while ii<line{
               if temp1<max_x[ii]{
                super::oft::swap_func(&mut temp1,&mut max_x[ii])
               }
               ii+=1;
            }
  
           let mut origin:Vec<String>=Vec::with_capacity(xvalue);
           println!("xlen={} , ylen={}",temp1,line);
 //            panic!("がんばれよ");
           let mut buffer=String::new();
           for run in contents.chars(){
               match run{
                   '\n'=>{
                       origin.push(buffer.clone());
                       buffer.clear();
                   },
                   '\r'=>{
                       origin.push(buffer.clone());
                       buffer.clear();
                   },
                   ','=>{
                       origin.push(buffer.clone());
                       buffer.clear();
                   }
                   _=>{
                       buffer.push(run);           
                   },
               }
           }
  
           let mut newsheet:Vec<Vec<String>>=Vec::with_capacity(line);
           unsafe{
               newsheet.set_len(line);
           }
  
           let mut count=0;
           let mut buffer=String::new();
           for run in contents.chars(){
               match run{
                   '\n'=>{
                       newsheet[count].push(buffer.clone());
                       buffer.clear();
                       count+=1;
                   },
                   '\r'=>{
                       newsheet[count].push(buffer.clone());
                       buffer.clear();
                       count+=1;
                   },
                   ','=>{
                     newsheet[count].push(buffer.clone());
                     buffer.clear();
                   }
                   _=>{
                     buffer.push(run);
                   },
               }
           }
  
  
           CsvEx{
               line:origin,
               sheet:newsheet,
               ylength:line as i32,
               xlength:0,
           }
       }
  
       pub fn mesh_able(&self,x:i32,y:i32)->bool{
           if self.ylength<=y{
               false;
           }
           match self.sheet[y as usize].get(x as usize){
             Some(_)=>{
               true
             },
             None=>{
               false
             },
           }
       }
    }