Location: PHPKode > scripts > Simple Files > simple-files/simplefiles2.class.php
<?php

/***********************************************************
 * Auteur : Mallory Dessaintes
 * Email de l'auteur : hide@address.com 
 * Site Web : http://oprichnik.monespace.be
 *
 * Documentation : "documentation.html"
 *
 *
 * VERSION : [2.1]
 *
 *
 * HISTORIQUE
 *
 * 1.1.6 : Amélioration du code pour la création des fichiers de verrouillage
 * 2 : Changement du fonctionnement de l'objet
 * 2.1 : Possibilité d'ajouter des champs
 * -----
 *
 ***********************************************************/

class Simplefiles {
	
	private $read_default_return_structure;
	private $lastId;
	
	private $flock_on;
	private $flock_dir;
	
	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_read;
	private $select_fileLastId;
	
	private $fileFlockOpen; // Ressource du fichier pour le flock
	
	public $u_fichier;
	public $fileInfos;
	
	// ---------------------------------------------------------------
	
	function __construct($u_fichier,$flockStatus = true,$flockDir = false,$backupStatus = false,$backupDir = false,$backupTime = 86400) {
	
		if(!is_file($u_fichier))
			touch($u_fichier);
	
		$this->u_fichier = $u_fichier;
		
		$this->fileInfos = pathinfo($u_fichier);
	
		$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;
		
		if($flockStatus)
			$this->setFlock(true,$flockDir);
			
		if($backupStatus)
			$this->setBackup(true,$backupDir,$backupTime);
	}
	
