CodeS-SourceS
Rechercher un code, un tuto, une réponse

Class mise en cache

Soyez le premier à donner votre avis sur cette source.

Snippet vu 2 fois

Contenu du snippet

Salut à tous!

Je viens ici proposer un petit bout de code que j'ai fait dans le cadre d'un petit projet php ayant pour objectif de charger de manière régulière des données et les copier si des conditions sont rempli.
Dans ce cadre, j'ai donc eu besoin d'avoir la possibilité de faire une mise en cache dans le cas oú les conditions ne seraient pas remplise pour pouvoir retenter la copie plus tard.
Une petite contrainte supplémentaire: passé un certain, la copie ne doit pas se faire.

Ce code source à donc pour objectif de gérer des données globale (en l etat actuel, la mise en tampon serai récupérable pour chaque session), mon projet n'ayant lui aucuns interet ici.

Donc pour commencer, la classe tampon :


class cStamp {
/*************************************************/
/**                     NOTE                    **/
/** function eq is mandatory in objects in list **/
/*************************************************/
 private $content=array();
 private $tempDirectory = "../temp/";
 private $tempExt = ".DAT";
 private $fileName;
 private $allowDuplicates;
 public function __construct($fName,$bDuplicates = false){
  $this->allowDuplicates = $bDuplicates ;
  $this->fileName = $fName;
  if($this->fileName != "") {
   $FComplete = $this->tempDirectory . $this->fileName . $this->tempExt;
   if(file_exists($FComplete)){
    $s = file_get_contents($FComplete);
    $this->content = unserialize($s);
    unlink($FComplete);
   }
  }
 }
 public function add($o){ 
  if($this->allowDuplicates){
   $this->content[] = $o;
  } else {
   $this->rem($o);
   $this->content[] = $o;
  }
 }
 public function rem($o){
  $i = 0;
  foreach($this->content as $value){
   if(is_object($o)) {
    if($value->eq($o)){
     unset($this->content[$i]);
    }
   } else {
    if($value == $o){
     unset($this->content[$i]);
    }
   }
   $i++;
  }
  $this->content = array_values($this->content);
 }
 public function get($bDelete = false) {
  $cCopy = $this->content; 
  if($bDelete) $this->content = array();
  return $cCopy;  
 }
 public function save(){
  $FComplete = $this->tempDirectory . $this->fileName . $this->tempExt;
  if(file_exists($FComplete)){
   unlink($FComplete);
  }
  $iFic = fopen($FComplete,"w");
  $s = serialize($this->content);
  file_put_contents($FComplete, $s);
 }
}


Je ne penses pas qu'il y ai de difficultées particulières à expliquer. Voici un petit descriptif:

Variables
Fixes
- $tempDirectory: répertoire qui contiendra les fichier de données mises en mémoire.
- $tempExt: extension des fichiers "tampon"
Bien sûr, rien n empêche de les rendre paramétrable (lors de la construction par exemple), mais dans ma spec, je n en ai pas l utilité.
"Settable" à la construction
- $fileName : nom du fichier => en fonction du cadre, on pourra utiliser un ID par exemple.
- $ballowDublicates : si on autorise ou non les doublons

+$content qui contiendra la mémoire en tampon lors des traitements.

Fonction

add
Ajouter un element au tampon.
rem
Retirer un élément du tableau (toutes ses occurences)
get
Récupérer le content. Si true est passé en paramètre, le tampon est ensuite vidé.
save
Enregistre le tampon !!à appeler à chaque fois qu'on veut faire une mise en mémoire!!

Voilà, maintenant on a une classe qui permet de sérialiser et déserialiser des objets et faires quelques manipulations simples, mais ce n'est pas suffisant.
La suite va donc donner un moyen d'utiliser cette classe de manière à gérer des données string datées (pour appliquer un principe de péremption).

class strHisto{
 public $dateTime; 
 public $strData; 
 public function __construct($o){
  $this->strData = $o;
  $this->dateTime = date("Y-m-d H:i:s");
 }
 public function eq($o) { 
  return ($o->strData == $this->strData);
 }
}


Rien de particulier là encore dans la lecture, par contre à noter que dans le cas ou l on souhaite avoir des objets, on rajoute la fonction "eq" (pour equal) pour tester les égalitée.

Une évolution possible serai d'utiliser les surcharges d'opérateurs, mais dans mon cas je ne peux pas. ( __is_identical pour surcharger === par exemple. une liste est dipo ici <undefined>http://www.web-d.be/post/296/surcharge-d%27op%C3%A9rateurs-php-(operator-overloading).html</undefined>

Donc maintenant, on a la classe qui s'occupe des objets et leurs sauvegarde ET le type qu'on veut mettre en mémoire.
Il ne reste plus qu'à rendre tout ca facilement accessible. Pour ca je me tourne vers les class static:

class Foo
{
 private static $oStampAWB = null;
 public static function getStampAWB() {
  $filename = "AWBSTAMPED"; 
  if(self::$oStampAWB == null) {
   self::$oStampAWB = new cStamp("AWBSTAMPED");
  }
  return self::$oStampAWB ;
 }

} 

Voilà dans mon cas je veux gérer une seule mise en tampn commune.

et maintenant je peux simplement gérer mon tampon en faisant :
Récupérer un contenu
 foo::getStampAWB->get(); 

Ajoute un élément
 foo::getStampAWB->add(new strHisto("mise en tampon")); 

Sauvegarder
 foo::getStampAWB->save(); 



Voilà, je penses que c'est très simple et que ca pourrai être utile pour certain (en tout cas moi ^^).
Si vous avez des question ou autres, dites moi.

naga

A voir également

Ajouter un commentaire

Commentaires

Donnez votre avis

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.