interface/modules/zend_modules/library/Zend/Server/AbstractServer.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Server;
  11
  12 use ReflectionClass;
  13
  14 /**
  15  * Abstract Server implementation
  16  */
  17 abstract class AbstractServer implements Server
  18 {
  19     /**
  20      * @var bool Flag; whether or not overwriting existing methods is allowed
  21      */
  22     protected $overwriteExistingMethods = false;
  23
  24     /**
  25      * @var Definition
  26      */
  27     protected $table;
  28
  29     /**
  30      * Constructor
  31      *
  32      * Setup server description
  33      *
  34      */
  35     public function __construct()
  36     {
  37         $this->table = new Definition();
  38         $this->table->setOverwriteExistingMethods($this->overwriteExistingMethods);
  39     }
  40
  41     /**
  42      * Returns a list of registered methods
  43      *
  44      * Returns an array of method definitions.
  45      *
  46      * @return Definition
  47      */
  48     public function getFunctions()
  49     {
  50         return $this->table;
  51     }
  52
  53     /**
  54      * Build callback for method signature
  55      *
  56      * @param  Reflection\AbstractFunction $reflection
  57      * @return Method\Callback
  58      */
  59     protected function _buildCallback(Reflection\AbstractFunction $reflection)
  60     {
  61         $callback = new Method\Callback();
  62         if ($reflection instanceof Reflection\ReflectionMethod) {
  63             $callback->setType($reflection->isStatic() ? 'static' : 'instance')
  64                      ->setClass($reflection->getDeclaringClass()->getName())
  65                      ->setMethod($reflection->getName());
  66         } elseif ($reflection instanceof Reflection\ReflectionFunction) {
  67             $callback->setType('function')
  68                      ->setFunction($reflection->getName());
  69         }
  70         return $callback;
  71     }
  72
  73     /**
  74      * Build a method signature
  75      *
  76      * @param  Reflection\AbstractFunction $reflection
  77      * @param  null|string|object $class
  78      * @return Method\Definition
  79      * @throws Exception\RuntimeException on duplicate entry
  80      */
  81     protected function _buildSignature(Reflection\AbstractFunction $reflection, $class = null)
  82     {
  83         $ns         = $reflection->getNamespace();
  84         $name       = $reflection->getName();
  85         $method     = empty($ns) ? $name : $ns . '.' . $name;
  86
  87         if (!$this->overwriteExistingMethods && $this->table->hasMethod($method)) {
  88             throw new Exception\RuntimeException('Duplicate method registered: ' . $method);
  89         }
  90
  91         $definition = new Method\Definition();
  92         $definition->setName($method)
  93                    ->setCallback($this->_buildCallback($reflection))
  94                    ->setMethodHelp($reflection->getDescription())
  95                    ->setInvokeArguments($reflection->getInvokeArguments());
  96
  97         foreach ($reflection->getPrototypes() as $proto) {
  98             $prototype = new Method\Prototype();
  99             $prototype->setReturnType($this->_fixType($proto->getReturnType()));
 100             foreach ($proto->getParameters() as $parameter) {
 101                 $param = new Method\Parameter(array(
 102                     'type'     => $this->_fixType($parameter->getType()),
 103                     'name'     => $parameter->getName(),
 104                     'optional' => $parameter->isOptional(),
 105                 ));
 106                 if ($parameter->isDefaultValueAvailable()) {
 107                     $param->setDefaultValue($parameter->getDefaultValue());
 108                 }
 109                 $prototype->addParameter($param);
 110             }
 111             $definition->addPrototype($prototype);
 112         }
 113         if (is_object($class)) {
 114             $definition->setObject($class);
 115         }
 116         $this->table->addMethod($definition);
 117         return $definition;
 118     }
 119
 120     /**
 121      * Dispatch method
 122      *
 123      * @param  Method\Definition $invokable
 124      * @param  array $params
 125      * @return mixed
 126      */
 127     protected function _dispatch(Method\Definition $invokable, array $params)
 128     {
 129         $callback = $invokable->getCallback();
 130         $type     = $callback->getType();
 131
 132         if ('function' == $type) {
 133             $function = $callback->getFunction();
 134             return call_user_func_array($function, $params);
 135         }
 136
 137         $class  = $callback->getClass();
 138         $method = $callback->getMethod();
 139
 140         if ('static' == $type) {
 141             return call_user_func_array(array($class, $method), $params);
 142         }
 143
 144         $object = $invokable->getObject();
 145         if (!is_object($object)) {
 146             $invokeArgs = $invokable->getInvokeArguments();
 147             if (!empty($invokeArgs)) {
 148                 $reflection = new ReflectionClass($class);
 149                 $object     = $reflection->newInstanceArgs($invokeArgs);
 150             } else {
 151                 $object = new $class;
 152             }
 153         }
 154         return call_user_func_array(array($object, $method), $params);
 155     }
 156
 157     /**
 158      * Map PHP type to protocol type
 159      *
 160      * @param  string $type
 161      * @return string
 162      */
 163     abstract protected function _fixType($type);
 164 }