GÉRER LES ACCÈS À UNE BASE DE DONNÉES VIA UNE DAO

<?php
namespace GenDao;

//require_once realpath(dirname(__FILE__)).'/../config/Logger.php';
//require_once realpath(dirname(__FILE__)).'/../util/Util.class.php';
//require_once realpath(dirname(__FILE__)).'/../dal/Dal.class.php';
//require_once realpath(dirname(__FILE__)).'/../dal/DalPeer.class.php';

require_once realpath(dirname(__FILE__)).'/../model_autoload.php';

/**
 * Description of SqlRequest
 *
 * @author Guillaume Genet
 */
class SqlRequest
{
    /*________________________________________________________________________*/
    /**
     * Permet de récuperer les informations sur une table
     * @param <string> $table
     * @return <PDOStatement>
     */
    public static function showColumns($table)
    {
        Util::emptyException($table);
        
        $conn = DalPeer::getConnection();

        $query = 'SHOW COLUMNS FROM '.$table;
	      $recordset = $conn->query($query);

	      if($recordset === false)
            throw new \Exception("la table ".$table." n'existe pas");
        else
            return $recordset->fetchAll(\PDO::FETCH_ASSOC);
    }

    /*________________________________________________________________________*/
     /**
      * Permet de tester si la table existe
      * @param <string> $table
      * @return <bool>
      */
    public static function existTable($table)
    {
        Util::emptyException($table);

        $conn = DalPeer::getConnection();
        $query = 'DESC '.$table;
	      $recordset = $conn->query($query);

	      return ($recordset instanceof  \PDOStatement);
    }

    /*________________________________________________________________________*/
    /** */
    /**
     * Permet de tester si la colonne existe dans la table
     * @param <string> $table le nom de la table
     * @param <string> $field nom du champ
     * @return <boolean>
     */
    public static function existColumns($table, $field)
    {
        Util::emptyException($table);
        Util::emptyException($field);

        $field = strtolower(trim($field));
	      $champTable = static::showColumns($table);

        foreach ($champTable as $tableField)
        {
            if(strtolower(trim($tableField['Field'])) == $field) return true;
        }
 
	      return false;
    }

    /*________________________________________________________________________*/
    /**
     * permet de genérer la clause where/set 
     * @param array $clause tableau ex:array('ville'=>'clermont-ferrand','nom'=>'genet') --> ville = 'clermont-ferrand' and nom='genet'
     * @param PDO $conn
     * @return <string> la chaine sql
     */
    public static function clause(array $clause, PDO $conn = null)
    {
        Util::nullException($clause);
        
      	$query = "";
      	$and = 0;
              
      	if($conn === null)
                  $conn = DalPeer::getConnection();
      
      	foreach($clause as $element => $valeur)
      	{
      	    $temp = "";
      	    if($and === 1)
      		$temp .= " and ";
      
      	    $temp .= $element."=";
      
      	    if (is_numeric($valeur))
      		$temp .= $valeur;
      	    else
      		$temp .= $conn->quote($valeur,\PDO::PARAM_STR); //rajoute les quotes et protège la requête sql en ajoutant les \
      
      	    $and = 1;
      	    $query .= $temp;
      	}
              
      	return $query;
    }

    /*________________________________________________________________________*/
    protected static function getClauseWhere($where,$conn = null)
    {
        if(empty($where)) return "";

        if($conn === null)
            $conn = DalPeer::getConnection();

        $query = "";
        $query .= ' WHERE ';

        if(is_array($where))
        {
            $query .= static::clause($where);
        }
        elseif(is_string($where))
        {
            $query .= $conn->quote($where,\PDO::PARAM_STR); //rajoute les quotes et protège la requête sql en ajoutant les \
        }
        else
            throw new \Exception("La clause where doit être un string ou un tableau");

        return $query;
    }

