<?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;
}
}
?>