PHP Zend_Server_Definition::addMethod方法代码示例

 /**
  * 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;
 }

    /**
     * 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;
    }

    /**
     * Load methods as returned from {@link getFunctions}
     *
     * Typically, you will not use this method; it will be called using the
     * results pulled from {@link Zend_XmlRpc_Server_Cache::get()}.
     *
     * @param  array|Zend_Server_Definition $definition
     * @return void
     * @throws Zend_XmlRpc_Server_Exception on invalid input
     */
    public function loadFunctions($definition)
    {
        if (!is_array($definition) && (!$definition instanceof Zend_Server_Definition)) {
            if (is_object($definition)) {
                $type = get_class($definition);
            } else {
                $type = gettype($definition);
            }
            require_once 'Zend/XmlRpc/Server/Exception.php';
            throw new Zend_XmlRpc_Server_Exception('Unable to load server definition; must be an array or Zend_Server_Definition, received ' . $type, 612);
        }

        $this->_table->clearMethods();
        $this->_registerSystemMethods();

        if ($definition instanceof Zend_Server_Definition) {
            $definition = $definition->getMethods();
        }

        foreach ($definition as $key => $method) {
            if ('system.' == substr($key, 0, 7)) {
                continue;
            }
            $this->_table->addMethod($method, $key);
        }
    }

 public function testDefinitionShouldSerializeToArray()
 {
     $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'));
     $definition = new Zend_Server_Definition();
     $definition->addMethod($method);
     $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']);
 }