/**
     * Cache a file containing the dispatch list.
     *
     * Serializes the server definition stores the information
     * in $filename.
     *
     * Returns false on any error (typically, inability to write to file), true
     * on success.
     *
     * @param  string $filename
     * @param  Zend_Server_Interface $server
     * @return bool
     */
    public static function save($filename, Zend_Server_Interface $server)
    {
        if (!is_string($filename)
            || (!file_exists($filename) && !is_writable(dirname($filename))))
        {
            return false;
        }

        $methods = $server->getFunctions();

        if ($methods instanceof Zend_Server_Definition) {
            $definition = new Zend_Server_Definition();
            foreach ($methods as $method) {
                if (in_array($method->getName(), self::$_skipMethods)) {
                    continue;
                }
                $definition->addMethod($method);
            }
            $methods = $definition;
        }

        if (0 === @file_put_contents($filename, serialize($methods))) {
            return false;
        }

        return true;
    }

 public function testPassingOptionsToConstructorShouldSetObjectState()
 {
     $method = array('name' => 'foo.bar', 'callback' => array('type' => 'function', 'function' => 'bar'), 'prototypes' => array(array('returnType' => 'string', 'parameters' => array('string'))), 'methodHelp' => 'Foo Bar!', 'invokeArguments' => array('foo'));
     $options = array($method);
     $definition = new Zend_Server_Definition($options);
     $test = $definition->toArray();
     $this->assertEquals(1, count($test));
     $test = array_shift($test);
     $this->assertEquals($method['name'], $test['name']);
     $this->assertEquals($method['methodHelp'], $test['methodHelp']);
     $this->assertEquals($method['invokeArguments'], $test['invokeArguments']);
     $this->assertEquals($method['prototypes'][0]['returnType'], $test['prototypes'][0]['returnType']);
 }

 /**
  * Build a method signature
  *
  * @param  Zend_Server_Reflection_Function_Abstract $reflection
  * @param  null|string|object $class
  * @return Zend_Server_Method_Definition
  * @throws Zend_Server_Exception on duplicate entry
  */
 protected function _buildSignature(Zend_Server_Reflection_Function_Abstract $reflection, $class = null)
 {
     $ns = $reflection->getNamespace();
     $name = $reflection->getName();
     $method = empty($ns) ? $name : $ns . '.' . $name;
     if (!$this->_overwriteExistingMethods && $this->_table->hasMethod($method)) {
         #require_once 'Zend/Server/Exception.php';
         throw new Zend_Server_Exception('Duplicate method registered: ' . $method);
     }
     $definition = new Zend_Server_Method_Definition();
     $definition->setName($method)->setCallback($this->_buildCallback($reflection))->setMethodHelp($reflection->getDescription())->setInvokeArguments($reflection->getInvokeArguments());
     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);
     }
     if (is_object($class)) {
         $definition->setObject($class);
     }
     $this->_table->addMethod($definition);
     return $definition;
 }

    /**
     * Handle an xmlrpc call (actual work)
     *
     * @param Zend_XmlRpc_Request $request
     * @return Zend_XmlRpc_Response
     * @throws Zend_XmlRpcServer_Exception|Exception
     * Zend_XmlRpcServer_Exceptions are thrown for internal errors; otherwise,
     * any other exception may be thrown by the callback
     */
    protected function _handle(Zend_XmlRpc_Request $request)
    {
        $method = $request->getMethod();

        // Check for valid method
        if (!$this->_table->hasMethod($method)) {
            require_once 'Zend/XmlRpc/Server/Exception.php';
            throw new Zend_XmlRpc_Server_Exception('Method "' . $method . '" does not exist', 620);
        }

        $info     = $this->_table->getMethod($method);
        $params   = $request->getParams();
        $argv     = $info->getInvokeArguments();
        if (0 < count($argv) and $this->sendArgumentsToAllMethods()) {
            $params = array_merge($params, $argv);
        }

        // Check calling parameters against signatures
        $matched    = false;
        $sigCalled  = $request->getTypes();

        $sigLength  = count($sigCalled);
        $paramsLen  = count($params);
        if ($sigLength < $paramsLen) {
            for ($i = $sigLength; $i < $paramsLen; ++$i) {
                $xmlRpcValue = Zend_XmlRpc_Value::getXmlRpcValue($params[$i]);
                $sigCalled[] = $xmlRpcValue->getType();
            }
        }

        $signatures = $info->getPrototypes();
        foreach ($signatures as $signature) {
            $sigParams = $signature->getParameters();
            if ($sigCalled === $sigParams) {
                $matched = true;
                break;
            }
        }
        if (!$matched) {
            require_once 'Zend/XmlRpc/Server/Exception.php';
            throw new Zend_XmlRpc_Server_Exception('Calling parameters do not match signature', 623);
        }

        $return        = $this->_dispatch($info, $params);
        $responseClass = $this->getResponseClass();
        return new $responseClass($return);
    }