/**
  * Add method to definition
  *
  * @param  array|Zend_Server_Method_Definition $method
  * @param  null|string $name
  * @return Zend_Server_Definition
  * @throws Zend_Server_Exception if duplicate or invalid method provided
  */
 public function addMethod($method, $name = null)
 {
     if (is_array($method)) {
         // require_once 'Zend/Server/Method/Definition.php';
         $method = new Zend_Server_Method_Definition($method);
     } elseif (!$method instanceof Zend_Server_Method_Definition) {
         // require_once 'Zend/Server/Exception.php';
         throw new Zend_Server_Exception('Invalid method provided');
     }
     if (is_numeric($name)) {
         $name = null;
     }
     if (null !== $name) {
         $method->setName($name);
     } else {
         $name = $method->getName();
     }
     if (null === $name) {
         // require_once 'Zend/Server/Exception.php';
         throw new Zend_Server_Exception('No method name provided');
     }
     if (!$this->_overwriteExistingMethods && array_key_exists($name, $this->_methods)) {
         // require_once 'Zend/Server/Exception.php';
         throw new Zend_Server_Exception(sprintf('Method by name of "%s" already exists', $name));
     }
     $this->_methods[$name] = $method;
     return $this;
 }

 /**
  * Here we need to be able to add new functions to the call list
  *
  * @param array $functions
  */
 public function addFunctionsAsMethods($functions)
 {
     foreach ($functions as $key => $function) {
         // do a reflection on the function interface
         $reflection = new Zend_Server_Reflection_Function(new ReflectionFunction($function));
         // build up the method definition
         $definition = new Zend_Server_Method_Definition();
         $definition->setName($key)->setCallback($this->_buildCallback($reflection))->setMethodHelp($reflection->getDescription())->setInvokeArguments($reflection->getInvokeArguments());
         // here is where the parameters really get built up
         foreach ($reflection->getPrototypes() as $proto) {
             $prototype = new Zend_Server_Method_Prototype();
             $prototype->setReturnType($this->_fixType($proto->getReturnType()));
             foreach ($proto->getParameters() as $parameter) {
                 $param = new Zend_Server_Method_Parameter(array('type' => $this->_fixType($parameter->getType()), 'name' => $parameter->getName(), 'optional' => $parameter->isOptional()));
                 if ($parameter->isDefaultValueAvailable()) {
                     $param->setDefaultValue($parameter->getDefaultValue());
                 }
                 $prototype->addParameter($param);
             }
             $definition->addPrototype($prototype);
         }
         // finally add the new function definition to the available call stack
         $this->_table->addMethod($definition, $key);
     }
 }

 /**
  * Dispatch method
  *
  * @param  Zend_Server_Method_Definition $invocable
  * @param  array $params
  * @return mixed
  */
 protected function _dispatch(Zend_Server_Method_Definition $invocable, array $params)
 {
     $callback = $invocable->getCallback();
     $type = $callback->getType();
     if ('function' == $type) {
         $function = $callback->getFunction();
         return call_user_func_array($function, $params);
     }
     $class = $callback->getClass();
     $method = $callback->getMethod();
     if ('static' == $type) {
         return call_user_func_array(array($class, $method), $params);
     }
     $object = $invocable->getObject();
     if (!is_object($object)) {
         $invokeArgs = $invocable->getInvokeArguments();
         if (!empty($invokeArgs)) {
             $reflection = new ReflectionClass($class);
             $object = $reflection->newInstanceArgs($invokeArgs);
         } else {
             $object = new $class();
         }
     }
     return call_user_func_array(array($object, $method), $params);
 }

 /**
  * Get method return type
  *
  * @param  Zend_Server_Reflection_Function_Abstract $method
  * @return string|array
  */
 protected function _getReturnType(Zend_Server_Method_Definition $method)
 {
     $return = array();
     foreach ($method->getPrototypes() as $prototype) {
         $return[] = $prototype->getReturnType();
     }
     if (1 == count($return)) {
         return $return[0];
     }
     return $return;
 }

 public function testPassingOptionsToConstructorShouldSetObjectState()
 {
     $options = array('name' => 'foo.bar', 'callback' => array('function' => 'foo', 'type' => 'function'), 'prototypes' => array(array('returnType' => 'struct', 'parameters' => array('string', 'array'))), 'methodHelp' => 'foo bar', 'object' => new stdClass(), 'invokeArguments' => array('foo', array('bar', 'baz')));
     $definition = new Zend_Server_Method_Definition($options);
     $test = $definition->toArray();
     $this->assertEquals($options['name'], $test['name']);
     $this->assertEquals($options['callback'], $test['callback']);
     $this->assertEquals($options['prototypes'], $test['prototypes']);
     $this->assertEquals($options['methodHelp'], $test['methodHelp']);
     $this->assertEquals($options['object'], $test['object']);
     $this->assertEquals($options['invokeArguments'], $test['invokeArguments']);
 }