SimpleFiles

                               

                            
/*------------------------------*/
/*
 Titre : SimpleFiles                                                                                                      
                                                                                                                          
 Auteur           : Oprichnik                                                                                             
 Date édition     : 13 Aout 2007                                                                                         
*/
/*------------------------------*/

/***********************************************************
 * Auteur : Mallory Dessaintes
 * Email de l'auteur : mallory.dessaintes@gmail.com 
 * Site Web : http://oprichnik.monespace.be
 *
 * Documentation : "documentation.html"
 *
 *
 * VERSION : [1.0]
 *
 *
 ***********************************************************/

class simplefiles {
  
  private $read_default_return_structure;
  private $lastId;
  private $flock_on;
  
  private $backup_on;
  private $backup_dir;
  private $backup_time;
  
  private $hash_on;
  private $hash_fields;
  private $hash_type;
  
  private $crypt_on;
  private $crypt_fields;
  private $crypt_password;
  private $crypt_functions;
  
  private $select_a_u_fichier;
  private $select_a_read;
  private $select_last_id;
  
  // ---------------------------------------------------------------
  
  function __construct() {
    $this->read_default_return_structure = 2;
    $this->flock_on = true;
    $this->backup_on = false;
    $this->crypt_on = false;
    $this->hash_on = false;
    $this->select_a_read = false;
    $this->select_last_id = false;
  }
  
  // ---------------------------------------------------------------
  
  private function is_assoc_array($array) {
      if(!is_array($array))
        return false;
      
       $next = 0;
       foreach ($array as $k=>$v) {
         if ($k === $next)
           return false;
         $next++;
       }
       return true;
  }
  
  private function is_assoc_multi_array($array) {
      foreach($array as $k => $valeur) {
      if(!$this->is_assoc_array($valeur))
      return false;
      }
      
      return true;
  }
  
  private function sort_by_key($array, $index) {
    $sort = array();
    //préparation d'un nouveau tableau basé sur la clé à trier
    foreach ($array as $key => $val) {
      $sort[$key] = $val[$index];
    }
    
    asort($sort);
    //formation du nouveau tableau trié selon la clé
    $output = array();
    foreach($sort as $key => $val) {
      $output[] = $array[$key];
      
    }
    return $output;
  }
  
  private function str_decode($str,$filter) {
     $filter = md5($filter);
     $letter = -1;
     $newstr = '';
     $str = base64_decode($str);
     $strlen = strlen($str);

     for ( $i = 0; $i < $strlen; $i++ )
     {
      $letter++;

      if ( $letter > 31 )
      {
       $letter = 0;
      }

      $neword = ord($str{$i}) - ord($filter{$letter});

      if ( $neword < 1 )
      {
       $neword += 256;
      }
      
      $newstr .= chr($neword);
     }

     return $newstr;
  }

  private function str_encode($str,$filter) {
     $filter = md5($filter);
     $letter = -1;
     $newpass = '';

     $strlen = strlen($str);
     
     for ( $i = 0; $i < $strlen; $i++ )
     {
      $letter++;

      if ( $letter > 31 )
      {
       $letter = 0;
      }

      $neword = ord($str{$i}) + ord($filter{$letter});

      if ( $neword > 255 )
      {
       $neword -= 256;
      }

      $newstr .= chr($neword);

     }
     
     return base64_encode($newstr);
  }
  
  private function cryptAndHashTest($array) { // tableau unidimensionnel
    $result = $array;
    
    foreach($array as $cle => $valeur) {
        if($this->hash_on == true && in_array($cle,$this->hash_fields)
           or $this->hash_fields[0] == "*")
          ($this->hash_type == "sha1")?$result[$cle] =
                            sha1($valeur):$result[$cle] = md5($valeur);
        if($this->crypt_on == true && in_array($cle,$this->crypt_fields)
           or $this->crypt_fields[0] == "*") {
          if($this->crypt_functions)
            $result[$cle] = call_user_func($this->crypt_functions[0],
            $result[$cle],$this->crypt_password);
            // Je modifie $result[$cle] et non pas $valeur comme au dessus
            // car si le script a hashé dans le script du dessus et qu'il doit
            // être crypté en dessous cela ne marchera pas en reprenant la
            // valeur du tableau d'argument
          else
            $result[$cle] = $this->str_encode($result[$cle],
            $this->crypt_password);
        }


    }
    return $result;
  }
  