    /*________________________________________________________________________*/
    /**
     * Contruit la requete insert
     * @param <string> $table le nom de la table
     * @param array $elements
     * @return <int> l'identifiant de la ligne insérée
     */
    public static function insert($table, array $elements)
    {
        Util::emptyException($table);
        Util::emptyException($elements);
        
        $conn = DalPeer::getConnection();

	      $keys = array_keys($elements);
	      $values = array_values($elements);

	      $query = "INSERT INTO " . $table . " (";

        $query .= implode(', ',$keys);

        $query .= ") values (";
        $countValues = count($values);
	      for ($i = 0; $i < $countValues; $i++) //ajout des valeurs
	      {
	         if (is_numeric($values[$i]))
		          $query .= $values[$i];
	         else
		          $query .= $conn->quote($values[$i],\PDO::PARAM_STR); //pour protéger la requête sql
	     
           if ($i != count($values) - 1)
	         {
		          $query .= ", ";
	         }
	      }

	      $query .= " )";

        $flag = $conn->exec($query);

        $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
        if($logger->isDebugEnabled())
            $logger->debug('insert: '.$query.' --> nbLigneInsert='.$flag);

        if($flag === 1)
            $flag = $conn->lastInsertId(); //on récupère l'id
        else
            if($flag === false)
                throw new \Exception("erreur lors de la reqête insertion - erreur:".Util::printPdoError($conn->errorInfo()));
        
        return $flag;
    }

    /*________________________________________________________________________*/
    /**
     * Contruit la requete insert en utilisant un prepareStatement
     * @param <string> $table le nom de la table
     * @param <array> $elements
     * @return <int> l'identifiant de la ligne insérée
     */
    public static function insertPrepareStatement($table, array $elements)
    {
        Util::emptyException($table);
        Util::emptyException($elements);
        $conn = DalPeer::getConnection();

        $fieldNames = array_keys($elements); //recupère le nom des champs

        $query = 'INSERT INTO '.$table;

        $fields = '( ' . implode(' ,', $fieldNames) . ' )';
        $values = '(:' . implode(', :', $fieldNames) . ' )';

        $query .= $fields.' VALUES '.$values;

        $stmt = $conn->prepare($query);

        $flag = $stmt->execute($elements);
        $stmt->closeCursor();

        $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
        if($logger->isDebugEnabled())
            $logger->debug('insert: '.$query.' --> nbLigneInsert='.$flag);

        if($flag === true)
            $flag = $conn->lastInsertId(); //on récupère l'id
        else
            if($flag === false)
                throw new \Exception("erreur lors de la reqête insertion - erreur:".Util::printPdoError($conn->errorInfo()));

        return $flag;
    }

    /*________________________________________________________________________*/
    /**
     * Contruit la requete update
     * @param <string> $table
     * @param <array> $update
     * @param <array|string> $where
     * @return <int> le nombre de ligne modifiée
     */
    public static function update($table, array $update, $where)
    {
        Util::emptyException($table);
        Util::emptyException($update);
        Util::emptyException($where);

        $conn = DalPeer::getConnection();
        $query = 'UPDATE '.$table.' SET ';

     	 $i=0;
    	 foreach ($update as $key => $value)
    	 {
    	    $query .= $key.'='.$conn->quote($value,\PDO::PARAM_STR);
    	    if ($i != count($update) - 1)
    	    {
    		      $query .= ", ";
    	    }
    	    $i++;
    	 }

        $query .= static::getClauseWhere($where);

        $flag = $conn->exec($query);

        $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
        if($logger->isDebugEnabled())
            $logger->debug('update: '.$query.' --> nbLigneUpdate='.$flag);

        if($flag === false)
            throw new \Exception("erreur lors de la reqête update - erreur:".Util::printPdoError($conn->errorInfo()));
        
        return $flag;
    }

