PHP Zend_Server_Reflection::reflectClass方法代码示例

 /**
  * Implement Zend_Server_Interface::setClass()
  *
  * @param string $classname Class name
  * @param string $namespace Class namespace (unused)
  * @param array $argv An array of Constructor Arguments
  */
 public function setClass($classname, $namespace = '', $argv = array())
 {
     $this->_args = $argv;
     foreach ($this->_reflection->reflectClass($classname, $argv)->getMethods() as $method) {
         $this->_functions[$method->getName()] = $method;
     }
 }

    /**
     * Set the Class the SOAP server will use
     *
     * @param string $class Class Name
     * @param string $namespace Class Namspace - Not Used
     * @param array $argv Arguments to instantiate the class - Not Used
     */
    public function setClass($class, $namespace = '', $argv = null)
    {
        $uri = Zend_Uri::factory('http://' . $_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']);

        $wsdl = new Zend_Soap_Wsdl($class, $uri, $this->_extractComplexTypes);
        
        $port = $wsdl->addPortType($class . 'Port');
        $binding = $wsdl->addBinding($class . 'Binding', 'tns:' .$class. 'Port');
        
        $wsdl->addSoapBinding($binding, 'rpc');
        $wsdl->addService($class . 'Service', $class . 'Port', 'tns:' . $class . 'Binding', $uri);
        foreach ($this->_reflection->reflectClass($class)->getMethods() as $method) {
            /* <wsdl:portType>'s */
            $portOperation = $wsdl->addPortOperation($port, $method->getName(), 'tns:' .$method->getName(). 'Request', 'tns:' .$method->getName(). 'Response');
            $desc = $method->getDescription();
            if (strlen($desc) > 0) {
                /** @todo check, what should be done for portoperation documentation */
                //$wsdl->addDocumentation($portOperation, $desc);
            }
            /* </wsdl:portType>'s */
            
            $this->_functions[] = $method->getName();

            foreach ($method->getPrototypes() as $prototype) {
                $args = array();
                foreach ($prototype->getParameters() as $param) {
                    $args[$param->getName()] = $wsdl->getType($param->getType());
                }
                $message = $wsdl->addMessage($method->getName() . 'Request', $args);
                if (strlen($desc) > 0) {
                    //$wsdl->addDocumentation($message, $desc);
                }
                if ($prototype->getReturnType() != "void") {
                    $message = $wsdl->addMessage($method->getName() . 'Response', array($method->getName() . 'Return' => $wsdl->getType($prototype->getReturnType())));
                }

                /* <wsdl:binding>'s */
                $operation = $wsdl->addBindingOperation($binding, $method->getName(),  array('use' => 'encoded', 'encodingStyle' => "http://schemas.xmlsoap.org/soap/encoding/"), array('use' => 'encoded', 'encodingStyle' => "http://schemas.xmlsoap.org/soap/encoding/"));
                $wsdl->addSoapOperation($binding, $uri->getUri() . '#' .$method->getName());
                /* </wsdl:binding>'s */
            }
        }
        $this->_wsdl = $wsdl;
    }

 /**
  * Set the Class the SOAP server will use
  *
  * @param string $class Class Name
  * @param string $namespace Class Namspace - Not Used
  * @param array $argv Arguments to instantiate the class - Not Used
  */
 public function setClass($class, $namespace = '', $argv = null)
 {
     $uri = $this->getUri();
     $wsdl = new Zend_Soap_Wsdl($class, $uri, $this->_strategy);
     $port = $wsdl->addPortType($class . 'Port');
     $binding = $wsdl->addBinding($class . 'Binding', 'tns:' . $class . 'Port');
     $wsdl->addSoapBinding($binding, $this->_bindingStyle['style'], $this->_bindingStyle['transport']);
     $wsdl->addService($class . 'Service', $class . 'Port', 'tns:' . $class . 'Binding', $uri);
     foreach ($this->_reflection->reflectClass($class)->getMethods() as $method) {
         /* <wsdl:portType>'s */
         $portOperation = $wsdl->addPortOperation($port, $method->getName(), 'tns:' . $method->getName() . 'Request', 'tns:' . $method->getName() . 'Response');
         $desc = $method->getDescription();
         if (strlen($desc) > 0) {
             /** @todo check, what should be done for portoperation documentation */
             //$wsdl->addDocumentation($portOperation, $desc);
         }
         /* </wsdl:portType>'s */
         $this->_functions[] = $method->getName();
         $selectedPrototype = null;
         $maxNumArgumentsOfPrototype = -1;
         foreach ($method->getPrototypes() as $prototype) {
             $numParams = count($prototype->getParameters());
             if ($numParams > $maxNumArgumentsOfPrototype) {
                 $maxNumArgumentsOfPrototype = $numParams;
                 $selectedPrototype = $prototype;
             }
         }
         if ($selectedPrototype != null) {
             $prototype = $selectedPrototype;
             $args = array();
             foreach ($prototype->getParameters() as $param) {
                 $args[$param->getName()] = $wsdl->getType($param->getType());
             }
             $message = $wsdl->addMessage($method->getName() . 'Request', $args);
             if (strlen($desc) > 0) {
                 //$wsdl->addDocumentation($message, $desc);
             }
             if ($prototype->getReturnType() != "void") {
                 if ($this->_responseMessageReturnNameCompability === true) {
                     $returnName = 'return';
                 } else {
                     $returnName = $method->getName() . 'Return';
                 }
                 $message = $wsdl->addMessage($method->getName() . 'Response', array($returnName => $wsdl->getType($prototype->getReturnType())));
             }
             /* <wsdl:binding>'s */
             $operation = $wsdl->addBindingOperation($binding, $method->getName(), $this->_operationBodyStyle, $this->_operationBodyStyle);
             $wsdl->addSoapOperation($operation, $uri->getUri() . '#' . $method->getName());
             /* </wsdl:binding>'s */
         }
     }
     $this->_wsdl = $wsdl;
 }

 /**
  * Set the Class the SOAP server will use
  *
  * @param string $class Class Name
  * @param string $namespace Class Namspace - Not Used
  * @param array $argv Arguments to instantiate the class - Not Used
  */
 public function setClass($class, $namespace = '', $argv = null)
 {
     $uri = $this->getUri();
     $wsdl = new Zend_Soap_Wsdl($class, $uri, $this->_strategy);
     // The wsdl:types element must precede all other elements (WS-I Basic Profile 1.1 R2023)
     $wsdl->addSchemaTypeSection();
     $port = $wsdl->addPortType($class . 'Port');
     $binding = $wsdl->addBinding($class . 'Binding', 'tns:' . $class . 'Port');
     $wsdl->addSoapBinding($binding, $this->_bindingStyle['style'], $this->_bindingStyle['transport']);
     $wsdl->addService($class . 'Service', $class . 'Port', 'tns:' . $class . 'Binding', $uri);
     foreach ($this->_reflection->reflectClass($class)->getMethods() as $method) {
         $this->_addFunctionToWsdl($method, $wsdl, $port, $binding);
     }
     $this->_wsdl = $wsdl;
 }

 public function setClass($class, $namespace = '', $argv = null)
 {
     if (is_string($class) && !class_exists($class)) {
         throw new Cosmos_Api_Server_Exception('Invalid method class', 610);
     }
     $argv = null;
     if (2 < func_num_args()) {
         $argv = func_get_args();
         $argv = array_slice($argv, 2);
     }
     $dispatchable = Zend_Server_Reflection::reflectClass($class, $argv, $namespace);
     foreach ($dispatchable->getMethods() as $reflection) {
         $this->_buildSignature($reflection, $class);
     }
 }

 public function setClass($class, $namespace = '', $argv = null)
 {
     if (is_string($class) && class_exists($class) || is_object($class)) {
         // Get args.
         $argv = null;
         if (2 < func_num_args()) {
             $argv = array_slice(func_get_args(), 2);
         }
         // Get namespace.
         if ($namespace == '') {
             $namespace = is_object($class) ? get_class($class) : $class;
         }
         // Validate namespace.
         if (!new $namespace() instanceof phpMyWave_AbstractRobot) {
             throw new Exception('Invalid method or class; must be instace of phpMyWave_AbstractRobot');
         }
         // Reflect class.
         $this->_robots[] = Zend_Server_Reflection::reflectClass($class, $argv, $namespace);
     } else {
         throw new Exception('Invalid method or class; must be a classname or object');
     }
     return $this;
 }

 /**
  * Attach a class or object to the server
  *
  * Class may be either a class name or an instantiated object. Reflection
  * is done on the class or object to determine the available public
  * methods, and each is attached to the server as and available method. If
  * a $namespace has been provided, that namespace is used to prefix
  * AMF service call.
  *
  * @param  string|object $class
  * @param  string $namespace Optional
  * @param  mixed $arg Optional arguments to pass to a method
  * @return Zend_Amf_Server
  * @throws Zend_Amf_Server_Exception on invalid input
  */
 public function setClass($class, $namespace = '', $argv = null)
 {
     if (is_string($class) && !class_exists($class)) {
         require_once 'Zend/Amf/Server/Exception.php';
         throw new Zend_Amf_Server_Exception('Invalid method or class');
     } elseif (!is_string($class) && !is_object($class)) {
         require_once 'Zend/Amf/Server/Exception.php';
         throw new Zend_Amf_Server_Exception('Invalid method or class; must be a classname or object');
     }
     $argv = null;
     if (2 < func_num_args()) {
         $argv = array_slice(func_get_args(), 2);
     }
     // Use the class name as the name space by default.
     if ($namespace == '') {
         $namespace = is_object($class) ? get_class($class) : $class;
     }
     $this->_classAllowed[is_object($class) ? get_class($class) : $class] = true;
     $this->_methods[] = Zend_Server_Reflection::reflectClass($class, $argv, $namespace);
     $this->_buildDispatchTable();
     return $this;
 }

 /**
  * reflectClass() test; test namespaces
  */
 public function testReflectClass2()
 {
     $reflection = Zend_Server_Reflection::reflectClass('Zend_Server_Reflection_testClass', false, 'zsr');
     $this->assertEquals('zsr', $reflection->getNamespace());
 }

 /**
  * Create XML definition on an AMF service class
  * 
  * @param  string $serviceClass Service class name
  * @param  array $options invocation options
  * @return string XML with service class introspection
  */
 public function introspect($serviceClass, $options = array())
 {
     $this->_options = $options;
     if (strpbrk($serviceClass, '\\/<>')) {
         return $this->_returnError('Invalid service name');
     }
     // Transform com.foo.Bar into com_foo_Bar
     $serviceClass = str_replace('.', '_', $serviceClass);
     // Introspect!
     if (!class_exists($serviceClass)) {
         // require_once 'Zend/Loader.php';
         Zend_Loader::loadClass($serviceClass, $this->_getServicePath());
     }
     $serv = $this->_xml->createElement('service-description');
     $serv->setAttribute('xmlns', 'http://ns.adobe.com/flex/service-description/2008');
     $this->_types = $this->_xml->createElement('types');
     $this->_ops = $this->_xml->createElement('operations');
     $r = Zend_Server_Reflection::reflectClass($serviceClass);
     $this->_addService($r, $this->_ops);
     $serv->appendChild($this->_types);
     $serv->appendChild($this->_ops);
     $this->_xml->appendChild($serv);
     return $this->_xml->saveXML();
 }

/**
 * upgrades the mnet rpc definitions for the given component.
 * this method doesn't return status, an exception will be thrown in the case of an error
 *
 * @param string $component the plugin to upgrade, eg auth_mnet
 */
function upgrade_plugin_mnet_functions($component) {
    global $DB, $CFG;

    list($type, $plugin) = core_component::normalize_component($component);
    $path = core_component::get_plugin_directory($type, $plugin);

    $publishes = array();
    $subscribes = array();
    if (file_exists($path . '/db/mnet.php')) {
        require_once($path . '/db/mnet.php'); // $publishes comes from this file
    }
    if (empty($publishes)) {
        $publishes = array(); // still need this to be able to disable stuff later
    }
    if (empty($subscribes)) {
        $subscribes = array(); // still need this to be able to disable stuff later
    }

    static $servicecache = array();

    // rekey an array based on the rpc method for easy lookups later
    $publishmethodservices = array();
    $subscribemethodservices = array();
    foreach($publishes as $servicename => $service) {
        if (is_array($service['methods'])) {
            foreach($service['methods'] as $methodname) {
                $service['servicename'] = $servicename;
                $publishmethodservices[$methodname][] = $service;
            }
        }
    }

    // Disable functions that don't exist (any more) in the source
    // Should these be deleted? What about their permissions records?
    foreach ($DB->get_records('mnet_rpc', array('pluginname'=>$plugin, 'plugintype'=>$type), 'functionname ASC ') as $rpc) {
        if (!array_key_exists($rpc->functionname, $publishmethodservices) && $rpc->enabled) {
            $DB->set_field('mnet_rpc', 'enabled', 0, array('id' => $rpc->id));
        } else if (array_key_exists($rpc->functionname, $publishmethodservices) && !$rpc->enabled) {
            $DB->set_field('mnet_rpc', 'enabled', 1, array('id' => $rpc->id));
        }
    }

    // reflect all the services we're publishing and save them
    require_once($CFG->dirroot . '/lib/zend/Zend/Server/Reflection.php');
    static $cachedclasses = array(); // to store reflection information in
    foreach ($publishes as $service => $data) {
        $f = $data['filename'];
        $c = $data['classname'];
        foreach ($data['methods'] as $method) {
            $dataobject = new stdClass();
            $dataobject->plugintype  = $type;
            $dataobject->pluginname  = $plugin;
            $dataobject->enabled     = 1;
            $dataobject->classname   = $c;
            $dataobject->filename    = $f;

            if (is_string($method)) {
                $dataobject->functionname = $method;

            } else if (is_array($method)) { // wants to override file or class
                $dataobject->functionname = $method['method'];
                $dataobject->classname     = $method['classname'];
                $dataobject->filename      = $method['filename'];
            }
            $dataobject->xmlrpcpath = $type.'/'.$plugin.'/'.$dataobject->filename.'/'.$method;
            $dataobject->static = false;

            require_once($path . '/' . $dataobject->filename);
            $functionreflect = null; // slightly different ways to get this depending on whether it's a class method or a function
            if (!empty($dataobject->classname)) {
                if (!class_exists($dataobject->classname)) {
                    throw new moodle_exception('installnosuchmethod', 'mnet', '', (object)array('method' => $dataobject->functionname, 'class' => $dataobject->classname));
                }
                $key = $dataobject->filename . '|' . $dataobject->classname;
                if (!array_key_exists($key, $cachedclasses)) { // look to see if we've already got a reflection object
                    try {
                        $cachedclasses[$key] = Zend_Server_Reflection::reflectClass($dataobject->classname);
                    } catch (Zend_Server_Reflection_Exception $e) { // catch these and rethrow them to something more helpful
                        throw new moodle_exception('installreflectionclasserror', 'mnet', '', (object)array('method' => $dataobject->functionname, 'class' => $dataobject->classname, 'error' => $e->getMessage()));
                    }
                }
                $r =& $cachedclasses[$key];
                if (!$r->hasMethod($dataobject->functionname)) {
                    throw new moodle_exception('installnosuchmethod', 'mnet', '', (object)array('method' => $dataobject->functionname, 'class' => $dataobject->classname));
                }
                // stupid workaround for zend not having a getMethod($name) function
                $ms = $r->getMethods();
                foreach ($ms as $m) {
                    if ($m->getName() == $dataobject->functionname) {
                        $functionreflect = $m;
                        break;
                    }
                }
                $dataobject->static = (int)$functionreflect->isStatic();
//.........这里部分代码省略.........

 /**
  * Register a class with the server
  *
  * @param  string $class
  * @param  string $namespace Ignored
  * @param  mixed $argv Ignored
  * @return Zend_Json_Server
  */
 public function setClass($class, $namespace = '', $argv = null)
 {
     $argv = null;
     if (3 < func_num_args()) {
         $argv = func_get_args();
         $argv = array_slice($argv, 3);
     }
     // require_once 'Zend/Server/Reflection.php';
     $reflection = Zend_Server_Reflection::reflectClass($class, $argv, $namespace);
     foreach ($reflection->getMethods() as $method) {
         $definition = $this->_buildSignature($method, $class);
         $this->_addMethodServiceMap($definition);
     }
     return $this;
 }

 /**
  * Register a class with the server
  * 
  * @param  string $class 
  * @param  string $namespace Ignored
  * @param  mixed $argv Ignored
  * @return Zend_Json_Server
  */
 public function setClass($class, $namespace = '', $argv = null)
 {
     require_once 'Zend/Server/Reflection.php';
     $reflection = Zend_Server_Reflection::reflectClass($class);
     foreach ($reflection->getMethods() as $method) {
         $this->_methods[$method->getName()] = $method;
         $this->_addMethodServiceMap($method);
     }
     return $this;
 }

 /**
  * Attach class methods as XMLRPC method handlers
  *
  * $class may be either a class name or an object. Reflection is done on the 
  * class or object to determine the available public methods, and each is 
  * attached to the server as an available method; if a $namespace has been 
  * provided, that namespace is used to prefix the XMLRPC method names.
  *
  * Any additional arguments beyond $namespace will be passed to a method at 
  * invocation.
  *
  * @param string|object $class 
  * @param string $namespace Optional
  * @param mixed $argv Optional arguments to pass to methods
  * @return void
  * @throws Zend_XmlRpc_Server_Exception on invalid input
  */
 public function setClass($class, $namespace = '', $argv = null)
 {
     if (is_string($class) && !class_exists($class)) {
         if (!class_exists($class)) {
             throw new Zend_XmlRpc_Server_Exception('Invalid method class', 610);
         }
     }
     $argv = null;
     if (3 < func_num_args()) {
         $argv = func_get_args();
         $argv = array_slice($argv, 3);
     }
     $this->_methods[] = Zend_Server_Reflection::reflectClass($class, $argv, $namespace);
     $this->_buildDispatchTable();
 }

 /**
 * Generate web service description array from the phpdoc for a given class
 * @param string $file the class file
 * @param string $class the class name
 * @return array description
 *
 *
   -------
   Example
   -------
 * Docnlock: @ subparam string $params:searches->search - the string to search
 * $params is considered as the first element, searches the second, and search the terminal
 * Except the terminal element, all other will be generated as an array
 * => left element are generated as an associative array.
 * If the following character is ':' so the right element is a key named 'multiple:element_name'
 * If the following character is '->' so the right element will be named 'element_name'
 * Rule: If a key is named 'multiple:xxx' other key must be 'multiple:yyy'
 
   Docblock of  mock_function
   ---------------------------
   @ param array|struct $params
   @ subparam string $params:searches->search - the string to search
   @ subparam string $params:searches->search2 optional - optional string to search
   @ subparam string $params:searches->search3 - the string to search
   @ subparam string $params:airport->planes:plane->company->employees:employee->name - name of a employee of a company of a plane of an airport
   @ return array users
   @ subreturn integer $users:user->id
   @ subreturn integer $users:user->auth
 
   Generated description array
   ---------------------------
   description["mock_function"]=>
          array(3) {
            ["params"]=>
            array(2) {
              ["multiple:searches"]=>
              array(2) {
                ["search"]=>
                string(6) "string"
                ["search3"]=>
                string(6) "string"
              }
              ["multiple:airport"]=>
              array(1) {
                ["planes"]=>
                array(1) {
                  ["multiple:plane"]=>
                  array(1) {
                    ["company"]=>
                    array(1) {
                      ["employees"]=>
                      array(1) {
                        ["multiple:employee"]=>
                        array(1) {
                          ["name"]=>
                          string(6) "string"
                        }
                      }
                    }
                  }
                }
              }
            }
            ["optional"]=>
            array(1) {
              ["multiple:searches"]=>
              array(1) {
                ["search2"]=>
                string(6) "string"
              }
            }
            ["return"]=>
            array(1) {
              ["multiple:user"]=>
              array(13) {
                ["id"]=>
                string(7) "integer"
                ["auth"]=>
                string(7) "integer"
              }
            }
 */
 public static function generate_webservice_description($file, $class)
 {
     require_once $file;
     require_once "Zend/Loader.php";
     Zend_Loader::registerAutoload();
     $reflection = Zend_Server_Reflection::reflectClass($class);
     $description = array();
     foreach ($reflection->getMethods() as $method) {
         $docBlock = $method->getDocComment();
         //retrieve the return and add it into the description if not array|object
         preg_match_all('/@return\\s+(\\w+)\\s+((?:\\$)?\\w+)/', $docBlock, $returnmatches);
         //retrieve the subparam and subreturn
         preg_match_all('/\\s*\\*\\s*@(subparam|subreturn)\\s+(\\w+)\\s+(\\$\\w+(?::\\w+|->\\w+)+)((?:\\s+(?:optional|required|multiple))*)/', $docBlock, $matches);
         /// process every @subparam and @subreturn line of the docblock
         for ($i = 0; $i < sizeof($matches[1]); $i++) {
             /// identify the description type of the docblock line: is it params, optional or return (first key of a description method array)
             switch ($matches[1][$i]) {
                 case "subparam":
//.........这里部分代码省略.........

 /**
  * Attach class methods as XMLRPC method handlers
  *
  * $class may be either a class name or an object. Reflection is done on the
  * class or object to determine the available public methods, and each is
  * attached to the server as an available method; if a $namespace has been
  * provided, that namespace is used to prefix the XMLRPC method names.
  *
  * Any additional arguments beyond $namespace will be passed to a method at
  * invocation.
  *
  * @param string|object $class
  * @param string $namespace Optional
  * @param mixed $argv Optional arguments to pass to methods
  * @return void
  * @throws Zend_XmlRpc_Server_Exception on invalid input
  */
 public function setClass($class, $namespace = '', $argv = null)
 {
     if (is_string($class) && !class_exists($class)) {
         //require_once 'Zend/XmlRpc/Server/Exception.php';
         throw new Zend_XmlRpc_Server_Exception('Invalid method class', 610);
     }
     $args = null;
     if (2 < func_num_args()) {
         $args = func_get_args();
         $args = array_slice($args, 2);
     }
     $dispatchable = Zend_Server_Reflection::reflectClass($class, $args, $namespace);
     foreach ($dispatchable->getMethods() as $reflection) {
         $this->_buildSignature($reflection, $class);
     }
 }