/**
  * Add a function to the WSDL document.
  *
  * @param Zend_Server_Reflection_Function_Abstract $function function to add
  * @param Zend_Soap_Wsdl                           $wsdl     WSDL document
  * @param object                                   $port     wsdl:portType
  * @param object                                   $binding  wsdl:binding
  * @return void
  */
 protected function _addFunctionToWsdl($function, $wsdl, $port, $binding)
 {
     $uri = $this->getUri();
     // We only support one prototype: the one with the maximum number of arguments
     $prototype = null;
     $maxNumArgumentsOfPrototype = -1;
     foreach ($function->getPrototypes() as $tmpPrototype) {
         $numParams = count($tmpPrototype->getParameters());
         if ($numParams > $maxNumArgumentsOfPrototype) {
             $maxNumArgumentsOfPrototype = $numParams;
             $prototype = $tmpPrototype;
         }
     }
     if ($prototype === null) {
         require_once "Zend/Soap/AutoDiscover/Exception.php";
         throw new Zend_Soap_AutoDiscover_Exception("No prototypes could be found for the '" . $function->getName() . "' function");
     }
     // Add the input message (parameters)
     $args = array();
     if ($this->_bindingStyle['style'] == 'document') {
         // Document style: wrap all parameters in a sequence element
         $sequence = array();
         foreach ($prototype->getParameters() as $param) {
             $sequenceElement = array('name' => $param->getName(), 'type' => $wsdl->getType($param->getType()));
             if ($param->isOptional()) {
                 $sequenceElement['nillable'] = 'true';
             }
             $sequence[] = $sequenceElement;
         }
         $element = array('name' => $function->getName(), 'sequence' => $sequence);
         // Add the wrapper element part, which must be named 'parameters'
         $args['parameters'] = array('element' => $wsdl->addElement($element));
     } else {
         // RPC style: add each parameter as a typed part
         foreach ($prototype->getParameters() as $param) {
             $args[$param->getName()] = array('type' => $wsdl->getType($param->getType()));
         }
     }
     $wsdl->addMessage($function->getName() . 'In', $args);
     $isOneWayMessage = false;
     if ($prototype->getReturnType() == "void") {
         $isOneWayMessage = true;
     }
     if ($isOneWayMessage == false) {
         // Add the output message (return value)
         $args = array();
         if ($this->_bindingStyle['style'] == 'document') {
             // Document style: wrap the return value in a sequence element
             $sequence = array();
             if ($prototype->getReturnType() != "void") {
                 $sequence[] = array('name' => $function->getName() . 'Result', 'type' => $wsdl->getType($prototype->getReturnType()));
             }
             $element = array('name' => $function->getName() . 'Response', 'sequence' => $sequence);
             // Add the wrapper element part, which must be named 'parameters'
             $args['parameters'] = array('element' => $wsdl->addElement($element));
         } else {
             if ($prototype->getReturnType() != "void") {
                 // RPC style: add the return value as a typed part
                 $args['return'] = array('type' => $wsdl->getType($prototype->getReturnType()));
             }
         }
         $wsdl->addMessage($function->getName() . 'Out', $args);
     }
     // Add the portType operation
     if ($isOneWayMessage == false) {
         $portOperation = $wsdl->addPortOperation($port, $function->getName(), 'tns:' . $function->getName() . 'In', 'tns:' . $function->getName() . 'Out');
     } else {
         $portOperation = $wsdl->addPortOperation($port, $function->getName(), 'tns:' . $function->getName() . 'In', false);
     }
     $desc = $function->getDescription();
     if (strlen($desc) > 0) {
         $wsdl->addDocumentation($portOperation, $desc);
     }
     // When using the RPC style, make sure the operation style includes a 'namespace' attribute (WS-I Basic Profile 1.1 R2717)
     if ($this->_bindingStyle['style'] == 'rpc' && !isset($this->_operationBodyStyle['namespace'])) {
         $this->_operationBodyStyle['namespace'] = '' . $uri;
     }
     // Add the binding operation
     if ($isOneWayMessage == false) {
         $operation = $wsdl->addBindingOperation($binding, $function->getName(), $this->_operationBodyStyle, $this->_operationBodyStyle);
     } else {
         $operation = $wsdl->addBindingOperation($binding, $function->getName(), $this->_operationBodyStyle);
     }
     $wsdl->addSoapOperation($operation, $uri . '#' . $function->getName());
     // Add the function name to the list
     $this->_functions[] = $function->getName();
 }

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

 /**
  * Dispatch method
  * 
  * @param  Zend_Server_Reflection_Function_Abstract $invocable 
  * @param  array $params 
  * @return mixed
  */
 protected function _dispatch(Zend_Server_Reflection_Function_Abstract $invocable, array $params)
 {
     if ($invocable instanceof Zend_Server_Reflection_Function) {
         $function = $invocable->getName();
         return call_user_func_array($function, $params);
     }
     $class = $invocable->getDeclaringClass();
     $object = $class->newInstance();
     return $invocable->invokeArgs($object, $params);
 }

/**
 * Given some sort of Zend Reflection function/method object, return a profile array, ready to be serialized and stored
 *
 * @param Zend_Server_Reflection_Function_Abstract $function can be any subclass of this object type
 *
 * @return array
 */
function admin_mnet_method_profile(Zend_Server_Reflection_Function_Abstract $function) {
    $protos = $function->getPrototypes();
    $proto = array_pop($protos);
    $ret = $proto->getReturnValue();
    $profile = array(
        'parameters' =>  array(),
        'return'     =>  array(
            'type'        => $ret->getType(),
            'description' => $ret->getDescription(),
        ),
    );
    foreach ($proto->getParameters() as $p) {
        $profile['parameters'][] = array(
            'name' => $p->getName(),
            'type' => $p->getType(),
            'description' => $p->getDescription(),
        );
    }
    return $profile;
}

 /**
  * Map PHP parameter types to XML-RPC types
  * 
  * @param Zend_Server_Reflection_Function_Abstract $method 
  * @return void
  */
 protected function _fixTypes(Zend_Server_Reflection_Function_Abstract $method)
 {
     foreach ($method->getPrototypes() as $prototype) {
         foreach ($prototype->getParameters() as $param) {
             $pType = $param->getType();
             if (isset($this->_typeMap[$pType])) {
                 $param->setType($this->_typeMap[$pType]);
             } else {
                 $param->setType('void');
             }
         }
     }
 }