Source for file jDatatype.class.php

Documentation is available at jDatatype.class.php

  1. <?php
  2. /**
  3. @package     jelix
  4. @subpackage  utils
  5. @author      Laurent Jouanneau
  6. @contributor Julien Issler
  7. @copyright   2006-2009 Laurent Jouanneau
  8. @copyright   2008 Julien Issler
  9. @link        http://www.jelix.org
  10. @licence     http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
  11. */
  12. /**
  13.  * interface for datatypes which can filter value
  14.  * @package     jelix
  15.  * @subpackage  utils
  16.  * @since 1.1
  17.  */
  18. interface jIFilteredDatatype {
  19.     /**
  20.      * return the value on which filters are applied
  21.      * should be call after a call of check() method
  22.      */
  23.     public function getFilteredValue();
  24. }
  25. /**
  26.  *
  27.  * @package     jelix
  28.  * @subpackage  utils
  29.  */
  30. abstract class jDatatype {
  31.  
  32.     protected $hasFacetsfalse;
  33.     protected $facets = array();
  34.  
  35.     /**
  36.     * call it to add restriction on possible values
  37.     * @param string $type 
  38.     * @param string $value 
  39.     */
  40.     public function addFacet($type,$value=null){
  41.         if(in_array($type$this->facets)){
  42.             $this->hasFacets = true;
  43.             $this->_addFacet($type,$value);
  44.         }
  45.     }
  46.  
  47.     /**
  48.     * get a restriction value
  49.     * @param string $type 
  50.     * @return mixed  the value
  51.     * @since 1.0
  52.     */
  53.     public function getFacet($type){
  54.         if(in_array($type$this->facets)){
  55.             return $this->$type;
  56.         }
  57.         return null;
  58.     }
  59.  
  60.     protected function _addFacet($type,$value){
  61.         $this->$type $value;
  62.     }
  63.  
  64.     /**
  65.     * verify a value : it should correspond to the datatype
  66.     * @param string   $value 
  67.     * @return boolean true if the value is ok
  68.     */
  69.     public function check($value){
  70.         return true;
  71.     }
  72. }
  73.  
  74. /**
  75.  * Datatype String.
  76.  *
  77.  * Possible facets are: 'length','minLength','maxLength', 'pattern'
  78.  * @package     jelix
  79.  * @subpackage  utils
  80.  */
  81. class jDatatypeString extends jDatatype {
  82.     protected $length=null;
  83.     protected $minLength=null;
  84.     protected $maxLength=null;
  85.     protected $pattern=null;
  86.     protected $facets = array('length','minLength','maxLength''pattern');
  87.  
  88.     public function check($value){
  89.         if($this->hasFacets){
  90.             $len iconv_strlen($value$GLOBALS['gJConfig']->charset);
  91.             if($this->length !== null && $len != $this->length)
  92.                 return false;
  93.             if($this->minLength !== null && $len $this->minLength)
  94.                 return false;
  95.             if($this->maxLength !== null && $len $this->maxLength)
  96.                 return false;
  97.             if($this->pattern !== null && !preg_match($this->pattern,$value))
  98.                 return false;
  99.         }
  100.         return true;
  101.     }
  102. }
  103.  
  104. /**
  105.  * Datatype HTML String.
  106.  *
  107.  * Possible facets are: 'length','minLength','maxLength'
  108.  * @package     jelix
  109.  * @subpackage  utils
  110.  * @since 1.1
  111.  */
  112. class jDatatypeHtml extends jDatatype implements jIFilteredDatatype {
  113.     protected $length=null;
  114.     protected $minLength=null;
  115.     protected $maxLength=null;
  116.     protected $facets = array('length','minLength','maxLength');
  117.     public $outputXhtml = false;
  118.  
  119.     protected $newValue;
  120.  
  121.     public function __construct($aOutputXhtml false{
  122.         $this->outputXhtml = $aOutputXhtml;
  123.     }
  124.  
  125.     public function check($value){
  126.         if($this->hasFacets){
  127.             $len iconv_strlen($value$GLOBALS['gJConfig']->charset);
  128.             if($this->length !== null && $len != $this->length)
  129.                 return false;
  130.             if($this->minLength !== null && $len $this->minLength)
  131.                 return false;
  132.             if($this->maxLength !== null && $len $this->maxLength)
  133.                 return false;
  134.         }
  135.         $this->newValue = jFilter::cleanHtml($value$this->outputXhtml);
  136.         return is_string($this->newValue);
  137.     }
  138.  
  139.     public function getFilteredValue({
  140.         return $this->newValue;
  141.     }
  142. }
  143.  
  144. /**
  145.  * Datatype BoolĂ©en
  146.  * @package     jelix
  147.  * @subpackage  utils
  148.  */
  149. class jDatatypeBoolean extends jDatatype {
  150.     public function check($valuereturn jFilter::isBool($value)}
  151. }
  152.  
  153. /**
  154.  * Datatype Decimal
  155.  *
  156.  * Possible facets are: 'maxValue', 'minValue'
  157.  * @package     jelix
  158.  * @subpackage  utils
  159.  */
  160. class jDatatypeDecimal extends jDatatype {
  161.     // xxxx.yyyyy
  162.     protected $maxValue=null;
  163.     protected $minValue=null;
  164.     protected $facets = array('maxValue''minValue');
  165.     public function check($valuereturn jFilter::isFloat($value$this->minValue$this->maxValue)}
  166.     protected function _addFacet($type,$value){
  167.         if($type == 'maxValue' || $type == 'minValue'){
  168.             $this->$type floatval($value);
  169.         }
  170.     }
  171. }
  172.  
  173. /**
  174.  * Datatype Integer
  175.  * @package     jelix
  176.  * @subpackage  utils
  177.  */
  178. class jDatatypeInteger extends jDatatypeDecimal {
  179.     public function check($valuereturn jFilter::isInt($value$this->minValue$this->maxValue)}
  180.     protected function _addFacet($type,$value){
  181.         if($type == 'maxValue' || $type == 'minValue'){
  182.             $this->$type intval($value);
  183.         }
  184.     }
  185. }
  186.  
  187.  
  188. /**
  189.  * Datatype Hexa
  190.  * @package     jelix
  191.  * @subpackage  utils
  192.  */
  193. class jDatatypeHexadecimal extends jDatatypeDecimal {
  194.     public function check($value{
  195.         if(substr($value,0,2!= '0x'$value='0x'.$value;
  196.         return jFilter::isHexInt($value$this->minValue$this->maxValue);
  197.     }
  198.     protected function _addFacet($type,$value){
  199.         if($type == 'maxValue' || $type == 'minValue'){
  200.             $this->$type intval($value,16);
  201.         }
  202.     }
  203. }
  204.  
  205.  
  206. /**
  207.  * Datatype datetime
  208.  *
  209.  * Possible facets are: 'maxValue', 'minValue'
  210.  * @package     jelix
  211.  * @subpackage  utils
  212.  */
  213. class jDatatypeDateTime extends jDatatype {
  214.     protected $facets = array('maxValue''minValue');
  215.     protected $maxValue;
  216.     protected $minValue;
  217.     private $dt;
  218.     protected $format=21;
  219.     protected $_date_format = 'Y-m-d H:i:s';
  220.     public function check($value{
  221.         $this->dt new jDateTime();
  222.         if(!$this->dt->setFromString($value,$this->format)) return false;
  223.         if($this->maxValue !== null){
  224.             if($this->dt->compareTo($this->maxValue== 1return false;
  225.         }
  226.         if($this->minValue !== null){
  227.             if($this->dt->compareTo($this->minValue== -1return false;
  228.         }
  229.         return true;
  230.     }
  231.  
  232.     protected function _addFacet($type,$value){
  233.         if($type == 'maxValue' || $type == 'minValue'){
  234.             if(!preg_match('#^\d{4}-\d{2}-\d{2} (\d{2}:\d{2}(:\d{2})?)?$#',$value))
  235.                 $value date($this->_date_format,strtotime($value));
  236.             $this->$type new jDateTime();
  237.             $this->$type->setFromString($value,$this->format);
  238.         }
  239.         else
  240.             parent::_addFacet($type,$value);
  241.     }
  242.     /**
  243.      * @since 1.0
  244.      */
  245.     public function getFormat(return $this->format}
  246. }
  247.  
  248. /**
  249.  * Datatype time
  250.  * @package     jelix
  251.  * @subpackage  utils
  252.  */
  253. class jDatatypeTime extends jDatatypeDateTime {
  254.     protected $format=22;
  255. }
  256. /**
  257.  * Datatype date
  258.  * @package     jelix
  259.  * @subpackage  utils
  260.  */
  261. class jDatatypeDate extends jDatatypeDateTime {
  262.     protected $format=20;
  263.     protected $_date_format = 'Y-m-d';
  264. }
  265.  
  266. /**
  267.  * Datatype localedatetime
  268.  * @package     jelix
  269.  * @subpackage  utils
  270.  */
  271. class jDatatypeLocaleDateTime extends jDatatypeDateTime {
  272.     protected $format=11;
  273. }
  274.  
  275. /**
  276.  * Datatype localedate
  277.  * @package     jelix
  278.  * @subpackage  utils
  279.  */
  280. class jDatatypeLocaleDate extends jDatatypeDateTime {
  281.     protected $format=10;
  282. }
  283.  
  284. /**
  285.  * Datatype localetime
  286.  * @package     jelix
  287.  * @subpackage  utils
  288.  */
  289. class jDatatypeLocaleTime extends jDatatypeDateTime {
  290.     protected $format=12;
  291. }
  292.  
  293.  
  294. /**
  295.  * Datatype url
  296.  *
  297.  * Possible facets are: 'schemeRequired','hostRequired','pathRequired', 'queryRequired'.
  298.  * all are booleans.
  299.  * @package     jelix
  300.  * @subpackage  utils
  301.  */
  302. class jDatatypeUrl extends jDatatype {
  303.     protected $schemeRequired=true;
  304.     protected $hostRequired=true;
  305.     protected $pathRequired=null;
  306.     protected $queryRequired=null;
  307.  
  308.     protected $facets = array('schemeRequired','hostRequired','pathRequired''queryRequired');
  309.  
  310.     public function check($value){
  311.         return jFilter::isUrl($value$this->schemeRequired$this->hostRequired$this->pathRequired$this->queryRequired);
  312.     }
  313. }
  314.  
  315. /**
  316.  * Datatype ipv4
  317.  * @package     jelix
  318.  * @subpackage  utils
  319.  */
  320. class jDatatypeIPv4 extends jDatatype {
  321.     public function check($value){
  322.         return jFilter::isIPv4($value);
  323.     }
  324. }
  325.  
  326. /**
  327.  * Datatype ipv6
  328.  * @package     jelix
  329.  * @subpackage  utils
  330.  */
  331. class jDatatypeIPv6 extends jDatatype {
  332.     public function check($value){
  333.         return jFilter::isIPv6($value);
  334.     }
  335. }
  336.  
  337. /**
  338.  * Datatype mail
  339.  * @package     jelix
  340.  * @subpackage  utils
  341.  */
  342. class jDatatypeEmail extends jDatatype {
  343.     public function check($value){
  344.         return jFilter::isEmail($value);
  345.     }
  346. }

Documentation generated on Thu, 22 Mar 2012 22:15:04 +0100 by phpDocumentor 1.4.3