    /*________________________________________________________________________*/
    /**
    * Contruit la requete update
    * @param <string> $table
    * @param <array> $update
    * @param <array> $where
    * @return <int> le nombre de ligne modifiée
    */
    public function updatePrepareStatement($table, array $update, array $where)
    {
        Util::emptyException($table);
        Util::emptyException($update);
        Util::emptyException($where);

        $conn = DalPeer::getConnection();
        $query = 'UPDATE '.$table.' SET ';

        $updateKeys = array_keys($update);
        $whereKeys = array_keys($where);

        $countUpdate = count($updateKeys);
        for($i = 0; $i < $countUpdate ; $i++) //construction de la première partie set titre=:titre, message=:message
        {
            $query.= $updateKeys[$i]." = :".$updateKeys[$i];
            if($i != $countUpdate-1)
                $query.=", ";
        }

        $query .= " WHERE ";

        $countWhere = count($whereKeys);
        for($i = 0; $i < $countWhere ; $i++)
        {
            $query.=$whereKeys[$i]." = :".$whereKeys[$i];
            if($i != $countWhere-1)
                $query .= " and ";
        }

        $args = array_merge($update, $where);//on fusionne les 2 tableaux pour le prepareStatement

        $sth = $conn->prepare($query);
        $flag = $sth->execute($args);

        $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
        if($logger->isDebugEnabled())
            $logger->debug('update: '.$query.' --> nbLigneUpdate='.$flag);

        if($flag === false)
            throw new \Exception("erreur lors de la reqête update - erreur:".Util::printPdoError($conn->errorInfo()));

        return $flag;
    }
    
    /*________________________________________________________________________*/
    /**
     * Contruit la requete delete
     * @param <string> $table nom de la table
     * @param array|string $where
     * @return <int> le nombre de ligne supprimée
     */
    public static function delete($table, $where = null)
    {
        Util::emptyException($table);

	      $conn = DalPeer::getConnection();
        $query = 'DELETE FROM '.$table;

        $query .= static::getClauseWhere($where);

        $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);

        $flag = $conn->exec($query);
        
        if($logger->isDebugEnabled())
            $logger->debug('delete: '.$query." --> nbLigneDelete=".$flag);
            
        if($flag === false)
            throw new \Exception("erreur lors du delete de l'objet en base - erreur:".Util::printPdoError($conn->errorInfo()));

