[Summary view] [Print] [Text view]

   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 [email protected] so we can send you a copy immediately.
  14   *
  15   * @category   Zend
  16   * @package    Zend_Server
  17   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  18   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  19   */
  20  
  21  /** Zend_Server_Interface */
  22  require_once 'Zend/Server/Interface.php';
  23  
  24  /**
  25   * Zend_Server_Definition
  26   */
  27  require_once 'Zend/Server/Definition.php';
  28  
  29  /**
  30   * Zend_Server_Method_Definition
  31   */
  32  require_once 'Zend/Server/Method/Definition.php';
  33  
  34  /**
  35   * Zend_Server_Method_Callback
  36   */
  37  require_once 'Zend/Server/Method/Callback.php';
  38  
  39  /**
  40   * Zend_Server_Method_Prototype
  41   */
  42  require_once 'Zend/Server/Method/Prototype.php';
  43  
  44  /**
  45   * Zend_Server_Method_Parameter
  46   */
  47  require_once 'Zend/Server/Method/Parameter.php';
  48  
  49  /**
  50   * Zend_Server_Abstract
  51   *
  52   * @category   Zend
  53   * @package    Zend_Server
  54   * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  55   * @license    http://framework.zend.com/license/new-bsd     New BSD License
  56   * @version    $Id$
  57   */
  58  abstract class Zend_Server_Abstract implements Zend_Server_Interface
  59  {
  60      /**
  61       * @deprecated
  62       * @var array List of PHP magic methods (lowercased)
  63       */
  64      protected static $magic_methods = array(
  65          '__call',
  66          '__clone',
  67          '__construct',
  68          '__destruct',
  69          '__get',
  70          '__isset',
  71          '__set',
  72          '__set_state',
  73          '__sleep',
  74          '__tostring',
  75          '__unset',
  76          '__wakeup',
  77      );
  78  
  79      /**
  80       * @var bool Flag; whether or not overwriting existing methods is allowed
  81       */
  82      protected $_overwriteExistingMethods = false;
  83  
  84      /**
  85       * @var Zend_Server_Definition
  86       */
  87      protected $_table;
  88  
  89      /**
  90       * Constructor
  91       *
  92       * Setup server description
  93       *
  94       * @return void
  95       */
  96      public function __construct()
  97      {
  98          $this->_table = new Zend_Server_Definition();
  99          $this->_table->setOverwriteExistingMethods($this->_overwriteExistingMethods);
 100      }
 101  
 102      /**
 103       * Returns a list of registered methods
 104       *
 105       * Returns an array of method definitions.
 106       *
 107       * @return Zend_Server_Definition
 108       */
 109      public function getFunctions()
 110      {
 111          return $this->_table;
 112      }
 113  
 114      /**
 115       * Lowercase a string
 116       *
 117       * Lowercase's a string by reference
 118       *
 119       * @deprecated
 120       * @param  string $string value
 121       * @param  string $key
 122       * @return string Lower cased string
 123       */
 124      public static function lowerCase(&$value, &$key)
 125      {
 126          trigger_error(__CLASS__ . '::' . __METHOD__ . '() is deprecated and will be removed in a future version', E_USER_NOTICE);
 127          return $value = strtolower($value);
 128      }
 129  
 130      /**
 131       * Build callback for method signature
 132       *
 133       * @param  Zend_Server_Reflection_Function_Abstract $reflection
 134       * @return Zend_Server_Method_Callback
 135       */
 136      protected function _buildCallback(Zend_Server_Reflection_Function_Abstract $reflection)
 137      {
 138          $callback = new Zend_Server_Method_Callback();
 139          if ($reflection instanceof Zend_Server_Reflection_Method) {
 140              $callback->setType($reflection->isStatic() ? 'static' : 'instance')
 141                       ->setClass($reflection->getDeclaringClass()->getName())
 142                       ->setMethod($reflection->getName());
 143          } elseif ($reflection instanceof Zend_Server_Reflection_Function) {
 144              $callback->setType('function')
 145                       ->setFunction($reflection->getName());
 146          }
 147          return $callback;
 148      }
 149  
 150      /**
 151       * Build a method signature
 152       *
 153       * @param  Zend_Server_Reflection_Function_Abstract $reflection
 154       * @param  null|string|object $class
 155       * @return Zend_Server_Method_Definition
 156       * @throws Zend_Server_Exception on duplicate entry
 157       */
 158      protected function _buildSignature(Zend_Server_Reflection_Function_Abstract $reflection, $class = null)
 159      {
 160          $ns         = $reflection->getNamespace();
 161          $name       = $reflection->getName();
 162          $method     = empty($ns) ? $name : $ns . '.' . $name;
 163  
 164          if (!$this->_overwriteExistingMethods && $this->_table->hasMethod($method)) {
 165              require_once 'Zend/Server/Exception.php';
 166              throw new Zend_Server_Exception('Duplicate method registered: ' . $method);
 167          }
 168  
 169          $definition = new Zend_Server_Method_Definition();
 170          $definition->setName($method)
 171                     ->setCallback($this->_buildCallback($reflection))
 172                     ->setMethodHelp($reflection->getDescription())
 173                     ->setInvokeArguments($reflection->getInvokeArguments());
 174  
 175          foreach ($reflection->getPrototypes() as $proto) {
 176              $prototype = new Zend_Server_Method_Prototype();
 177              $prototype->setReturnType($this->_fixType($proto->getReturnType()));
 178              foreach ($proto->getParameters() as $parameter) {
 179                  $param = new Zend_Server_Method_Parameter(array(
 180                      'type'     => $this->_fixType($parameter->getType()),
 181                      'name'     => $parameter->getName(),
 182                      'optional' => $parameter->isOptional(),
 183                  ));
 184                  if ($parameter->isDefaultValueAvailable()) {
 185                      $param->setDefaultValue($parameter->getDefaultValue());
 186                  }
 187                  $prototype->addParameter($param);
 188              }
 189              $definition->addPrototype($prototype);
 190          }
 191          if (is_object($class)) {
 192              $definition->setObject($class);
 193          }
 194          $this->_table->addMethod($definition);
 195          return $definition;
 196      }
 197  
 198      /**
 199       * Dispatch method
 200       *
 201       * @param  Zend_Server_Method_Definition $invocable
 202       * @param  array $params
 203       * @return mixed
 204       */
 205      protected function _dispatch(Zend_Server_Method_Definition $invocable, array $params)
 206      {
 207          $callback = $invocable->getCallback();
 208          $type     = $callback->getType();
 209  
 210          if ('function' == $type) {
 211              $function = $callback->getFunction();
 212              return call_user_func_array($function, $params);
 213          }
 214  
 215          $class  = $callback->getClass();
 216          $method = $callback->getMethod();
 217  
 218          if ('static' == $type) {
 219              return call_user_func_array(array($class, $method), $params);
 220          }
 221  
 222          $object = $invocable->getObject();
 223          if (!is_object($object)) {
 224              $invokeArgs = $invocable->getInvokeArguments();
 225              if (!empty($invokeArgs)) {
 226                  $reflection = new ReflectionClass($class);
 227                  $object     = $reflection->newInstanceArgs($invokeArgs);
 228              } else {
 229                  $object = new $class;
 230              }
 231          }
 232          return call_user_func_array(array($object, $method), $params);
 233      }
 234  
 235      /**
 236       * Map PHP type to protocol type
 237       *
 238       * @param  string $type
 239       * @return string
 240       */
 241      abstract protected function _fixType($type);
 242  }