  private function decryptTest($array) { // array[][]
    $result = $array;
    
    foreach($array as $cle => $valeur) {
      foreach($valeur as $cle2 => $valeur2) {
          if($this->crypt_on == true && in_array($cle2,$this->crypt_fields)
              or $this->crypt_fields[0] == "*") {
            if($this->crypt_functions)
              $result[$cle][$cle2] = call_user_func($this->crypt_functions[1],
              $valeur2,$this->crypt_password);
            else
              $result[$cle][$cle2] = $this->str_decode($valeur2,
              $this->crypt_password);
          }
      }
    }
    return $result;
  }
  
  private function backupTest($u_fichier) {
    if($this->backup_on) {
    $pathInf = pathinfo($u_fichier);

    $last_num_backup = 0;
    
    while(file_exists($this->backup_dir.$pathInf["filename"]."_
         ".$last_num_backup.".backup"))
      $last_num_backup++;
      
    if(!file_exists($this->backup_dir.$pathInf["filename"]."_0.backup"))
      $filemtime = 0;
    else
      $filemtime = filemtime($this->backup_dir.$pathInf["filename"]."_
      ".($last_num_backup-1).".backup");

    if(file_exists($u_fichier) && (time() - $filemtime > $this->backup_time))
      copy($u_fichier,$this->backup_dir.$pathInf["filename"]."_
      ".$last_num_backup.".backup");
    }
  }
  
  // ---------------------------------------------------------------
  
  public function escapeQuotes($str) {
    if(get_magic_quotes_gpc())
      $str = stripslashes($str);
    
    $str = str_replace('\\','\\\\',$str);
    $str = str_replace("'","\\'",$str);
    
    return $str;
  }
  
  public function escape2Quotes($str) {
    if(get_magic_quotes_gpc())
      $str = stripslashes($str);
    
    $str = str_replace('\\','\\\\',$str);
    $str = str_replace('"','\\"',$str);
    
    return $str;
  }
  
  public function setReadDrs($i_s) { // default return structure
    if($i_s == 1 or $i_s == 2 or $i_s == 3 or $i_s == 4)
      { // 1 vecteur 2 associatif 3 les deux 4 like file
      $this->read_default_return_structure = $i_s;
      return true;
    }
    else
      return false;
  }
  
  public function setFlock($status) {
    if($status)
      $this->$flock_on = true;
    else
      $this->$flock_on = false;
      
    return true;
  }
  
  public function setBackup($status,$dir = false,$time = 86400) {
    if($status == true) {
      if(ctype_digit($time) == true) {
        $this->backup_on = true;
        
        if($dir[strlen($dir)-1] != "/")
          $dir .= "/";
        
        $this->backup_dir = $dir;
      }
      else
        return false;
    }
    else
      $this->backup_on = false;
  
    return true;
  }
  
  public function setHash($status,$fields = false,$type = false) {
  // fields séparés par des "," type = "md5" ou "sha1"
    if($status && $fields && $type) {
      $this->hash_on = true;
      $this->hash_fields = explode(",",$fields);
      $this->hash_type = $type;
    }
    else
      $this->hash_on = false;
      
    return true;
  }
  
  public function setCrypt($status,$fields = false,$password = false) {
  // fields séparés par des ","
    if($status && $fields && $password) {
      $this->crypt_on = true;
      $this->crypt_fields = explode(",",$fields);
      $this->crypt_password = $password;
    }
    else
      $this->crypt_on = false;
      
    return true;
  }
  
  public function setCryptFunctions($CryptFctName,$DecryptFctName) {
    if(function_exists($CryptFctName) && function_exists($DecryptFctName)) {
      $this->crypt_function[0] = $CryptFctName;
      $this->crypt_function[1] = $DecryptFctName;
      
      return true;
    }
    else
      return false;
  }
  
  public function getLastId() {
    return $this->lastId;
  }
  
  public function unik() { 
    $ttime = str_replace(".","",time() + microtime(true)); // total time
    echo $ttime."<br />";
    $a_ttime = str_split($ttime);
    $ar_ttime = array_reverse($a_ttime);
    
    $result = "";
    $chars = array("a","b","c","d","e","f","g","h","i","j","k","l","m",
                   "n","o","p","q","r","s","t","u","v","w","x","y","z",
    "A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q",
    "R","S","T","U","V","W","X","Y","Z");
    for($i=0;$i<count($ar_ttime);$i++) {
      $result .= $chars[mt_rand(0,count($chars)-1)].$ar_ttime[$i];
    }
    return $result;
  }
  
  public function valueExist($value,$field,$haystack,$caseSensitive = true) {
  
    if($caseSensitive)
      $value = strtolower($value);
  
    if(!is_array($haystack)) {
      require($haystack);
      $haystack = $FILE;
    }
  
    foreach($haystack as $line) {
      if($caseSensitive)
        $line[$field] = strtolower($line[$field]);
        
        if($line[$field] == $value)
          return true;
    }
    return false;
  }
  
  public function read($u_fichier,$where = false,$orderBy = false,
  $limit = false,$i_return_structure = false)
  { # Ancienne structure where = "pseudo='oprichn,ik',
   'dracau'&email='mallory.dessaintes@gmail.com'"

    if(!file_exists($u_fichier))
      return false;
    if(!isset($FILE_LAST_ID))
      $FILE_LAST_ID = 0;
    
    require($u_fichier);
    
    if(!isset($FILE))
      return array(); // Il n'y a rien à retourner
    elseif(!$this->is_assoc_multi_array($FILE))
      return false;
    elseif($this->crypt_on)
      $FILE = $this->decryptTest($FILE);
    
    if($where) {
      if(!is_array($where)) {
      
        $result = array();
        
        foreach($FILE as $k => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $LINE = $valeur;
          $eval = "if($where) { $result[] = $valeur; }";
          ob_start(); // Securité pour ne rien afficher à l'écran
          eval($eval);
          ob_clean();
        }
        
      }
      else {
      
        $a_where = $where;
      
        $result = array();
        
        foreach($FILE as $cle => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $i2 = 0;
          foreach($a_where as $cle2 => $valeur2) {
          // On parcourt le tableau where à chaque ligne du fichier
          //pour voir si il correspond avec where
            if(is_array($valeur2)) {
              if(in_array($valeur[$cle2],$valeur2))
              $result[] = $valeur;
            }
            else {
              if($valeur[$cle2] == $valeur2)
              $result[] = $valeur;
            }
          }
        }
      }
    }
    else
      $result = $FILE;
    
    // On modifie le tableau en fonction du paramètre orderBy
    
    if($orderBy) {
      if(strtolower($orderBy) == "desc")
        $result = array_reverse($result);
      else {
        list($orderBy_champ,$orderBy_asc_dsc) = explode(" ",$orderBy);

        $result = $this->sort_by_key($result,$orderBy_champ);
        
        if(strtolower($orderBy_asc_dsc) == "desc")
          $result = array_reverse($result);
        
      }
    }
      
    // On modifie le tableau en fonction du paramètre limit
    
    if($limit) { // Structure : $limit = "0-5" =>
                  //On prend les 5 premiers ou $limit = "5"
      $tmp_result = array();
      if(strpos($limit,"-") !== false) {
        $a_limit = explode("-",$limit);
        for($i=$a_limit[0];$i<min($a_limit[0]+$a_limit[1],count($result));$i++)
         {
          $tmp_result[$i] = $result[$i];
        }
      }
      else {
        for($i=0;$i<min($limit,count($result));$i++) {
          $tmp_result[$i] = $result[$i];
        }
      }
      $result = $tmp_result;
    }
  
    // On retourne un tableau selon le paramètre de retour (type de tableau)
    
    if(!$i_return_structure) 
      $i_return_structure = $this->read_default_return_structure;
    
    if($i_return_structure == 1) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $valeur2) {
          $result2[$i][] = $valeur2;
        }
        $i++;
      }
      return $result2;
    }
    elseif($i_return_structure == 3) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $cle => $valeur2) {
          $result2[$i][] = $valeur2;
          $result2[$i][$cle] = $valeur2;
        }
        $i++;
      }
      return $result2;
    }
    elseif($i_return_structure == 4) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $cle => $valeur2) {
          $result2[$i] = $valeur2;
          $i++;
        }
      }
      return $result2;
    }
    else
      return $result;
      
    // ---------------------------------------------------------------
  }
  
  public function readArrayLikeFile($FILE,$where = false,$orderBy = false,
  $limit = false,$i_return_structure = false) {
  # Ancienne structure where = "pseudo='oprichn,ik',
  'dracau'&email='mallory.dessaintes@gmail.com'"
    
    if(!isset($FILE))
      return array(); // Il n'y a rien à retourner
    elseif(!$this->is_assoc_multi_array($FILE))
      return false;
    
    if($where) {
      if(!is_array($where)) {
      
        $result = array();
        
        foreach($FILE as $k => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $LINE = $valeur;
          $eval = "if($where) { \$result[] = \$valeur; }";
          ob_start(); // Securité pour ne rien afficher à l'écran
          eval($eval);
          ob_clean();
        }
        
      }
      else {
      
        $a_where = $where;
      
        $result = array();
        
        foreach($FILE as $cle => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $i2 = 0;
          foreach($a_where as $cle2 => $valeur2) {
          // On parcourt le tableau where à chaque ligne du fichier
          //pour voir si il correspond avec where
            if(is_array($valeur2)) {
              if(in_array($valeur[$cle2],$valeur2))
              $result[] = $valeur;
            }
            else {
              if($valeur[$cle2] == $valeur2)
              $result[] = $valeur;
            }
          }
        }
      }
    }
    else
      $result = $FILE;
    
    // On modifie le tableau en fonction du paramètre orderBy
    
    if($orderBy) {
      if(strtolower($orderBy) == "desc")
        $result = array_reverse($result);
      else {
        list($orderBy_champ,$orderBy_asc_dsc) = explode(" ",$orderBy);

        $result = $this->sort_by_key($result,$orderBy_champ);
        
        if(strtolower($orderBy_asc_dsc) == "desc")
          $result = array_reverse($result);
        
      }
    }
      
    // On modifie le tableau en fonction du paramètre limit
    
    if($limit) { // Structure : $limit = "0-5" =>
                  // On prend les 5 premiers ou $limit = "5"
      $tmp_result = array();
      if(strpos($limit,"-") !== false) {
        $a_limit = explode("-",$limit);
        for($i=$a_limit[0];$i<min($a_limit[0]+$a_limit[1],count($result));$i++)
         {
          $tmp_result[$i] = $result[$i];
        }
      }
      else {
        for($i=0;$i<min($limit,count($result));$i++) {
          $tmp_result[$i] = $result[$i];
        }
      }
      $result = $tmp_result;
    }
  
    // On retourne un tableau selon le paramètre de retour (type de tableau)
    
    if(!$i_return_structure) 
      $i_return_structure = $this->read_default_return_structure;
    
    if($i_return_structure == 1) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $valeur2) {
          $result2[$i][] = $valeur2;
        }
        $i++;
      }
      return $result2;
    }
    elseif($i_return_structure == 3) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $cle => $valeur2) {
          $result2[$i][] = $valeur2;
          $result2[$i][$cle] = $valeur2;
        }
        $i++;
      }
      return $result2;
    }
    elseif($i_return_structure == 4) {
      $result2 = array(); $i = 0;
      foreach($result as $valeur) {
        foreach($valeur as $cle => $valeur2) {
          $result2[$i] = $valeur2;
          $i++;
        }
      }
      return $result2;
    }
    else
      return $result;
      
    // ---------------------------------------------------------------
  }
  
  public function add($u_fichier,$a_add) {
    // Si une seule ligne à insérer
    if(!isset($a_add[0]))
    // Car les indices du tableau sont indexés associativement
      $__result[0] = $a_add;
    else
      $__result = $a_add;
  
    if(file_exists($u_fichier)) {
      require($u_fichier);
      
      if(!isset($FILE_LAST_ID))
        $FILE_LAST_ID = 0;
      elseif(isset($FILE) && !$this->is_assoc_multi_array($FILE))
        return false;
    }
    else
      $FILE_LAST_ID = 0;
      
    $i = 0;
    
    $_result = $__result;
      
    foreach($__result as $cle => $valeur) {
      foreach($valeur as $cle2 => $valeur2) {
        if($cle2 == "ID")
        // Si un champ a pour nom ID, sa valeur est
        // automatisée et correspond au numéro d'entrée
          $_result[$i][$cle2] = ++$FILE_LAST_ID;
      }
      
      // CRYPTAGE ET HACHAGE -------------------------------------------
      
      if($this->crypt_on or $this->hash_on)
        $_result[$i] = $this->cryptAndHashTest($valeur);
      $i++;
      
      // ---------------------------------------------------------------
    }
    
    $this->lastId = $FILE_LAST_ID;
    
    if(isset($FILE)) // Si le fichier existait déjà et qu'il n'est pas vide
      $result = array_merge($FILE,$_result);
    else
      $result = $_result;
      
    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($u_fichier);
    
    // ---------------------------------------------------------------

    $fo = fopen($u_fichier,"w");



    fputs($fo,"<?php \n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
    
    $i = 0;
    foreach($result as $cle => $valeur) {
        foreach($valeur as $cle2 => $valeur2) {
              fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
                stripslashes(\"".addslashes($valeur2)."\");\n");
        }
        $i++;
    }
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }

  public function mod($u_fichier,$where,$a_mod) {
  // $a_mod est un tableau d'une dimension associatif
    if(!file_exists($u_fichier))
      return false;
    
    require($u_fichier);
    
    if(!isset($FILE_LAST_ID))
      $FILE_LAST_ID = 0;
    
    if(!isset($FILE))
      return false; // Il n'y a rien à retourner
    elseif(!$this->is_assoc_multi_array($FILE))
      return false;
    elseif($this->crypt_on)
      $FILE = $this->decryptTest($FILE);
    
    // CRYPTAGE ET HACHAGE -------------------------------------------
    
    if($this->crypt_on or $this->hash_on)
      $a_mod = $this->cryptAndHashTest($a_mod);
    
    // ---------------------------------------------------------------
    
    if($where) {
      if(!is_array($where)) {
        
        $result = $FILE;
        
        foreach($FILE as $k => $valeur) {
         // On parcourt le fichier pour trouver les lignes à retourner
          $LINE = $valeur;
          $eval = 
"if($where) { \$result[\$k] = array_merge(\$result[\$k],\$a_mod); }";
          ob_start(); // Securité pour ne rien afficher à l'écran
          eval($eval);
          ob_clean();
        }
      }
      else {
      
        $a_where = $where;
      
        $result = $FILE;
        
        foreach($FILE as $cle => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          foreach($a_where as $cle2 => $valeur2) { // On parcourt le
          //tableau where à chaque ligne du fichier pour voir si
          //il correspond avec where
            if(is_array($valeur2)) {
              if(in_array($valeur[$cle2],$valeur2))
                $result[$cle] = array_merge($result[$cle],$a_mod);
            }
            else {
              if($valeur[$cle2] == $valeur2)
                $result[$cle] = array_merge($result[$cle],$a_mod);
            }
          }
        }
      }
    }
    else { // on modifie toutes les lignes
      $result = $FILE;
      
      foreach($FILE as $cle => $valeur) {
        $result[$cle] = array_merge($result[$cle],$a_mod);
      }
    }
    
    
    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($u_fichier);
    
    // ---------------------------------------------------------------
    
    $fo = fopen($u_fichier,"w");
    
    fputs($fo,"<?php\n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
    
    $i = 0;
    foreach($result as $cle => $valeur) {
        foreach($valeur as $cle2 => $valeur2) {
          fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
          stripslashes(\"".addslashes($valeur2)."\");\n");
        }
        $i++;
    }
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }
  
  public function del($u_fichier,$where) {
    if(!file_exists($u_fichier))
      return false;
    if(!isset($FILE_LAST_ID))
      $FILE_LAST_ID = 0;
    
    require($u_fichier);
    
    if(!isset($FILE))
      return false; // Il n'y a rien à retourner
    elseif(!$this->is_assoc_multi_array($FILE))
      return false;
    elseif($this->crypt_on)
      $FILE = $this->decryptTest($FILE);
    
    if($where) {
      if(!is_array($where)) {
        
        $result = $FILE;
        
        foreach($FILE as $k => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          $LINE = $valeur;
          $eval = "if($where) { unset(\$result[\$k]); }";
          echo $eval."<br>";
          ob_start(); // Securité pour ne rien afficher à l'écran
          eval($eval);
          ob_clean();
        }
      }
      else {
      
        $a_where = $where;
      
        $result = $FILE;
        
        foreach($FILE as $cle => $valeur) {
        // On parcourt le fichier pour trouver les lignes à retourner
          foreach($a_where as $cle2 => $valeur2) {
          // On parcourt le tableau where à chaque ligne du fichier
          //pour voir si il correspond avec where
            if(is_array($valeur2)) {
              if(in_array($valeur[$cle2],$valeur2))
                unset($result[$cle]);
            }
            else {
              if($valeur[$cle2] == $valeur2)
                unset($result[$cle]);
            }
          }
        }
      }
    }
    else
      $result = array();
    
    // ---------------------------------------------------------------
    
    $_result = array();
    
    foreach($result as $valeur) {
    // Pour que les indices se suivent (on a supprimé certains avant)
      $_result[] = $valeur;
    }
    
    $result = $_result;
    
    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($u_fichier);
    
    // ---------------------------------------------------------------
    
    $fo = fopen($u_fichier,"w");
    
    fputs($fo,"<?php\n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
    
    $i = 0;
    foreach($result as $cle => $valeur) {
        foreach($valeur as $cle2 => $valeur2) {
          fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
          stripslashes(\"".addslashes($valeur2)."\");\n");
        }
        $i++;
    }
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }
  
  public function uRead($u_fichier) {
    if(!file_exists($u_fichier))
      return false;
    
    require($u_fichier);
    
    if(!isset($FILE))
      return array(); // Il n'y a rien à retourner

    return $FILE;
  }
  
  public function uMod($u_fichier,$a_mod) {
    if(file_exists($u_fichier))
      require($u_fichier);
      
    if(!isset($FILE))
      $FILE = array();
    
    $result = array_merge($FILE,$a_mod);

    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($u_fichier);
    
    // ---------------------------------------------------------------

    $fo = fopen($u_fichier,"w");
    
    fputs($fo,"<?php\n");
    
    $str_put = "\$FILE = ".var_export($result,true)."\n";
    
    fputs($fo,$str_put);
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }
  
  // ---------------------------------------------------------------
  
  public function select_start($u_fichier,&$var_to_affect_read = false) {
    if(file_exists($u_fichier)) {
      require($u_fichier);
      
      if(!isset($FILE))
        $FILE = array();
      elseif($this->crypt_on)
        $FILE = $this->decryptTest($FILE);
        
      $this->select_u_fichier = $u_fichier;
      $this->select_a_read = $FILE;
      $var_to_affect_read = $FILE;
      
      return true;
    }
    else
      return false;
  }
  
  public function select() {
    $i = 0;
    
    if($this->select_a_read) {
      while(!isset($this->select_a_read[$i])) {
        $i++;
      }
      
      $result = $this->select_a_read[$i];
      unset($this->select_a_read[$i]);
      
      return $result;
    }
    else
      return false;
  }
  
  public function select_close($a_to_write) {
  
    if(!$this->select_u_fichier)
      return false;
    
    // FLOCK ---------------------------------------------------------
    
    $pathInf = pathinfo($this->select_u_fichier);
    $flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
    
    if($this->flock_on) {
      touch($flockFilename);
      $ffo = fopen($flockFilename,"r"); // File flock open
      flock($ffo,LOCK_EX);
    }
    else
      if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
        unlink($flockFilename);
    
    // ---------------------------------------------------------------
    
    // BACKUP --------------------------------------------------------
    
    $this->backupTest($this->select_u_fichier);
    
    // ---------------------------------------------------------------
    
    $result = array();
    $i = 0;
    
    if($this->crypt_on or $this->hash_on) {
      foreach($a_to_write as $valeur) {
        $result[$i] = $this->cryptAndHashTest($valeur);
        $i++;
      }
    }
    else
      $result = $a_to_write;

    $fo = fopen($this->select_u_fichier,"w");
    
    fputs($fo,"<?php\n");
    
    $i = 0;
    foreach($result as $cle => $valeur) {
        foreach($valeur as $cle2 => $valeur2) {
          fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
          stripslashes(\"".addslashes($valeur2)."\");\n");
        }
        $i++;
    }
    
    fputs($fo,"?>");
    
    fclose($fo);
    
    // FLOCK ---------------------------------------------------------
    
    if($this->flock_on) {
      flock($ffo,LOCK_UN);
      fclose($ffo);
    }
    
    // ---------------------------------------------------------------
    
    return true;
  }
  
  // ---------------------------------------------------------------
}

?>