        return $flag;
    }

    /*________________________________________________________________________*/
    /**
     * construit la requete sql select
     * @param <string> $table
     * @param array $elements
     * @param <array|string> $where
     * @param <array> $order
     * @param <bool> $desc
     * @param <int|array> $limit
     * @return <array<stdclass>>  la liste des enregistrements
     */
    public static function select($table, array $elements = null, $where = null,array $order = null,$desc = null, $limit = null)
    {
        Util::emptyException($table);

	      $conn = DalPeer::getConnection();
        $query = "SELECT ";

        if(empty($elements))
            $query .= " * ";
        else
            $query .= implode(",", $elements);
        
        $query .= " FROM " . $table;

        $query .= static::getClauseWhere($where);
        
        if(!empty($order))
        {
            $query .= " ORDER BY ";
            $countOrder = count($order);

            for ($i = 0; $i < $countOrder; $i++)
            {
                $query .= $order[$i];
                
           		  if($desc !== null && $desc === true) $query .=" DESC ";
          		  if ($i < count($order) - 1)
                {
                    $query .= ", ";
                }
            }
        }
        if($limit !== null )
        {
            if(is_array($limit))
            {
                if(count($limit) === 2)
                    $query .= " LIMIT ".$limit[0].", ".$limit[1];
                else
                    throw new \Exception("erreur: 2 arguments attendus pour LIMIT");
            }
            else
                $query .= " LIMIT ".$limit;
        }

        $recordset = $conn->query($query);

	      $result = null;

        if($recordset === false)
            throw new \Exception("erreur lors de la reqête :".$query." - erreur:".Util::printPdoError($conn->errorInfo()));
        else
      	{
            $recordset->setFetchMode(\PDO::FETCH_OBJ);
      	    $result = $recordset->fetchAll();
      
            $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
            if($logger->isDebugEnabled())
                $logger->debug('select: '.$query." --> result: ".Util::get_print_contents($result));
      	}
 
        return $result;
    }

    /*______________________________________________________________________________________________________________________________*/
     /**
     * construit la requete sql select avec un prepareStatement
     * @param <string> $table
     * @param array $elements
     * @param <array> $where
     * @param <array> $order
     * @param <bool> $desc
     * @param <int|array> $limit
     * @return <array<stdclass>>  la liste des enregistrements
     */
    public function selectPrepareStatement($table, array $elements = null,array $where = null, array $order = null,$desc = null, $limit = null)
    {
        Util::emptyException($table);

	      $conn = DalPeer::getConnection();
        $query = "SELECT ";

        if(empty($elements))
            $query .= " * ";
        else
        {
            $countInsert = count($elements);
            for($i = 0; $i < $countInsert ; $i++) //construction de la première partie set titre=:titre, message=:message
            {
                $query.= $elements[$i];
                if($i != $countInsert-1)
                    $query.=", ";
            }
        }

        $query .= " FROM " . $table;
        
        if(!empty($where))
        {
            $query .= " WHERE ";
            $whereKeys = array_keys($where);
            $countWhere = count($whereKeys);
            for($i = 0; $i < $countWhere ; $i++)
            {
                $query.=$whereKeys[$i]." = :".$whereKeys[$i];
                if($i != $countWhere-1)
                    $query .= " and ";
            }
        }

        if(!empty($order))
        {
            $query .= " ORDER BY ";
            $countOrder = count($order);
	          for ($i = 0; $i < $countOrder; $i++)
            {
                $query .= $order[$i];
          		  if($desc !== null && $desc === true) $query .=" DESC ";
          		  if ($i < count($order) - 1)
                {
                    $query .= ", ";
                }
            }
        }

        if($limit !== null )
        {
            if(is_array($limit))
            {
                if(count($limit) === 2)
                    $query .= " LIMIT ".$limit[0].", ".$limit[1];
                else
                    throw new \Exception("erreur: 2 arguments attendus pour LIMIT");
            }
            else
                $query .= " LIMIT ".$limit;
        }

        $sth = $conn->prepare($query);
        $flag = $sth->execute($where);

        if($flag === false)
            throw new \Exception("erreur lors de la reqête select : $query - erreur:".Util::printPdoError($sth->errorInfo()));

        $sth->setFetchMode(\PDO::FETCH_OBJ);
	      $result = $sth->fetchAll();

        $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
        if($logger->isDebugEnabled())
            $logger->debug('select: '.$query." --> result: ".Util::get_print_contents($result));
                
        return $result;
    }

    /*________________________________________________________________________*/
    /**
     * Execute une requete sql
     * @param <type> $query
     * @return <PDOStatement> recordset
     */
    public static function query($query)
    {
        Util::emptyException($query);
        
        $conn = DalPeer::getConnection();
        $recordset = $conn->query($query);

	      $result = null;

        $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
        if($logger->isDebugEnabled())
            $logger->debug('query_object: '.$query." --> result: ".Util::get_print_contents($result));

        if($recordset === false)
            throw new \Exception("erreur lors de l'execution de la reqête:".$query." - erreur:".Util::printPdoError($conn->errorInfo()));
        
        return $recordset;
    }
    
    /*________________________________________________________________________*/
    /* execute une requete sql et renvoi un tableau de tableau associatif*/
    public static function query_assoc($query)
    {
        $recordset = static::query($query);
        $recordset->setFetchMode(\PDO::FETCH_ASSOC);
	      $result = $recordset->fetchAll();
	
        return $result;
    }

    /*________________________________________________________________________*/
    /* execute une requete sql et renvoi un tableau d'objet*/
    public static function query_object($query)
    {
        $recordset = static::query($query);
        $recordset->setFetchMode(\PDO::FETCH_OBJ);
	      $result = $recordset->fetchAll();

        return $result;
    }

    /*________________________________________________________________________*/
    /* constuit la requete count */
    public static function count($table,$where = null)
    {
        Util::emptyException($table);

        $conn = DalPeer::getConnection();
        $query = "SELECT COUNT(*) as total FROM ".$table;

        $query .= static::getClauseWhere($where);

	      $recordset = $conn->query($query);

        if($recordset !== false)
        {
            $result = $recordset->fetch(\PDO::FETCH_ASSOC);           
            return $result["total"];
        }
        else
            if(!static::existTable($table)) //pour aider le debogage
                throw new \Exception("la table ".$table." n'existe pas");
            else
               throw new \Exception("erreur lors de l'execution de la reqête count - erreur:".Util::printPdoError($conn->errorInfo()));
    }
}
?>

/****************** la DAO ********************/
<?php
namespace GenDao;
/**
 * Description of Dao
 *
 * @author Guillaume Genet
 */
require_once realpath(dirname(__FILE__)).'/../model_autoload.php';


