library/Zend/CodeGenerator/Php/Property/DefaultValue.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_CodeGenerator
  17  * @subpackage PHP
  18  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  19  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  20  * @version    $Id: DefaultValue.php 16971 2009-07-22 18:05:45Z mikaelkael $
  21  */
  22
  23 /**
  24  * @see Zend_CodeGenerator_Php_Abstract
  25  */
  26 require_once 'Zend/CodeGenerator/Php/Abstract.php';
  27
  28 /**
  29  * @category   Zend
  30  * @package    Zend_CodeGenerator
  31  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  32  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  33  */
  34 class Zend_CodeGenerator_Php_Property_DefaultValue extends Zend_CodeGenerator_Php_Abstract
  35 {
  36     /**#@+
  37      * Constant values
  38      */
  39     const TYPE_AUTO     = 'auto';
  40     const TYPE_BOOLEAN  = 'boolean';
  41     const TYPE_BOOL     = 'bool';
  42     const TYPE_NUMBER   = 'number';
  43     const TYPE_INTEGER  = 'integer';
  44     const TYPE_INT      = 'int';
  45     const TYPE_FLOAT    = 'float';
  46     const TYPE_DOUBLE   = 'double';
  47     const TYPE_STRING   = 'string';
  48     const TYPE_ARRAY    = 'array';
  49     const TYPE_CONSTANT = 'constant';
  50     const TYPE_NULL     = 'null';
  51     const TYPE_OTHER    = 'other';
  52     /**#@-*/
  53
  54     /**
  55      * @var array of reflected constants
  56      */
  57     protected static $_constants = array();
  58
  59     /**
  60      * @var mixed
  61      */
  62     protected $_value = null;
  63
  64     /**
  65      * @var string
  66      */
  67     protected $_type  = self::TYPE_AUTO;
  68
  69     /**
  70      * @var int
  71      */
  72     protected $_arrayDepth = 1;
  73
  74     /**
  75      * _init()
  76      *
  77      * This method will prepare the constant array for this class
  78      */
  79     protected function _init()
  80     {
  81         $reflect = new ReflectionClass(get_class($this));
  82         self::$_constants = $reflect->getConstants();
  83         unset($reflect);
  84     }
  85
  86     /**
  87      * isValidConstantType()
  88      *
  89      * @return bool
  90      */
  91     public function isValidConstantType()
  92     {
  93         if ($this->_type == self::TYPE_AUTO) {
  94             $type = $this->_getAutoDeterminedType($this->_value);
  95         }
  96
  97         // valid types for constants
  98         $scalarTypes = array(
  99             self::TYPE_BOOLEAN,
 100             self::TYPE_BOOL,
 101             self::TYPE_NUMBER,
 102             self::TYPE_INTEGER,
 103             self::TYPE_INT,
 104             self::TYPE_FLOAT,
 105             self::TYPE_DOUBLE,
 106             self::TYPE_STRING,
 107             self::TYPE_CONSTANT,
 108             self::TYPE_NULL
 109             );
 110
 111         return in_array($type, $scalarTypes);
 112     }
 113
 114     /**
 115      * setValue()
 116      *
 117      * @param mixed $value
 118      * @return Zend_CodeGenerator_Php_Property_DefaultValue
 119      */
 120     public function setValue($value)
 121     {
 122         $this->_value = $value;
 123         return $this;
 124     }
 125
 126     /**
 127      * getValue()
 128      *
 129      * @return mixed
 130      */
 131     public function getValue()
 132     {
 133         return $this->_value;
 134     }
 135
 136     /**
 137      * setType()
 138      *
 139      * @param string $type
 140      * @return Zend_CodeGenerator_Php_Property_DefaultValue
 141      */
 142     public function setType($type)
 143     {
 144         $this->_type = $type;
 145         return $this;
 146     }
 147
 148     /**
 149      * getType()
 150      *
 151      * @return string
 152      */
 153     public function getType()
 154     {
 155         return $this->_type;
 156     }
 157
 158     /**
 159      * setArrayDepth()
 160      *
 161      * @param int $arrayDepth
 162      * @return Zend_CodeGenerator_Php_Property_DefaultValue
 163      */
 164     public function setArrayDepth($arrayDepth)
 165     {
 166         $this->_arrayDepth = $arrayDepth;
 167         return $this;
 168     }
 169
 170     /**
 171      * getArrayDepth()
 172      *
 173      * @return int
 174      */
 175     public function getArrayDepth()
 176     {
 177         return $this->_arrayDepth;
 178     }
 179
 180     /**
 181      * _getValidatedType()
 182      *
 183      * @param string $type
 184      * @return string
 185      */
 186     protected function _getValidatedType($type)
 187     {
 188         if (($constName = array_search($type, self::$_constants)) !== false) {
 189             return $type;
 190         }
 191
 192         return self::TYPE_AUTO;
 193     }
 194
 195     /**
 196      * _getAutoDeterminedType()
 197      *
 198      * @param mixed $value
 199      * @return string
 200      */
 201     public function _getAutoDeterminedType($value)
 202     {
 203         switch (gettype($value)) {
 204             case 'boolean':
 205                 return self::TYPE_BOOLEAN;
 206             case 'integer':
 207                 return self::TYPE_INT;
 208             case 'string':
 209                 return self::TYPE_STRING;
 210             case 'double':
 211             case 'float':
 212             case 'integer':
 213                 return self::TYPE_NUMBER;
 214             case 'array':
 215                 return self::TYPE_ARRAY;
 216             case 'NULL':
 217                 return self::TYPE_NULL;
 218             case 'object':
 219             case 'resource':
 220             case 'unknown type':
 221             default:
 222                 return self::TYPE_OTHER;
 223         }
 224
 225         return self::TYPE_OTHER;
 226     }
 227
 228     /**
 229      * generate()
 230      *
 231      * @return string
 232      */
 233     public function generate()
 234     {
 235         $type = $this->_type;
 236
 237         if ($type != self::TYPE_AUTO) {
 238             $type = $this->_getValidatedType($type);
 239         }
 240
 241         $value = $this->_value;
 242
 243         if ($type == self::TYPE_AUTO) {
 244             $type = $this->_getAutoDeterminedType($value);
 245
 246             if ($type == self::TYPE_ARRAY) {
 247                 $rii = new RecursiveIteratorIterator(
 248                     $it = new RecursiveArrayIterator($value),
 249                     RecursiveIteratorIterator::SELF_FIRST
 250                     );
 251                 foreach ($rii as $curKey => $curValue) {
 252                     if (!$curValue instanceof Zend_CodeGenerator_Php_Property_DefaultValue) {
 253                         $curValue = new self(array('value' => $curValue));
 254                         $rii->getSubIterator()->offsetSet($curKey, $curValue);
 255                     }
 256                     $curValue->setArrayDepth($rii->getDepth());
 257                 }
 258                 $value = $rii->getSubIterator()->getArrayCopy();
 259             }
 260
 261         }
 262
 263         $output = '';
 264
 265         switch ($type) {
 266             case self::TYPE_STRING:
 267                 $output .= "'" . $value . "'";
 268                 break;
 269             case self::TYPE_NUMBER:
 270             case self::TYPE_INTEGER:
 271             case self::TYPE_INT:
 272             case self::TYPE_FLOAT:
 273             case self::TYPE_DOUBLE:
 274             case self::TYPE_NULL:
 275             case self::TYPE_CONSTANT:
 276                 $output .= $value;
 277                 break;
 278             case self::TYPE_ARRAY:
 279                 $output .= 'array(';
 280                 $curArrayMultiblock = false;
 281                 if (count($value) > 1) {
 282                     $curArrayMultiblock = true;
 283                     $output .= PHP_EOL . str_repeat($this->_indentation, $this->_arrayDepth+1);
 284                 }
 285                 $outputParts = array();
 286                 $noKeyIndex = 0;
 287                 foreach ($value as $n => $v) {
 288                     $v->setArrayDepth($this->_arrayDepth + 1);
 289                     $partV = $v->generate();
 290                     $partV = substr($partV, 0, strlen($partV)-1);
 291                     if ($n === $noKeyIndex) {
 292                         $outputParts[] = $partV;
 293                         $noKeyIndex++;
 294                     } else {
 295                         $outputParts[] = (is_int($n) ? $n : "'" . $n . "'") . ' => ' . $partV;
 296                     }
 297
 298                 }
 299                 $output .= implode(',' . PHP_EOL . str_repeat($this->_indentation, $this->_arrayDepth+1), $outputParts);
 300                 if ($curArrayMultiblock == true) {
 301                     $output .= PHP_EOL . str_repeat($this->_indentation, $this->_arrayDepth+1);
 302                 }
 303                 $output .= ')';
 304                 break;
 305             case self::TYPE_OTHER:
 306             default:
 307                 throw new Exception('I dont know this type');
 308         }
 309
 310         $output .= ';';
 311
 312         return $output;
 313     }
 314 }