	// ---------------------------------------------------------------
	
	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['basename'].'_'.$last_num_backup.'.backup')) 
			$last_num_backup++;
			
		if(!file_exists($this->backup_dir.$pathInf['basename'].'_0.backup'))
			$filemtime = 0;
		else
			$filemtime = filemtime($this->backup_dir.$pathInf['basename'].'_'.($last_num_backup-1).'.backup');

		if(file_exists($u_fichier) && (time() - $filemtime > $this->backup_time))
			copy($u_fichier,$this->backup_dir.$pathInf['basename'].'_'.$last_num_backup.'.backup');
		}
	}
	
	private function flockTest($u_fichier,$a = 0) { // 0 open 1 close
		if($a == 0) {
			if($this->flock_on){
				$pathInf = pathinfo($u_fichier);
					
				if(!$this->flock_dir)
					$flockFilename = $pathInf['dirname'].'/'.$pathInf['basename'].'.flock';
				else
					$flockFilename = $this->flock_dir.$pathInf['basename'].'.flock';
			
				touch($flockFilename);
				
				$this->fileflockOpen = fopen($flockFilename,'r'); // File flock open
				
				flock($this->fileflockOpen,LOCK_EX);
			}
			else
				if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
					unlink($flockFilename);		
		}
		else {
			if($this->flock_on) {
				flock($this->fileflockOpen,LOCK_UN);
				fclose($this->fileflockOpen);
			}
		}
	}
	
	// ---------------------------------------------------------------
	
	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,$dir = false) {
		if($status) {
			$this->flock_on = true;
			
			if($dir) {
				if($dir[strlen($dir)-1] != '/')
					$dir .= '/';	
			
				$this->flock_dir = $dir;
			}
		}
		else
			$this->flock_on = false;
			
		return true;
	}
	
	public function setBackup($status,$dir = false,$time = 86400) {
		if($status == true) {
			if(is_numeric($time) == true) {
				$this->backup_on = true;
				$this->backup_time = $time;
				
				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 valueExist($value,$field,$caseSensitive = true) {
	
		if(!file_exists($this->u_fichier))
			return false;
		
		require($this->u_fichier);
	
		if(!isset($FILE))
			return false;
		elseif(!$this->is_assoc_multi_array($FILE))
			return false;
	
		if($caseSensitive)
			$value = strtolower($value);
	
		foreach($FILE as $line) {
			if($caseSensitive)
				$line[$field] = strtolower($line[$field]);
				
				if($line[$field] == $value)
					return true;
		}
		
		return false;
	}
	
	public function read($where = false,$orderBy = false,$limit = false,$i_return_structure = false) { # Ancienne structure where = "pseudo='oprichn,ik','dracau'&email='hide@address.com'"

		if(!file_exists($this->u_fichier))
			return false;
		
		require($this->u_fichier);
		
		if(!isset($FILE_LAST_ID))
			$FILE_LAST_ID = 0;
		
		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;
					
					$addLine = true;
					
					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))
								$addLine = false;
						}
						else {
							if($valeur[$cle2] != $valeur2)
								$addLine = false;
						}
					}
					
					if($addLine) {
						$result[] = $valeur;
						$addLine = true;
					}
				}
			}
		}
		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='hide@address.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($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($this->u_fichier)) {
			require($this->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 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 ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		// BACKUP --------------------------------------------------------
		
		$this->backupTest($this->u_fichier);
		
		// ---------------------------------------------------------------

		$fo = fopen($this->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 ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier,1);
		
		// ---------------------------------------------------------------
		
		return true;
	}

	public function mod($where,$a_mod) { // $a_mod est un tableau d'une dimension associatif
		if(!file_exists($this->u_fichier))
			return false;
		
		require($this->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 ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		// BACKUP --------------------------------------------------------
		
		$this->backupTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		$fo = fopen($this->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 ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier,1);
		
		// ---------------------------------------------------------------
		
		return true;
	}
	
	public function del($where) {
		if(!file_exists($this->u_fichier))
			return false;
		if(!isset($FILE_LAST_ID))
			$FILE_LAST_ID = 0;
		
		require($this->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]); }";

					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 ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		// BACKUP --------------------------------------------------------
		
		$this->backupTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		$fo = fopen($this->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 ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier,1);
		
		// ---------------------------------------------------------------
		
		return true;
	}

	public function addField($fieldName,$defaultValue) {
		if(!file_exists($this->u_fichier))
			return false;
		
		require($this->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;
		
		$result = $FILE;
		
		for($i=0;$i<count($result);$i++) {
			$result[$i][$fieldName] = $defaultValue;
		}
		
		// FLOCK ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		// BACKUP --------------------------------------------------------
		
		$this->backupTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		$fo = fopen($this->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 ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier,1);
		
		// ---------------------------------------------------------------
		
		return true;
	}
	
	public function getSimilarLines($field1,Simplefile $sf2,$field2) { // Retourne les lignes similaires du fichier 1 sur un champ (jointure)

		if(!file_exists($this->u_fichier))
			return false;
		
		require($this->u_fichier);
		
		if(!isset($FILE))
			return false;
			
		$f1 = $FILE;
		
		unset($FILE);
		
		if(!file_exists($sf2->u_fichier))
			return false;
			
			require($sf2->u_fichier);
			
			if(!isset($FILE))
				return false;
				
			$f2 = $FILE;
			
			unset($FILE);
		
		$result = array();
		
		foreach($f1 as $cle => $valeur) {
			foreach($f2 as $cle2 => $valeur2) {
				if($valeur[$field1] == $valeur2[$field2])
				$result[] = $valeur;
			}
		}
		
		return $result;
	}
	
	public function uRead() {
		if(!file_exists($this->u_fichier))
			return false;
		
		require($this->u_fichier);
		
		if(!isset($FILE))
			return array(); // Il n'y a rien à retourner

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

		// FLOCK ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		// BACKUP --------------------------------------------------------
		
		$this->backupTest($this->u_fichier);
		
		// ---------------------------------------------------------------

		$fo = fopen($this->u_fichier,'w');
		
		fputs($fo,"<?php\n");
		
		$str_put = "\$FILE = ".var_export($result,true)."\n";
		
		fputs($fo,$str_put);
		
		fputs($fo,'?>');
		
		fclose($fo);
		
		// FLOCK ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier,1);
		
		// ---------------------------------------------------------------
		
		return true;
	}
	
	public function file_put_contents($data) {
	
		// FLOCK ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		// BACKUP --------------------------------------------------------
		
		$this->backupTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		$fo = fopen($this->u_fichier,'w');
		fputs($fo,$data);
		fclose($fo);
		
		// FLOCK ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier,1);
		
		// ---------------------------------------------------------------
		
		return true;
	}
	
	// ---------------------------------------------------------------
	
	public function select_start(&$var_to_affect_read = false) {
		if(file_exists($this->u_fichier)) {
			require($this->u_fichier);
			
			if(!isset($FILE))
				$FILE = array();
			elseif($this->crypt_on)
				$FILE = $this->decryptTest($FILE);
				
			$this->select_a_read = $FILE;
			$this->select_fileLastId = $FILE_LAST_ID;
			
			$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) {
		
		// FLOCK ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier);
		
		// ---------------------------------------------------------------
		
		// BACKUP --------------------------------------------------------
		
		$this->backupTest($this->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->u_fichier,'w');
		
		if(!is_numeric($this->select_fileLastId)) $this->select_fileLastId = 0;

		fputs($fo,"<?php\n\$FILE_LAST_ID = ".$this->select_fileLastId.";\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 ---------------------------------------------------------
		
		$this->flockTest($this->u_fichier,1);
		
		// ---------------------------------------------------------------
		
		$this->select_a_read = false;
		
		return true;
	}
	
	// FONCTIONS DE DEVELLOPEMENT -----------------------------------
	
	public function vd($var,$varName = false,$die = true) {
		
		if($varName)
			$pref = '<b>'.$varName.'</b> :';
		
		if($die)
			die($pref.'<pre>'.var_export($var).'</pre>');
		else
			echo('<p>'.$pref.'<pre>'.var_export($var).'</pre></p>');
		
		return true;
	}
	
}

?>
Return current item: Simple Files