class Dao 
{
    /** Correspond à la clé primaire de la base de données */
    public static $ID = "id";

    /** tableau associatif permettant de stocker les champs issus de la base de données*/
    public $attributs = null;

    /** le nom de la classe source*/
    public $className = null;

    public $isNewInstance = false;

    public $isDeleted = false;

    /*________________________________________________________________________*/
    public static function getPrimaryKeyField()
    {
        return self::$ID;
    }
    
    /*________________________________________________________________________*/
    protected function setAttributs(array $attributs)
    {
        $this->attributs = $attributs;
    }

    /*________________________________________________________________________*/
    protected function initFields()
    {
        $champTable = SqlRequest::showColumns($this->className);
        if($champTable != null)
        {
            //construction des attributs de la classe
            if($this->attributs == null)
                foreach ($champTable as $field)
                {
                    $temp = strtolower($field['Field']);
                    $this->attributs[$temp] = null;
                }
        }
        else
            throw new \Exception($this->className." n'existe pas dans la base de données");
    }

    /*________________________________________________________________________*/
    /** constructeur */
    public function __construct($args=null)
    {
    	  //SqlRequest::query('SET NAMES utf8');
        $this->attributs = array();
        $this->className = get_called_class();
        $this->isNewInstance = true;
        $this->isDeleted = false;

        $this->initFields();
    }

    /*________________________________________________________________________*/
    public function isNew()
    {
         return $this->isNewInstance;
    }

    /*________________________________________________________________________*/
    protected function setNewInstance($bool)
    {
        $this->isNewInstance = $bool;
    }

    /*________________________________________________________________________*/
    public function isDeleted()
    {
         return $this->isDeleted;
    }

    /*________________________________________________________________________*/
    protected function setDeleted($bool)
    {
        $this->isDeleted = $bool;
    }

    /*________________________________________________________________________*/
    public function getClassName()
    {
        return $this->className;
    }

    /*________________________________________________________________________*/
    /* constuit la requete count */
    public static function count()
    {
        return SqlRequest::count(get_called_class());
    }

    /*________________________________________________________________________*/
    /**
     * Permet de convertir un objet de type stdClass(PDO) en class courante
     * @param stdClass $stdClass
     * @return <Object>
    */
    public static function convertToClass(\stdClass $stdClass)
    {
        $class = get_called_class();
        $dynamicClass = new $class; //nouvelle instance de classe
        $dynamicClass->setNewInstance(false);

        //convertion
        foreach ($stdClass as $champ=>$valeur)
        {
            $dynamicClass->$champ = $valeur;
        }

        return $dynamicClass;
    }

    /*________________________________________________________________________*/
    /**
     * Permet de récuperer l'objet en fonction de l'identifiant
     * @param <type> $id
     * @return <Object> une instance de classe
     */
    public static function getById($id)
    {
        $result = SqlRequest::selectPrepareStatement(get_called_class(),null,array(self::$ID=>$id));

        if(!empty($result))
        {
            $count = count($result);
            if($count === 1)
                return self::convertToClass($result[0]);
            else
                if($count > 1)
                    throw new \Exception("l'identifiant ".$id." est présent plusieurs fois dans la base de données");
        }
        return null;
    }

    /*________________________________________________________________________*/
    /* fait un select * sur la table */
    public static function getAll()
    {
        $stmt = SqlRequest::query("select * from ".get_called_class());
        //$stmt->setFetchMode(\PDO::FETCH_CLASS,get_called_class(),null);
        $stmt->setFetchMode(\PDO::FETCH_OBJ); 
        $result = $stmt->fetchAll();
        
      	foreach ($result as $line) //parcour des enregistrements
      	{
                  $listObjects[] = self::convertToClass($line);
      	}
         
        $stmt -> closeCursor();
         
        return $listObjects;
    }

