impl oft to finish

src/filesys/oftable.rs

@@ -0,0 +1,153 @@
+use super::openfile::OpenFile;
+
+
+pub const MAX_OF_TABLE_ENTRY : i32 = 500;
+
+pub struct OpenFileTableEntry {
+    name : String,
+    pub file : Option<OpenFile>,
+    pub num_thread : i32,//number of threads havng that file open
+    //lock : Lock,
+    pub to_be_deleted : bool,//si mis a true, quand ce fichier n'est plus ouvert par aucun thread, il doit etre supprimé
+    pub sector : i32,//secteur disque ou se situe le header de ce fichier
+}
+
+pub struct OpenFileTable{
+    table : Vec<Option<OpenFileTableEntry>>,
+    nb_entry : i32//numero du prochain fichier ouvert/prochaine entrée
+}
+
+impl OpenFileTableEntry {
+    
+    pub fn new() -> OpenFileTableEntry {
+
+        OpenFileTableEntry {
+            name : String::new(),
+            file : None,
+            num_thread : 1,
+            to_be_deleted : false,
+            sector : -1
+        }
+    }
+}
+
+impl OpenFileTable{
+
+    pub fn open(oft : &mut OpenFileTable, name : String)-> Option<OpenFile>{
+
+        let mut num : i32;
+        let mut sector : i32;
+        let mut dirsector : i32;
+        let mut file_name = String::new();
+
+        //Impl le trait copy sur open file
+        num = OpenFileTable::findl(oft, &name);
+
+        //no error
+        if num != -1 {
+            //the file is opened by another thread
+            match oft.table[num as usize] {
+
+                Some(e) => {
+
+                    if !e.to_be_deleted{
+                        e.num_thread += 1;
+
+                        let new_file : OpenFile = OpenFile::open_file(e.sector);
+                        new_file.name = name.clone();
+
+                        return Some(new_file);
+                    }
+                    else {
+                        return None;
+                    }
+
+                }
+
+                None => {
+                    println!("OpenFileTale :: open :: Error opening {}", name);
+                    return None;
+                }
+            }
+        }
+
+        //file is not opened yet
+        else {
+            if(oft.nb_entry != -1){
+                //il reste de la place
+                let mut new_entry : OpenFileTableEntry = OpenFileTableEntry::new();
+                let mut open_file : OpenFile;
+                let mut new_file : OpenFile;
+                //on va creer, si fichier present sur disque, deux objet open_file, 
+                //open_file ira dans la table
+                //new_file sera renvoyé
+
+            }
+            
+            
+            
+            
+
+
+        }
+
+        return None;
+
+    }
+
+    pub fn close(name : String){
+
+    }
+
+    pub fn file_lock(name : String){
+
+    }
+
+    pub fn file_release(name : String){
+
+    }
+
+    pub fn remove(name : String)-> i32{
+        0
+    }
+
+    pub fn next_entry(oft : &mut OpenFileTable)-> i32{
+        let mut i = 0;
+
+        for entry in oft.table.iter(){
+            match entry {
+                None => {
+                    return i;
+                }
+
+                _ => {
+                    i+=1;
+                }
+            }
+        }
+        0
+    }
+
+    pub fn findl(oft : &mut OpenFileTable, name : &String)-> i32{
+        let mut i = 0;
+
+        for entry in oft.table.iter(){
+
+            match entry {
+
+                Some(e) => {
+                    if e.name.eq(name){
+                        return i;
+                    }
+                }
+
+                _ => {}
+            }
+
+            i+=1
+        }
+        
+        -1
+    }
+
+}