    /*________________________________________________________________________*/
    /**
     * Permet de récuperer tous les objets en fonction des paramètres
     * @param <array|string>  $where la clause where de la requête
     * @param <numeric|array> $limit le nombre d'enregistrement envoyé
     * @param <array> $order un array contenant les champs de table, permet de trier les éléments
     * @param <boolean> $desc  vrai = tri décroissant, tri croissant sinon
     * @return <array> un array contenant les objets
     */
    public static function get($where = null, array $order = null, $desc = false, $limit = null)
    { 
        $listObjects = array();

        $recordset = SqlRequest::selectPrepareStatement(get_called_class(),null,$where,$order,$desc,$limit);
        foreach ($recordset as $line) //parcour des enregistrements
        {
            $listObjects[] = self::convertToClass($line);
	      }
    
	      return $listObjects;
    }

    /*________________________________________________________________________*/
    /** Permet de sauvegarder l'objet */
    public function save()
    {
        $newInstance = $this->isNew();
        $dal = DalPeer::getConnection();
        $flag = 0;
        
        if($newInstance)//on fait un insert en base
        {
            $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
            if($logger->isDebugEnabled())
              $logger->debug('doSave:insert');

            $flag = SqlRequest::insert($this->className, $this->attributs);
            if($flag >= 0)
            {
                $this->attributs[self::$ID] = $flag; //ajout de l'attribut id
                $this->setNewInstance(false);
            }
        }
        else //on fait un update en base
        {
            if(!$this->isDeleted())
            {
                $logger = \Logger::getLogger(basename(dirname(__FILE__)).'.'.__CLASS__);
                if($logger->isDebugEnabled())
                    $logger->debug('doSave:update');
                    
                $flag = SqlRequest::update($this->className, $this->attributs, array(self::$ID=>$this->attributs[self::$ID]));
            }
            else
                throw new \Exception("erreur: impossible de sauvegarder des données préalablement supprimées");
        }
        
        return $flag;
    }

     /*________________________________________________________________________*/
    /** Permet de supprimer l'objet */
    public static function deleteById($id)
    {
        $dal = DalPeer::getConnection();
        $flag = SqlRequest::delete(get_called_class(),array(self::$ID => $id));

        return $flag;
    }

    /*________________________________________________________________________*/
    /** Permet de supprimer l'objet */
    public function delete()
    {
        $dal = DalPeer::getConnection();
        $flag = 0;
        
        if(!$this->isDeleted())
        {
            $flag = SqlRequest::delete($this->className,array(self::$ID => $this->attributs[self::$ID]));
            $this->setDeleted(true);
         }
         else
             throw new \Exception("erreur:appel de la fonction delete plusieurs fois à la suite");

         return $flag;
    }

    /*________________________________________________________________________*/
    /**
     * Permet d'accéder aux attributs de la classe (sans l'utilisation d'un getter ex: echo $article->titre;)
     * @param <string> $name le nom de l'attribut
     * @return <array> le tableau de résultat
     */
    public function  __get($name)
    {
	      $name = strtolower($name);
        if(array_key_exists($name, $this->attributs))
        {
            return $this->attributs[$name];
        }
        else
            throw new \Exception( "l'attribut ".$name. " n'existe pas pour l'objet ".$this->className);
    }

    /*________________________________________________________________________*/
    /** Permet d'accéder aux attributs de la classe (sans l'utilisation d'un setter ex: $article->titre='football')
     * @param <string> $name le nom de l'attribut
     * @param <object> $value 
     * @return <array> le tableau de résultat
     */
    public function  __set($name,  $value)
    {
	      $name = strtolower($name);
        if(array_key_exists($name, $this->attributs))//pour pas ajouter un element au tableau assosiatif
        {
            $this->attributs[$name] = $value;
        }
        else
            throw new \Exception("l'attribut ".$name. " n'existe pas pour l'objet ".$this->className);
    }

    /*________________________________________________________________________*/
    /** appel de méthode */
    public function __call($name,  $arguments)
    {
        $getterSetter = strtolower(substr($name, 0,3));

        //pour accéder aux attributs en utilisant les getters
        if($getterSetter === "get")
        {
            $attribut = strtolower(substr($name, 3));//nom de l'attribut
            return $this->__get($attribut);
        }
	      //pour affecter des attributs en utilisant les setters
        else if($getterSetter === "set")
        {
            $attribut = strtolower(substr($name, 3));
            $this->__set($attribut, $arguments[0]);
        }
        else
            throw new \Exception($name." est une méthode inconnue");
    }
}
?>