X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=src%2FWrapper.php;h=10aae52eaf6d4842bd6fb433938f597e30e33dd4;hb=fc4f17849d8bb022c3b8ff38a2bed1d1c188ac7f;hp=ff1bbba993c849f0fd7c7c73bcd6d47481116782;hpb=9e9427b378d6be8e12413145f9aeaf6cfe324e62;p=plcapi.git

diff --git a/src/Wrapper.php b/src/Wrapper.php
index ff1bbba..10aae52 100644
--- a/src/Wrapper.php
+++ b/src/Wrapper.php
@@ -1,64 +1,68 @@
 <?php
 /**
  * @author Gaetano Giunta
- * @copyright (C) 2006-2014 G. Giunta
- * @license code licensed under the BSD License: http://phpxmlrpc.sourceforge.net/license.txt
+ * @copyright (C) 2006-2015 G. Giunta
+ * @license code licensed under the BSD License: see file license.txt
  */
 
 namespace PhpXmlRpc;
 
 /**
  * PHP-XMLRPC "wrapper" class.
- * Generate stubs to transparently access xmlrpc methods as php functions and viceversa.
+ * Generate stubs to transparently access xmlrpc methods as php functions and vice-versa.
  * Note: this class implements the PROXY pattern, but it is not named so to avoid confusion with http proxies.
  *
- * @todo separate introspection from code generation for func-2-method wrapping
  * @todo use some better templating system for code generation?
  * @todo implement method wrapping with preservation of php objs in calls
  * @todo when wrapping methods without obj rebuilding, use return_type = 'phpvals' (faster)
  */
 class Wrapper
 {
+    /// used to hold a reference to object instances whose methods get wrapped by wrapPhpFunction(), in 'create source' mode
+    public static $objHolder = array();
 
     /**
-    * Given a string defining a php type or phpxmlrpc type (loosely defined: strings
-    * accepted come from javadoc blocks), return corresponding phpxmlrpc type.
-    * NB: for php 'resource' types returns empty string, since resources cannot be serialized;
-    * for php class names returns 'struct', since php objects can be serialized as xmlrpc structs
-    * for php arrays always return array, even though arrays sometimes serialize as json structs
-    * @param string $phptype
-    * @return string
-    */
-    public function php_2_xmlrpc_type($phptype)
+     * Given a string defining a php type or phpxmlrpc type (loosely defined: strings
+     * accepted come from javadoc blocks), return corresponding phpxmlrpc type.
+     * Notes:
+     * - for php 'resource' types returns empty string, since resources cannot be serialized;
+     * - for php class names returns 'struct', since php objects can be serialized as xmlrpc structs
+     * - for php arrays always return array, even though arrays sometimes serialize as json structs
+     * - for 'void' and 'null' returns 'undefined'
+     *
+     * @param string $phpType
+     *
+     * @return string
+     */
+    public function php2XmlrpcType($phpType)
     {
-        switch(strtolower($phptype))
-        {
+        switch (strtolower($phpType)) {
             case 'string':
                 return Value::$xmlrpcString;
             case 'integer':
             case Value::$xmlrpcInt: // 'int'
             case Value::$xmlrpcI4:
                 return Value::$xmlrpcInt;
-            case 'double':
+            case Value::$xmlrpcDouble: // 'double'
                 return Value::$xmlrpcDouble;
-            case 'boolean':
+            case 'bool':
+            case Value::$xmlrpcBoolean: // 'boolean'
+            case 'false':
+            case 'true':
                 return Value::$xmlrpcBoolean;
-            case 'array':
+            case Value::$xmlrpcArray: // 'array':
                 return Value::$xmlrpcArray;
             case 'object':
+            case Value::$xmlrpcStruct: // 'struct'
                 return Value::$xmlrpcStruct;
             case Value::$xmlrpcBase64:
-            case Value::$xmlrpcStruct:
-                return strtolower($phptype);
+                return Value::$xmlrpcBase64;
             case 'resource':
                 return '';
             default:
-                if(class_exists($phptype))
-                {
+                if (class_exists($phpType)) {
                     return Value::$xmlrpcStruct;
-                }
-                else
-                {
+                } else {
                     // unknown: might be any 'extended' xmlrpc type
                     return Value::$xmlrpcValue;
                 }
@@ -66,14 +70,15 @@ class Wrapper
     }
 
     /**
-    * Given a string defining a phpxmlrpc type return corresponding php type.
-    * @param string $xmlrpctype
-    * @return string
-    */
-    public function xmlrpc_2_php_type($xmlrpctype)
+     * Given a string defining a phpxmlrpc type return the corresponding php type.
+     *
+     * @param string $xmlrpcType
+     *
+     * @return string
+     */
+    public function xmlrpc2PhpType($xmlrpcType)
     {
-        switch(strtolower($xmlrpctype))
-        {
+        switch (strtolower($xmlrpcType)) {
             case 'base64':
             case 'datetime.iso8601':
             case 'string':
@@ -92,837 +97,1010 @@ class Wrapper
             case 'null':
             default:
                 // unknown: might be any xmlrpc type
-                return strtolower($xmlrpctype);
+                return strtolower($xmlrpcType);
         }
     }
 
     /**
-    * Given a user-defined PHP function, create a PHP 'wrapper' function that can
-    * be exposed as xmlrpc method from an xmlrpc_server object and called from remote
-    * clients (as well as its corresponding signature info).
-    *
-    * Since php is a typeless language, to infer types of input and output parameters,
-    * it relies on parsing the javadoc-style comment block associated with the given
-    * function. Usage of xmlrpc native types (such as datetime.dateTime.iso8601 and base64)
-    * in the @param tag is also allowed, if you need the php function to receive/send
-    * data in that particular format (note that base64 encoding/decoding is transparently
-    * carried out by the lib, while datetime vals are passed around as strings)
-    *
-    * Known limitations:
-    * - only works for user-defined functions, not for PHP internal functions
-    *   (reflection does not support retrieving number/type of params for those)
-    * - functions returning php objects will generate special xmlrpc responses:
-    *   when the xmlrpc decoding of those responses is carried out by this same lib, using
-    *   the appropriate param in php_xmlrpc_decode, the php objects will be rebuilt.
-    *   In short: php objects can be serialized, too (except for their resource members),
-    *   using this function.
-    *   Other libs might choke on the very same xml that will be generated in this case
-    *   (i.e. it has a nonstandard attribute on struct element tags)
-    * - usage of javadoc @param tags using param names in a different order from the
-    *   function prototype is not considered valid (to be fixed?)
-    *
-    * Note that since rel. 2.0RC3 the preferred method to have the server call 'standard'
-    * php functions (ie. functions not expecting a single xmlrpcmsg obj as parameter)
-    * is by making use of the functions_parameters_type class member.
-    *
-    * @param string $funcname the name of the PHP user function to be exposed as xmlrpc method; array($obj, 'methodname') and array('class', 'methodname') are ok too
-    * @param string $newfuncname (optional) name for function to be created
-    * @param array $extra_options (optional) array of options for conversion. valid values include:
-    *        bool  return_source when true, php code w. function definition will be returned, not evaluated
-    *        bool  encode_php_objs let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
-    *        bool  decode_php_objs --- WARNING !!! possible security hazard. only use it with trusted servers ---
-    *        bool  suppress_warnings  remove from produced xml any runtime warnings due to the php function being invoked
-    * @return false on error, or an array containing the name of the new php function,
-    *         its signature and docs, to be used in the server dispatch map
-    *
-    * @todo decide how to deal with params passed by ref: bomb out or allow?
-    * @todo finish using javadoc info to build method sig if all params are named but out of order
-    * @todo add a check for params of 'resource' type
-    * @todo add some trigger_errors / error_log when returning false?
-    * @todo what to do when the PHP function returns NULL? we are currently returning an empty string value...
-    * @todo add an option to suppress php warnings in invocation of user function, similar to server debug level 3?
-    * @todo if $newfuncname is empty, we could use create_user_func instead of eval, as it is possibly faster
-    * @todo add a verbatim_object_copy parameter to allow avoiding the same obj instance?
-    */
-    public function wrap_php_function($funcname, $newfuncname='', $extra_options=array())
+     * Given a user-defined PHP function, create a PHP 'wrapper' function that can
+     * be exposed as xmlrpc method from an xmlrpc server object and called from remote
+     * clients (as well as its corresponding signature info).
+     *
+     * Since php is a typeless language, to infer types of input and output parameters,
+     * it relies on parsing the javadoc-style comment block associated with the given
+     * function. Usage of xmlrpc native types (such as datetime.dateTime.iso8601 and base64)
+     * in the @param tag is also allowed, if you need the php function to receive/send
+     * data in that particular format (note that base64 encoding/decoding is transparently
+     * carried out by the lib, while datetime vals are passed around as strings)
+     *
+     * Known limitations:
+     * - only works for user-defined functions, not for PHP internal functions
+     *   (reflection does not support retrieving number/type of params for those)
+     * - functions returning php objects will generate special structs in xmlrpc responses:
+     *   when the xmlrpc decoding of those responses is carried out by this same lib, using
+     *   the appropriate param in php_xmlrpc_decode, the php objects will be rebuilt.
+     *   In short: php objects can be serialized, too (except for their resource members),
+     *   using this function.
+     *   Other libs might choke on the very same xml that will be generated in this case
+     *   (i.e. it has a nonstandard attribute on struct element tags)
+     *
+     * Note that since rel. 2.0RC3 the preferred method to have the server call 'standard'
+     * php functions (ie. functions not expecting a single Request obj as parameter)
+     * is by making use of the functions_parameters_type class member.
+     *
+     * @param callable $callable the PHP user function to be exposed as xmlrpc method/ a closure, function name, array($obj, 'methodname') or array('class', 'methodname') are ok
+     * @param string $newFuncName (optional) name for function to be created. Used only when return_source in $extraOptions is true
+     * @param array $extraOptions (optional) array of options for conversion. valid values include:
+     *                            - bool return_source     when true, php code w. function definition will be returned, instead of a closure
+     *                            - bool encode_php_objs   let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
+     *                            - bool decode_php_objs   --- WARNING !!! possible security hazard. only use it with trusted servers ---
+     *                            - bool suppress_warnings remove from produced xml any warnings generated at runtime by the php function being invoked
+     *
+     * @return array|false false on error, or an array containing the name of the new php function,
+     *                     its signature and docs, to be used in the server dispatch map
+     *
+     * @todo decide how to deal with params passed by ref in function definition: bomb out or allow?
+     * @todo finish using phpdoc info to build method sig if all params are named but out of order
+     * @todo add a check for params of 'resource' type
+     * @todo add some trigger_errors / error_log when returning false?
+     * @todo what to do when the PHP function returns NULL? We are currently returning an empty string value...
+     * @todo add an option to suppress php warnings in invocation of user function, similar to server debug level 3?
+     * @todo add a verbatim_object_copy parameter to allow avoiding usage the same obj instance?
+     * @todo add an option to allow generated function to skip validation of number of parameters, as that is done by the server anyway
+     */
+    public function wrapPhpFunction($callable, $newFuncName = '', $extraOptions = array())
     {
-        $buildit = isset($extra_options['return_source']) ? !($extra_options['return_source']) : true;
-        $prefix = isset($extra_options['prefix']) ? $extra_options['prefix'] : 'xmlrpc';
-        $encode_php_objects = isset($extra_options['encode_php_objs']) ? (bool)$extra_options['encode_php_objs'] : false;
-        $decode_php_objects = isset($extra_options['decode_php_objs']) ? (bool)$extra_options['decode_php_objs'] : false;
-        $catch_warnings = isset($extra_options['suppress_warnings']) && $extra_options['suppress_warnings'] ? '@' : '';
-
-        $exists = false;
-        if (is_string($funcname) && strpos($funcname, '::') !== false)
-        {
-            $funcname = explode('::', $funcname);
+        $buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
+
+        if (is_string($callable) && strpos($callable, '::') !== false) {
+            $callable = explode('::', $callable);
         }
-        if(is_array($funcname))
-        {
-            if(count($funcname) < 2 || (!is_string($funcname[0]) && !is_object($funcname[0])))
-            {
-                error_log('XML-RPC: syntax for function to be wrapped is wrong');
+        if (is_array($callable)) {
+            if (count($callable) < 2 || (!is_string($callable[0]) && !is_object($callable[0]))) {
+                error_log('XML-RPC: ' . __METHOD__ . ': syntax for function to be wrapped is wrong');
                 return false;
             }
-            if(is_string($funcname[0]))
-            {
-                $plainfuncname = implode('::', $funcname);
+            if (is_string($callable[0])) {
+                $plainFuncName = implode('::', $callable);
+            } elseif (is_object($callable[0])) {
+                $plainFuncName = get_class($callable[0]) . '->' . $callable[1];
             }
-            elseif(is_object($funcname[0]))
-            {
-                $plainfuncname = get_class($funcname[0]) . '->' . $funcname[1];
+            $exists = method_exists($callable[0], $callable[1]);
+        } else if ($callable instanceof \Closure) {
+            // we do not support creating code which wraps closures, as php does not allow to serialize them
+            if (!$buildIt) {
+                error_log('XML-RPC: ' . __METHOD__ . ': a closure can not be wrapped in generated source code');
+                return false;
             }
-            $exists = method_exists($funcname[0], $funcname[1]);
+
+            $plainFuncName = 'Closure';
+            $exists = true;
         }
-        else
-        {
-            $plainfuncname = $funcname;
-            $exists = function_exists($funcname);
+        else {
+            $plainFuncName = $callable;
+            $exists = function_exists($callable);
         }
 
-        if(!$exists)
-        {
-            error_log('XML-RPC: function to be wrapped is not defined: '.$plainfuncname);
+        if (!$exists) {
+            error_log('XML-RPC: ' . __METHOD__ . ': function to be wrapped is not defined: ' . $plainFuncName);
             return false;
         }
-        else
-        {
-            // determine name of new php function
-            if($newfuncname == '')
-            {
-                if(is_array($funcname))
-                {
-                    if(is_string($funcname[0]))
-                        $xmlrpcfuncname = "{$prefix}_".implode('_', $funcname);
-                    else
-                        $xmlrpcfuncname = "{$prefix}_".get_class($funcname[0]) . '_' . $funcname[1];
-                }
-                else
-                {
-                    $xmlrpcfuncname = "{$prefix}_$funcname";
-                }
-            }
-            else
-            {
-                $xmlrpcfuncname = $newfuncname;
+
+        $funcDesc = $this->introspectFunction($callable, $plainFuncName);
+        if (!$funcDesc) {
+            return false;
+        }
+
+        $funcSigs = $this->buildMethodSignatures($funcDesc);
+
+        if ($buildIt) {
+            $callable = $this->buildWrapFunctionClosure($callable, $extraOptions, $plainFuncName, $funcDesc);
+        } else {
+            $newFuncName = $this->newFunctionName($callable, $newFuncName, $extraOptions);
+            $code = $this->buildWrapFunctionSource($callable, $newFuncName, $extraOptions, $plainFuncName, $funcDesc);
+        }
+
+        $ret = array(
+            'function' => $callable,
+            'signature' => $funcSigs['sigs'],
+            'docstring' => $funcDesc['desc'],
+            'signature_docs' => $funcSigs['sigsDocs'],
+        );
+        if (!$buildIt) {
+            $ret['function'] = $newFuncName;
+            $ret['source'] = $code;
+        }
+        return $ret;
+    }
+
+    /**
+     * Introspect a php callable and its phpdoc block and extract information about its signature
+     *
+     * @param callable $callable
+     * @param string $plainFuncName
+     * @return array|false
+     */
+    protected function introspectFunction($callable, $plainFuncName)
+    {
+        // start to introspect PHP code
+        if (is_array($callable)) {
+            $func = new \ReflectionMethod($callable[0], $callable[1]);
+            if ($func->isPrivate()) {
+                error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is private: ' . $plainFuncName);
+                return false;
             }
-            while($buildit && function_exists($xmlrpcfuncname))
-            {
-                $xmlrpcfuncname .= 'x';
+            if ($func->isProtected()) {
+                error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is protected: ' . $plainFuncName);
+                return false;
             }
-
-            // start to introspect PHP code
-            if(is_array($funcname))
-            {
-                $func = new \ReflectionMethod($funcname[0], $funcname[1]);
-                if($func->isPrivate())
-                {
-                    error_log('XML-RPC: method to be wrapped is private: '.$plainfuncname);
-                    return false;
-                }
-                if($func->isProtected())
-                {
-                    error_log('XML-RPC: method to be wrapped is protected: '.$plainfuncname);
-                    return false;
-                }
-                if($func->isConstructor())
-                {
-                    error_log('XML-RPC: method to be wrapped is the constructor: '.$plainfuncname);
-                    return false;
-                }
-                if($func->isDestructor())
-                {
-                    error_log('XML-RPC: method to be wrapped is the destructor: '.$plainfuncname);
-                    return false;
-                }
-                if($func->isAbstract())
-                {
-                    error_log('XML-RPC: method to be wrapped is abstract: '.$plainfuncname);
-                    return false;
-                }
-                /// @todo add more checks for static vs. nonstatic?
+            if ($func->isConstructor()) {
+                error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is the constructor: ' . $plainFuncName);
+                return false;
             }
-            else
-            {
-                $func = new \ReflectionFunction($funcname);
+            if ($func->isDestructor()) {
+                error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is the destructor: ' . $plainFuncName);
+                return false;
             }
-            if($func->isInternal())
-            {
-                // Note: from PHP 5.1.0 onward, we will possibly be able to use invokeargs
-                // instead of getparameters to fully reflect internal php functions ?
-                error_log('XML-RPC: function to be wrapped is internal: '.$plainfuncname);
+            if ($func->isAbstract()) {
+                error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is abstract: ' . $plainFuncName);
                 return false;
             }
+            /// @todo add more checks for static vs. nonstatic?
+        } else {
+            $func = new \ReflectionFunction($callable);
+        }
+        if ($func->isInternal()) {
+            // Note: from PHP 5.1.0 onward, we will possibly be able to use invokeargs
+            // instead of getparameters to fully reflect internal php functions ?
+            error_log('XML-RPC: ' . __METHOD__ . ': function to be wrapped is internal: ' . $plainFuncName);
+            return false;
+        }
 
-            // retrieve parameter names, types and description from javadoc comments
-
-            // function description
-            $desc = '';
-            // type of return val: by default 'any'
-            $returns = Value::$xmlrpcValue;
-            // desc of return val
-            $returnsDocs = '';
-            // type + name of function parameters
-            $paramDocs = array();
-
-            $docs = $func->getDocComment();
-            if($docs != '')
-            {
-                $docs = explode("\n", $docs);
-                $i = 0;
-                foreach($docs as $doc)
-                {
-                    $doc = trim($doc, " \r\t/*");
-                    if(strlen($doc) && strpos($doc, '@') !== 0 && !$i)
-                    {
-                        if($desc)
-                        {
-                            $desc .= "\n";
-                        }
-                        $desc .= $doc;
+        // retrieve parameter names, types and description from javadoc comments
+
+        // function description
+        $desc = '';
+        // type of return val: by default 'any'
+        $returns = Value::$xmlrpcValue;
+        // desc of return val
+        $returnsDocs = '';
+        // type + name of function parameters
+        $paramDocs = array();
+
+        $docs = $func->getDocComment();
+        if ($docs != '') {
+            $docs = explode("\n", $docs);
+            $i = 0;
+            foreach ($docs as $doc) {
+                $doc = trim($doc, " \r\t/*");
+                if (strlen($doc) && strpos($doc, '@') !== 0 && !$i) {
+                    if ($desc) {
+                        $desc .= "\n";
                     }
-                    elseif(strpos($doc, '@param') === 0)
-                    {
-                        // syntax: @param type [$name] desc
-                        if(preg_match('/@param\s+(\S+)(\s+\$\S+)?\s+(.+)/', $doc, $matches))
-                        {
-                            if(strpos($matches[1], '|'))
-                            {
-                                //$paramDocs[$i]['type'] = explode('|', $matches[1]);
-                                $paramDocs[$i]['type'] = 'mixed';
-                            }
-                            else
-                            {
-                                $paramDocs[$i]['type'] = $matches[1];
-                            }
-                            $paramDocs[$i]['name'] = trim($matches[2]);
-                            $paramDocs[$i]['doc'] = $matches[3];
-                        }
-                        $i++;
+                    $desc .= $doc;
+                } elseif (strpos($doc, '@param') === 0) {
+                    // syntax: @param type $name [desc]
+                    if (preg_match('/@param\s+(\S+)\s+(\$\S+)\s*(.+)?/', $doc, $matches)) {
+                        $name = strtolower(trim($matches[2]));
+                        //$paramDocs[$name]['name'] = trim($matches[2]);
+                        $paramDocs[$name]['doc'] = isset($matches[3]) ? $matches[3] : '';
+                        $paramDocs[$name]['type'] = $matches[1];
                     }
-                    elseif(strpos($doc, '@return') === 0)
-                    {
-                        // syntax: @return type desc
-                        //$returns = preg_split('/\s+/', $doc);
-                        if(preg_match('/@return\s+(\S+)\s+(.+)/', $doc, $matches))
-                        {
-                            $returns = php_2_xmlrpc_type($matches[1]);
-                            if(isset($matches[2]))
-                            {
-                                $returnsDocs = $matches[2];
-                            }
+                    $i++;
+                } elseif (strpos($doc, '@return') === 0) {
+                    // syntax: @return type [desc]
+                    if (preg_match('/@return\s+(\S+)(\s+.+)?/', $doc, $matches)) {
+                        $returns = $matches[1];
+                        if (isset($matches[2])) {
+                            $returnsDocs = trim($matches[2]);
                         }
                     }
                 }
             }
+        }
 
-            // execute introspection of actual function prototype
-            $params = array();
-            $i = 0;
-            foreach($func->getParameters() as $paramobj)
-            {
-                $params[$i] = array();
-                $params[$i]['name'] = '$'.$paramobj->getName();
-                $params[$i]['isoptional'] = $paramobj->isOptional();
-                $i++;
+        // execute introspection of actual function prototype
+        $params = array();
+        $i = 0;
+        foreach ($func->getParameters() as $paramObj) {
+            $params[$i] = array();
+            $params[$i]['name'] = '$' . $paramObj->getName();
+            $params[$i]['isoptional'] = $paramObj->isOptional();
+            $i++;
+        }
+
+        return array(
+            'desc' => $desc,
+            'docs' => $docs,
+            'params' => $params, // array, positionally indexed
+            'paramDocs' => $paramDocs, // array, indexed by name
+            'returns' => $returns,
+            'returnsDocs' =>$returnsDocs,
+        );
+    }
+
+    /**
+     * Given the method description given by introspection, create method signature data
+     *
+     * @todo support better docs with multiple types separated by pipes by creating multiple signatures
+     *       (this is questionable, as it might produce a big matrix of possible signatures with many such occurrences)
+     *
+     * @param array $funcDesc as generated by self::introspectFunction()
+     *
+     * @return array
+     */
+    protected function buildMethodSignatures($funcDesc)
+    {
+        $i = 0;
+        $parsVariations = array();
+        $pars = array();
+        $pNum = count($funcDesc['params']);
+        foreach ($funcDesc['params'] as $param) {
+            /* // match by name real param and documented params
+            $name = strtolower($param['name']);
+            if (!isset($funcDesc['paramDocs'][$name])) {
+                $funcDesc['paramDocs'][$name] = array();
             }
+            if (!isset($funcDesc['paramDocs'][$name]['type'])) {
+                $funcDesc['paramDocs'][$name]['type'] = 'mixed';
+            }*/
 
+            if ($param['isoptional']) {
+                // this particular parameter is optional. save as valid previous list of parameters
+                $parsVariations[] = $pars;
+            }
 
-            // start  building of PHP code to be eval'd
-            $innercode = '';
-            $i = 0;
-            $parsvariations = array();
-            $pars = array();
-            $pnum = count($params);
-            foreach($params as $param)
-            {
-                if (isset($paramDocs[$i]['name']) && $paramDocs[$i]['name'] && strtolower($paramDocs[$i]['name']) != strtolower($param['name']))
-                {
-                    // param name from phpdoc info does not match param definition!
-                    $paramDocs[$i]['type'] = 'mixed';
-                }
+            $pars[] = "\$p$i";
+            $i++;
+            if ($i == $pNum) {
+                // last allowed parameters combination
+                $parsVariations[] = $pars;
+            }
+        }
 
-                if($param['isoptional'])
-                {
-                    // this particular parameter is optional. save as valid previous list of parameters
-                    $innercode .= "if (\$paramcount > $i) {\n";
-                    $parsvariations[] = $pars;
-                }
-                $innercode .= "\$p$i = \$msg->getParam($i);\n";
-                if ($decode_php_objects)
-                {
-                    $innercode .= "if (\$p{$i}->kindOf() == 'scalar') \$p$i = \$p{$i}->scalarval(); else \$p$i = php_{$prefix}_decode(\$p$i, array('decode_php_objs'));\n";
-                }
-                else
-                {
-                    $innercode .= "if (\$p{$i}->kindOf() == 'scalar') \$p$i = \$p{$i}->scalarval(); else \$p$i = php_{$prefix}_decode(\$p$i);\n";
-                }
+        if (count($parsVariations) == 0) {
+            // only known good synopsis = no parameters
+            $parsVariations[] = array();
+        }
 
-                $pars[] = "\$p$i";
-                $i++;
-                if($param['isoptional'])
-                {
-                    $innercode .= "}\n";
+        $sigs = array();
+        $sigsDocs = array();
+        foreach ($parsVariations as $pars) {
+            // build a signature
+            $sig = array($this->php2XmlrpcType($funcDesc['returns']));
+            $pSig = array($funcDesc['returnsDocs']);
+            for ($i = 0; $i < count($pars); $i++) {
+                $name = strtolower($funcDesc['params'][$i]['name']);
+                if (isset($funcDesc['paramDocs'][$name]['type'])) {
+                    $sig[] = $this->php2XmlrpcType($funcDesc['paramDocs'][$name]['type']);
+                } else {
+                    $sig[] = Value::$xmlrpcValue;
                 }
-                if($i == $pnum)
-                {
-                    // last allowed parameters combination
-                    $parsvariations[] = $pars;
+                $pSig[] = isset($funcDesc['paramDocs'][$name]['doc']) ? $funcDesc['paramDocs'][$name]['doc'] : '';
+            }
+            $sigs[] = $sig;
+            $sigsDocs[] = $pSig;
+        }
+
+        return array(
+            'sigs' => $sigs,
+            'sigsDocs' => $sigsDocs
+        );
+    }
+
+    /**
+     * Creates a closure that will execute $callable
+     * @todo validate params? In theory all validation is left to the dispatch map...
+     * @todo add support for $catchWarnings
+     *
+     * @param $callable
+     * @param array $extraOptions
+     * @param string $plainFuncName
+     * @param string $funcDesc
+     * @return callable
+     */
+    protected function buildWrapFunctionClosure($callable, $extraOptions, $plainFuncName, $funcDesc)
+    {
+        $function = function($req) use($callable, $extraOptions, $funcDesc)
+        {
+            $nameSpace = '\\PhpXmlRpc\\';
+            $encoderClass = $nameSpace.'Encoder';
+            $responseClass = $nameSpace.'Response';
+            $valueClass = $nameSpace.'Value';
+
+            // validate number of parameters received
+            // this should be optional really, as we assume the server does the validation
+            $minPars = count($funcDesc['params']);
+            $maxPars = $minPars;
+            foreach ($funcDesc['params'] as $i => $param) {
+                if ($param['isoptional']) {
+                    // this particular parameter is optional. We assume later ones are as well
+                    $minPars = $i;
+                    break;
                 }
             }
+            $numPars = $req->getNumParams();
+            if ($numPars < $minPars || $numPars > $maxPars) {
+                return new $responseClass(0, 3, 'Incorrect parameters passed to method');
+            }
 
-            $sigs = array();
-            $psigs = array();
-            if(count($parsvariations) == 0)
-            {
-                // only known good synopsis = no parameters
-                $parsvariations[] = array();
-                $minpars = 0;
-            }
-            else
-            {
-                $minpars = count($parsvariations[0]);
-            }
-
-            if($minpars)
-            {
-                // add to code the check for min params number
-                // NB: this check needs to be done BEFORE decoding param values
-                $innercode = "\$paramcount = \$msg->getNumParams();\n" .
-                "if (\$paramcount < $minpars) return new {$prefix}resp(0, ".PhpXmlRpc::$xmlrpcerr['incorrect_params'].", '".PhpXmlRpc::$xmlrpcerr['incorrect_params']."');\n" . $innercode;
-            }
-            else
-            {
-                $innercode = "\$paramcount = \$msg->getNumParams();\n" . $innercode;
-            }
-
-            $innercode .= "\$np = false;\n";
-            // since there are no closures in php, if we are given an object instance,
-            // we store a pointer to it in a global var...
-            if ( is_array($funcname) && is_object($funcname[0]) )
-            {
-                $GLOBALS['xmlrpcWPFObjHolder'][$xmlrpcfuncname] =& $funcname[0];
-                $innercode .= "\$obj =& \$GLOBALS['xmlrpcWPFObjHolder']['$xmlrpcfuncname'];\n";
-                $realfuncname = '$obj->'.$funcname[1];
-            }
-            else
-            {
-                $realfuncname = $plainfuncname;
-            }
-            foreach($parsvariations as $pars)
-            {
-                $innercode .= "if (\$paramcount == " . count($pars) . ") \$retval = {$catch_warnings}$realfuncname(" . implode(',', $pars) . "); else\n";
-                // build a 'generic' signature (only use an appropriate return type)
-                $sig = array($returns);
-                $psig = array($returnsDocs);
-                for($i=0; $i < count($pars); $i++)
-                {
-                    if (isset($paramDocs[$i]['type']))
-                    {
-                        $sig[] = $this->php_2_xmlrpc_type($paramDocs[$i]['type']);
-                    }
-                    else
-                    {
-                        $sig[] = Value::$xmlrpcValue;
+            $encoder = new $encoderClass();
+            $options = array();
+            if (isset($extraOptions['decode_php_objs']) && $extraOptions['decode_php_objs']) {
+                $options[] = 'decode_php_objs';
+            }
+            $params = $encoder->decode($req, $options);
+
+            $result = call_user_func_array($callable, $params);
+
+            if (! is_a($result, $responseClass)) {
+                if ($funcDesc['returns'] == Value::$xmlrpcDateTime || $funcDesc['returns'] == Value::$xmlrpcBase64) {
+                    $result = new $valueClass($result, $funcDesc['returns']);
+                } else {
+                    $options = array();
+                    if (isset($extraOptions['encode_php_objs']) && $extraOptions['encode_php_objs']) {
+                        $options[] = 'encode_php_objs';
                     }
-                    $psig[] = isset($paramDocs[$i]['doc']) ? $paramDocs[$i]['doc'] : '';
+
+                    $result = $encoder->encode($result, $options);
                 }
-                $sigs[] = $sig;
-                $psigs[] = $psig;
-            }
-            $innercode .= "\$np = true;\n";
-            $innercode .= "if (\$np) return new {$prefix}resp(0, ".PhpXmlRpc::$xmlrpcerr['incorrect_params'].", '".PhpXmlRpc::$xmlrpcerr['incorrect_params']."'); else {\n";
-            //$innercode .= "if (\$_xmlrpcs_error_occurred) return new Response(0, $GLOBALS['xmlrpcerr']user, \$_xmlrpcs_error_occurred); else\n";
-            $innercode .= "if (is_a(\$retval, '{$prefix}resp')) return \$retval; else\n";
-            if($returns == Value::$xmlrpcDateTime || $returns == Value::$xmlrpcBase64)
-            {
-                $innercode .= "return new {$prefix}resp(new {$prefix}val(\$retval, '$returns'));";
-            }
-            else
-            {
-                if ($encode_php_objects)
-                    $innercode .= "return new {$prefix}resp(php_{$prefix}_encode(\$retval, array('encode_php_objs')));\n";
-                else
-                    $innercode .= "return new {$prefix}resp(php_{$prefix}_encode(\$retval));\n";
-            }
-            // shall we exclude functions returning by ref?
-            // if($func->returnsReference())
-            //     return false;
-            $code = "function $xmlrpcfuncname(\$msg) {\n" . $innercode . "}\n}";
-            //print_r($code);
-            if ($buildit)
-            {
-                $allOK = 0;
-                eval($code.'$allOK=1;');
-                // alternative
-                //$xmlrpcfuncname = create_function('$m', $innercode);
-
-                if(!$allOK)
-                {
-                    error_log('XML-RPC: could not create function '.$xmlrpcfuncname.' to wrap php function '.$plainfuncname);
-                    return false;
+                $result = new $responseClass($result);
+            }
+
+            return $result;
+        };
+
+        return $function;
+    }
+
+    /**
+     * Return a name for a new function, based on $callable, insuring its uniqueness
+     * @param mixed $callable a php callable, or the name of an xmlrpc method
+     * @param string $newFuncName when not empty, it is used instead of the calculated version
+     * @return string
+     */
+    protected function newFunctionName($callable, $newFuncName, $extraOptions)
+    {
+        // determine name of new php function
+
+        $prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
+
+        if ($newFuncName == '') {
+            if (is_array($callable)) {
+                if (is_string($callable[0])) {
+                    $xmlrpcFuncName = "{$prefix}_" . implode('_', $callable);
+                } else {
+                    $xmlrpcFuncName = "{$prefix}_" . get_class($callable[0]) . '_' . $callable[1];
+                }
+            } else {
+                if ($callable instanceof \Closure) {
+                    $xmlrpcFuncName = "{$prefix}_closure";
+                } else {
+                    $callable = preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
+                        array('_', ''), $callable);
+                    $xmlrpcFuncName = "{$prefix}_$callable";
                 }
             }
+        } else {
+            $xmlrpcFuncName = $newFuncName;
+        }
 
-            /// @todo examine if $paramDocs matches $parsvariations and build array for
-            /// usage as method signature, plus put together a nice string for docs
+        while (function_exists($xmlrpcFuncName)) {
+            $xmlrpcFuncName .= 'x';
+        }
+
+        return $xmlrpcFuncName;
+    }
+
+    /**
+     * @param $callable
+     * @param string $newFuncName
+     * @param array $extraOptions
+     * @param string $plainFuncName
+     * @param array $funcDesc
+     * @return array
+     *
+     * @todo add a nice phpdoc block in the generated source
+     */
+    protected function buildWrapFunctionSource($callable, $newFuncName, $extraOptions, $plainFuncName, $funcDesc)
+    {
+        $namespace = '\\PhpXmlRpc\\';
+
+        $encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
+        $decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
+        $catchWarnings = isset($extraOptions['suppress_warnings']) && $extraOptions['suppress_warnings'] ? '@' : '';
+
+        $i = 0;
+        $parsVariations = array();
+        $pars = array();
+        $pNum = count($funcDesc['params']);
+        foreach ($funcDesc['params'] as $param) {
+
+            if ($param['isoptional']) {
+                // this particular parameter is optional. save as valid previous list of parameters
+                $parsVariations[] = $pars;
+            }
+
+            $pars[] = "\$p[$i]";
+            $i++;
+            if ($i == $pNum) {
+                // last allowed parameters combination
+                $parsVariations[] = $pars;
+            }
+        }
+
+        if (count($parsVariations) == 0) {
+            // only known good synopsis = no parameters
+            $parsVariations[] = array();
+            $minPars = 0;
+            $maxPars = 0;
+        } else {
+            $minPars = count($parsVariations[0]);
+            $maxPars = count($parsVariations[count($parsVariations)-1]);
+        }
 
-            $ret = array('function' => $xmlrpcfuncname, 'signature' => $sigs, 'docstring' => $desc, 'signature_docs' => $psigs, 'source' => $code);
-            return $ret;
+        // build body of new function
+
+        $innerCode = "\$paramCount = \$req->getNumParams();\n";
+        $innerCode .= "if (\$paramCount < $minPars || \$paramCount > $maxPars) return new {$namespace}Response(0, " . PhpXmlRpc::$xmlrpcerr['incorrect_params'] . ", '" . PhpXmlRpc::$xmlrpcstr['incorrect_params'] . "');\n";
+
+        $innerCode .= "\$encoder = new {$namespace}Encoder();\n";
+        if ($decodePhpObjects) {
+            $innerCode .= "\$p = \$encoder->decode(\$req, array('decode_php_objs'));\n";
+        } else {
+            $innerCode .= "\$p = \$encoder->decode(\$req);\n";
+        }
+
+        // since we are building source code for later use, if we are given an object instance,
+        // we go out of our way and store a pointer to it in a static class var var...
+        if (is_array($callable) && is_object($callable[0])) {
+            self::$objHolder[$newFuncName] = $callable[0];
+            $innerCode .= "\$obj = PhpXmlRpc\\Wrapper::\$objHolder['$newFuncName'];\n";
+            $realFuncName = '$obj->' . $callable[1];
+        } else {
+            $realFuncName = $plainFuncName;
         }
+        foreach ($parsVariations as $i => $pars) {
+            $innerCode .= "if (\$paramCount == " . count($pars) . ") \$retval = {$catchWarnings}$realFuncName(" . implode(',', $pars) . ");\n";
+            if ($i < (count($parsVariations) - 1))
+                $innerCode .= "else\n";
+        }
+        $innerCode .= "if (is_a(\$retval, '{$namespace}Response')) return \$retval; else\n";
+        if ($funcDesc['returns'] == Value::$xmlrpcDateTime || $funcDesc['returns'] == Value::$xmlrpcBase64) {
+            $innerCode .= "return new {$namespace}Response(new {$namespace}Value(\$retval, '{$funcDesc['returns']}'));";
+        } else {
+            if ($encodePhpObjects) {
+                $innerCode .= "return new {$namespace}Response(\$encoder->encode(\$retval, array('encode_php_objs')));\n";
+            } else {
+                $innerCode .= "return new {$namespace}Response(\$encoder->encode(\$retval));\n";
+            }
+        }
+        // shall we exclude functions returning by ref?
+        // if($func->returnsReference())
+        //     return false;
+
+        $code = "function $newFuncName(\$req) {\n" . $innerCode . "\n}";
+
+        return $code;
     }
 
     /**
-    * Given a user-defined PHP class or php object, map its methods onto a list of
-    * PHP 'wrapper' functions that can be exposed as xmlrpc methods from an xmlrpc_server
-    * object and called from remote clients (as well as their corresponding signature info).
-    *
-    * @param mixed $classname the name of the class whose methods are to be exposed as xmlrpc methods, or an object instance of that class
-    * @param array $extra_options see the docs for wrap_php_method for more options
-    *        string method_type 'static', 'nonstatic', 'all' and 'auto' (default); the latter will switch between static and non-static depending on wheter $classname is a class name or object instance
-    * @return array or false on failure
-    *
-    * @todo get_class_methods will return both static and non-static methods.
-    *       we have to differentiate the action, depending on wheter we recived a class name or object
-    */
-    public function wrap_php_class($classname, $extra_options=array())
+     * Given a user-defined PHP class or php object, map its methods onto a list of
+     * PHP 'wrapper' functions that can be exposed as xmlrpc methods from an xmlrpc server
+     * object and called from remote clients (as well as their corresponding signature info).
+     *
+     * @param string|object $className the name of the class whose methods are to be exposed as xmlrpc methods, or an object instance of that class
+     * @param array $extraOptions see the docs for wrapPhpMethod for basic options, plus
+     *                            - string method_type    'static', 'nonstatic', 'all' and 'auto' (default); the latter will switch between static and non-static depending on whether $className is a class name or object instance
+     *                            - string method_filter  a regexp used to filter methods to wrap based on their names
+     *                            - string prefix         used for the names of the xmlrpc methods created
+     *
+     * @return array|false false on failure
+     */
+    public function wrapPhpClass($className, $extraOptions = array())
     {
-        $methodfilter = isset($extra_options['method_filter']) ? $extra_options['method_filter'] : '';
-        $methodtype = isset($extra_options['method_type']) ? $extra_options['method_type'] : 'auto';
+        $methodFilter = isset($extraOptions['method_filter']) ? $extraOptions['method_filter'] : '';
+        $methodType = isset($extraOptions['method_type']) ? $extraOptions['method_type'] : 'auto';
+        $prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : '';
 
-        $result = array();
-        $mlist = get_class_methods($classname);
-        foreach($mlist as $mname)
-        {
-            if ($methodfilter == '' || preg_match($methodfilter, $mname))
-            {
-                // echo $mlist."\n";
-                $func = new ReflectionMethod($classname, $mname);
-                if(!$func->isPrivate() && !$func->isProtected() && !$func->isConstructor() && !$func->isDestructor() && !$func->isAbstract())
-                {
-                    if(($func->isStatic && ($methodtype == 'all' || $methodtype == 'static' || ($methodtype == 'auto' && is_string($classname)))) ||
-                        (!$func->isStatic && ($methodtype == 'all' || $methodtype == 'nonstatic' || ($methodtype == 'auto' && is_object($classname)))))
-                    {
-                        $methodwrap = wrap_php_function(array($classname, $mname), '', $extra_options);
-                        if ( $methodwrap )
-                        {
-                            $result[$methodwrap['function']] = $methodwrap['function'];
+        $results = array();
+        $mList = get_class_methods($className);
+        foreach ($mList as $mName) {
+            if ($methodFilter == '' || preg_match($methodFilter, $mName)) {
+                $func = new \ReflectionMethod($className, $mName);
+                if (!$func->isPrivate() && !$func->isProtected() && !$func->isConstructor() && !$func->isDestructor() && !$func->isAbstract()) {
+                    if (($func->isStatic() && ($methodType == 'all' || $methodType == 'static' || ($methodType == 'auto' && is_string($className)))) ||
+                        (!$func->isStatic() && ($methodType == 'all' || $methodType == 'nonstatic' || ($methodType == 'auto' && is_object($className))))
+                    ) {
+                        $methodWrap = $this->wrapPhpFunction(array($className, $mName), '', $extraOptions);
+                        if ($methodWrap) {
+                            if (is_object($className)) {
+                                $realClassName = get_class($className);
+                            }else {
+                                $realClassName = $className;
+                            }
+                            $results[$prefix."$realClassName.$mName"] = $methodWrap;
                         }
                     }
                 }
             }
         }
-        return $result;
+
+        return $results;
     }
 
     /**
-    * Given an xmlrpc client and a method name, register a php wrapper function
-    * that will call it and return results using native php types for both
-    * params and results. The generated php function will return an xmlrpcresp
-    * object for failed xmlrpc calls
-    *
-    * Known limitations:
-    * - server must support system.methodsignature for the wanted xmlrpc method
-    * - for methods that expose many signatures, only one can be picked (we
-    *   could in principle check if signatures differ only by number of params
-    *   and not by type, but it would be more complication than we can spare time)
-    * - nested xmlrpc params: the caller of the generated php function has to
-    *   encode on its own the params passed to the php function if these are structs
-    *   or arrays whose (sub)members include values of type datetime or base64
-    *
-    * Notes: the connection properties of the given client will be copied
-    * and reused for the connection used during the call to the generated
-    * php function.
-    * Calling the generated php function 'might' be slow: a new xmlrpc client
-    * is created on every invocation and an xmlrpc-connection opened+closed.
-    * An extra 'debug' param is appended to param list of xmlrpc method, useful
-    * for debugging purposes.
-    *
-    * @param xmlrpc_client $client     an xmlrpc client set up correctly to communicate with target server
-    * @param string        $methodname the xmlrpc method to be mapped to a php function
-    * @param array         $extra_options array of options that specify conversion details. valid options include
-    *        integer       signum      the index of the method signature to use in mapping (if method exposes many sigs)
-    *        integer       timeout     timeout (in secs) to be used when executing function/calling remote method
-    *        string        protocol    'http' (default), 'http11' or 'https'
-    *        string        new_function_name the name of php function to create. If unspecified, lib will pick an appropriate name
-    *        string        return_source if true return php code w. function definition instead fo function name
-    *        bool          encode_php_objs let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
-    *        bool          decode_php_objs --- WARNING !!! possible security hazard. only use it with trusted servers ---
-    *        mixed         return_on_fault a php value to be returned when the xmlrpc call fails/returns a fault response (by default the xmlrpcresp object is returned in this case). If a string is used, '%faultCode%' and '%faultString%' tokens will be substituted with actual error values
-    *        bool          debug        set it to 1 or 2 to see debug results of querying server for method synopsis
-    * @return string                   the name of the generated php function (or false) - OR AN ARRAY...
-    */
-    public function wrap_xmlrpc_method($client, $methodname, $extra_options=0, $timeout=0, $protocol='', $newfuncname='')
+     * Given an xmlrpc client and a method name, register a php wrapper function
+     * that will call it and return results using native php types for both
+     * params and results. The generated php function will return a Response
+     * object for failed xmlrpc calls.
+     *
+     * Known limitations:
+     * - server must support system.methodsignature for the wanted xmlrpc method
+     * - for methods that expose many signatures, only one can be picked (we
+     *   could in principle check if signatures differ only by number of params
+     *   and not by type, but it would be more complication than we can spare time)
+     * - nested xmlrpc params: the caller of the generated php function has to
+     *   encode on its own the params passed to the php function if these are structs
+     *   or arrays whose (sub)members include values of type datetime or base64
+     *
+     * Notes: the connection properties of the given client will be copied
+     * and reused for the connection used during the call to the generated
+     * php function.
+     * Calling the generated php function 'might' be slow: a new xmlrpc client
+     * is created on every invocation and an xmlrpc-connection opened+closed.
+     * An extra 'debug' param is appended to param list of xmlrpc method, useful
+     * for debugging purposes.
+     *
+     * @todo allow caller to give us the method signature instead of querying for it, or just say 'skip it'
+     * @todo if we can not retrieve method signature, create a php function with varargs
+     * @todo allow the created function to throw exceptions on method calls failures
+     * @todo if caller did not specify a specific sig, shall we support all of them?
+     *       It might be hard (hence slow) to match based on type and number of arguments...
+     *
+     * @param Client $client an xmlrpc client set up correctly to communicate with target server
+     * @param string $methodName the xmlrpc method to be mapped to a php function
+     * @param array $extraOptions array of options that specify conversion details. Valid options include
+     *                            - integer signum              the index of the method signature to use in mapping (if method exposes many sigs)
+     *                            - integer timeout             timeout (in secs) to be used when executing function/calling remote method
+     *                            - string  protocol            'http' (default), 'http11' or 'https'
+     *                            - string  new_function_name   the name of php function to create, when return_source is used. If unspecified, lib will pick an appropriate name
+     *                            - string  return_source       if true return php code w. function definition instead of function itself (closure)
+     *                            - bool    encode_php_objs     let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
+     *                            - bool    decode_php_objs     --- WARNING !!! possible security hazard. only use it with trusted servers ---
+     *                            - mixed   return_on_fault     a php value to be returned when the xmlrpc call fails/returns a fault response (by default the Response object is returned in this case). If a string is used, '%faultCode%' and '%faultString%' tokens will be substituted with actual error values
+     *                            - bool    debug               set it to 1 or 2 to see debug results of querying server for method synopsis
+     *                            - int     simple_client_copy  set it to 1 to have a lightweight copy of the $client object made in the generated code (only used when return_source = true)
+     *
+     * @return \closure|array|false false on failure, closure by default and array for return_source = true
+     */
+    public function wrapXmlrpcMethod($client, $methodName, $extraOptions = array())
     {
-        // mind numbing: let caller use sane calling convention (as per javadoc, 3 params),
-        // OR the 2.0 calling convention (no options) - we really love backward compat, don't we?
-        if (!is_array($extra_options))
-        {
-            $signum = $extra_options;
-            $extra_options = array();
-        }
-        else
-        {
-            $signum = isset($extra_options['signum']) ? (int)$extra_options['signum'] : 0;
-            $timeout = isset($extra_options['timeout']) ? (int)$extra_options['timeout'] : 0;
-            $protocol = isset($extra_options['protocol']) ? $extra_options['protocol'] : '';
-            $newfuncname = isset($extra_options['new_function_name']) ? $extra_options['new_function_name'] : '';
-        }
-        //$encode_php_objects = in_array('encode_php_objects', $extra_options);
-        //$verbatim_client_copy = in_array('simple_client_copy', $extra_options) ? 1 :
-        //	in_array('build_class_code', $extra_options) ? 2 : 0;
-
-        $encode_php_objects = isset($extra_options['encode_php_objs']) ? (bool)$extra_options['encode_php_objs'] : false;
-        $decode_php_objects = isset($extra_options['decode_php_objs']) ? (bool)$extra_options['decode_php_objs'] : false;
-        // it seems like the meaning of 'simple_client_copy' here is swapped wrt client_copy_mode later on...
-        $simple_client_copy = isset($extra_options['simple_client_copy']) ? (int)($extra_options['simple_client_copy']) : 0;
-        $buildit = isset($extra_options['return_source']) ? !($extra_options['return_source']) : true;
-        $prefix = isset($extra_options['prefix']) ? $extra_options['prefix'] : 'xmlrpc';
-        if (isset($extra_options['return_on_fault']))
-        {
-            $decode_fault = true;
-            $fault_response = $extra_options['return_on_fault'];
+        $newFuncName = isset($extraOptions['new_function_name']) ? $extraOptions['new_function_name'] : '';
+
+        $buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
+
+        $mSig = $this->retrieveMethodSignature($client, $methodName, $extraOptions);
+        if (!$mSig) {
+            return false;
         }
-        else
-        {
-            $decode_fault = false;
-            $fault_response = '';
+
+        if ($buildIt) {
+            return $this->buildWrapMethodClosure($client, $methodName, $extraOptions, $mSig);
+        } else {
+            // if in 'offline' mode, retrieve method description too.
+            // in online mode, favour speed of operation
+            $mDesc = $this->retrieveMethodHelp($client, $methodName, $extraOptions);
+
+            $newFuncName = $this->newFunctionName($methodName, $newFuncName, $extraOptions);
+
+            $results = $this->buildWrapMethodSource($client, $methodName, $extraOptions, $newFuncName, $mSig, $mDesc);
+            /* was: $results = $this->build_remote_method_wrapper_code($client, $methodName,
+                $newFuncName, $mSig, $mDesc, $timeout, $protocol, $simpleClientCopy,
+                $prefix, $decodePhpObjects, $encodePhpObjects, $decodeFault,
+                $faultResponse, $namespace);*/
+
+            $results['function'] = $newFuncName;
+
+            return $results;
         }
-        $debug = isset($extra_options['debug']) ? ($extra_options['debug']) : 0;
 
-        $msgclass = $prefix.'msg';
-        $valclass = $prefix.'val';
-        $decodefunc = 'php_'.$prefix.'_decode';
+    }
+
+    /**
+     * Retrieves an xmlrpc method signature from a server which supports system.methodSignature
+     * @param Client $client
+     * @param string $methodName
+     * @param array $extraOptions
+     * @return false|array
+     */
+    protected function retrieveMethodSignature($client, $methodName, array $extraOptions = array())
+    {
+        $namespace = '\\PhpXmlRpc\\';
+        $reqClass = $namespace . 'Request';
+        $valClass = $namespace . 'Value';
+        $decoderClass = $namespace . 'Encoder';
+
+        $debug = isset($extraOptions['debug']) ? ($extraOptions['debug']) : 0;
+        $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+        $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+        $sigNum = isset($extraOptions['signum']) ? (int)$extraOptions['signum'] : 0;
 
-        $msg = new $msgclass('system.methodSignature');
-        $msg->addparam(new $valclass($methodname));
+        $req = new $reqClass('system.methodSignature');
+        $req->addparam(new $valClass($methodName));
         $client->setDebug($debug);
-        $response = $client->send($msg, $timeout, $protocol);
-        if($response->faultCode())
-        {
-            error_log('XML-RPC: could not retrieve method signature from remote server for method '.$methodname);
+        $response = $client->send($req, $timeout, $protocol);
+        if ($response->faultCode()) {
+            error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method signature from remote server for method ' . $methodName);
             return false;
         }
-        else
-        {
-            $msig = $response->value();
-            if ($client->return_type != 'phpvals')
-            {
-                $msig = $decodefunc($msig);
-            }
-            if(!is_array($msig) || count($msig) <= $signum)
-            {
-                error_log('XML-RPC: could not retrieve method signature nr.'.$signum.' from remote server for method '.$methodname);
-                return false;
-            }
-            else
-            {
-                // pick a suitable name for the new function, avoiding collisions
-                if($newfuncname != '')
-                {
-                    $xmlrpcfuncname = $newfuncname;
-                }
-                else
-                {
-                    // take care to insure that methodname is translated to valid
-                    // php function name
-                    $xmlrpcfuncname = $prefix.'_'.preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
-                        array('_', ''), $methodname);
-                }
-                while($buildit && function_exists($xmlrpcfuncname))
-                {
-                    $xmlrpcfuncname .= 'x';
-                }
 
-                $msig = $msig[$signum];
-                $mdesc = '';
-                // if in 'offline' mode, get method description too.
-                // in online mode, favour speed of operation
-                if(!$buildit)
-                {
-                    $msg = new $msgclass('system.methodHelp');
-                    $msg->addparam(new $valclass($methodname));
-                    $response = $client->send($msg, $timeout, $protocol);
-                    if (!$response->faultCode())
-                    {
-                        $mdesc = $response->value();
-                        if ($client->return_type != 'phpvals')
-                        {
-                            $mdesc = $mdesc->scalarval();
-                        }
-                    }
-                }
+        $mSig = $response->value();
+        if ($client->return_type != 'phpvals') {
+            $decoder = new $decoderClass();
+            $mSig = $decoder->decode($mSig);
+        }
 
-                $results = $this->build_remote_method_wrapper_code($client, $methodname,
-                    $xmlrpcfuncname, $msig, $mdesc, $timeout, $protocol, $simple_client_copy,
-                    $prefix, $decode_php_objects, $encode_php_objects, $decode_fault,
-                    $fault_response);
+        if (!is_array($mSig) || count($mSig) <= $sigNum) {
+            error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method signature nr.' . $sigNum . ' from remote server for method ' . $methodName);
+            return false;
+        }
 
-                //print_r($code);
-                if ($buildit)
-                {
-                    $allOK = 0;
-                    eval($results['source'].'$allOK=1;');
-                    // alternative
-                    //$xmlrpcfuncname = create_function('$m', $innercode);
-                    if($allOK)
-                    {
-                        return $xmlrpcfuncname;
-                    }
-                    else
-                    {
-                        error_log('XML-RPC: could not create function '.$xmlrpcfuncname.' to wrap remote method '.$methodname);
-                        return false;
-                    }
-                }
-                else
-                {
-                    $results['function'] = $xmlrpcfuncname;
-                    return $results;
-                }
+        return $mSig[$sigNum];
+    }
+
+    /**
+     * @param Client $client
+     * @param string $methodName
+     * @param array $extraOptions
+     * @return string in case of any error, an empty string is returned, no warnings generated
+     */
+    protected function retrieveMethodHelp($client, $methodName, array $extraOptions = array())
+    {
+        $namespace = '\\PhpXmlRpc\\';
+        $reqClass = $namespace . 'Request';
+        $valClass = $namespace . 'Value';
+
+        $debug = isset($extraOptions['debug']) ? ($extraOptions['debug']) : 0;
+        $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+        $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+
+        $mDesc = '';
+
+        $req = new $reqClass('system.methodHelp');
+        $req->addparam(new $valClass($methodName));
+        $client->setDebug($debug);
+        $response = $client->send($req, $timeout, $protocol);
+        if (!$response->faultCode()) {
+            $mDesc = $response->value();
+            if ($client->return_type != 'phpvals') {
+                $mDesc = $mDesc->scalarval();
             }
         }
+
+        return $mDesc;
     }
 
     /**
-    * Similar to wrap_xmlrpc_method, but will generate a php class that wraps
-    * all xmlrpc methods exposed by the remote server as own methods.
-    * For more details see wrap_xmlrpc_method.
-    * @param xmlrpc_client $client the client obj all set to query the desired server
-    * @param array $extra_options list of options for wrapped code
-    * @return mixed false on error, the name of the created class if all ok or an array with code, class name and comments (if the appropriatevoption is set in extra_options)
-    */
-    public function wrap_xmlrpc_server($client, $extra_options=array())
+     * @param Client $client
+     * @param string $methodName
+     * @param array $extraOptions
+     * @param string $mSig
+     * @return callable
+     *
+     * @todo should we allow usage of parameter simple_client_copy to mean 'do not clone' in this case?
+     */
+    protected function buildWrapMethodClosure($client, $methodName, array $extraOptions, $mSig)
     {
-        $methodfilter = isset($extra_options['method_filter']) ? $extra_options['method_filter'] : '';
-        //$signum = isset($extra_options['signum']) ? (int)$extra_options['signum'] : 0;
-        $timeout = isset($extra_options['timeout']) ? (int)$extra_options['timeout'] : 0;
-        $protocol = isset($extra_options['protocol']) ? $extra_options['protocol'] : '';
-        $newclassname = isset($extra_options['new_class_name']) ? $extra_options['new_class_name'] : '';
-        $encode_php_objects = isset($extra_options['encode_php_objs']) ? (bool)$extra_options['encode_php_objs'] : false;
-        $decode_php_objects = isset($extra_options['decode_php_objs']) ? (bool)$extra_options['decode_php_objs'] : false;
-        $verbatim_client_copy = isset($extra_options['simple_client_copy']) ? !($extra_options['simple_client_copy']) : true;
-        $buildit = isset($extra_options['return_source']) ? !($extra_options['return_source']) : true;
-        $prefix = isset($extra_options['prefix']) ? $extra_options['prefix'] : 'xmlrpc';
-
-        $msgclass = $prefix.'msg';
-        //$valclass = $prefix.'val';
-        $decodefunc = 'php_'.$prefix.'_decode';
-
-        $msg = new $msgclass('system.listMethods');
-        $response = $client->send($msg, $timeout, $protocol);
-        if($response->faultCode())
+        // we clone the client, so that we can modify it a bit independently of the original
+        $clientClone = clone $client;
+        $function = function() use($clientClone, $methodName, $extraOptions, $mSig)
         {
-            error_log('XML-RPC: could not retrieve method list from remote server');
-            return false;
-        }
-        else
-        {
-            $mlist = $response->value();
-            if ($client->return_type != 'phpvals')
-            {
-                $mlist = $decodefunc($mlist);
-            }
-            if(!is_array($mlist) || !count($mlist))
-            {
-                error_log('XML-RPC: could not retrieve meaningful method list from remote server');
-                return false;
+            $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+            $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+            $encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
+            $decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
+            if (isset($extraOptions['return_on_fault'])) {
+                $decodeFault = true;
+                $faultResponse = $extraOptions['return_on_fault'];
+            } else {
+                $decodeFault = false;
             }
-            else
-            {
-                // pick a suitable name for the new function, avoiding collisions
-                if($newclassname != '')
-                {
-                    $xmlrpcclassname = $newclassname;
-                }
-                else
-                {
-                    $xmlrpcclassname = $prefix.'_'.preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
-                        array('_', ''), $client->server).'_client';
+
+            $namespace = '\\PhpXmlRpc\\';
+            $reqClass = $namespace . 'Request';
+            $encoderClass = $namespace . 'Encoder';
+            $valueClass = $namespace . 'Value';
+
+            $encoder = new $encoderClass();
+            $encodeOptions = array();
+            if ($encodePhpObjects) {
+                $encodeOptions[] = 'encode_php_objs';
+            }
+            $decodeOptions = array();
+            if ($decodePhpObjects) {
+                $decodeOptions[] = 'decode_php_objs';
+            }
+
+            /// @todo check for insufficient nr. of args besides excess ones? note that 'source' version does not...
+
+            // support one extra parameter: debug
+            $maxArgs = count($mSig)-1; // 1st element is the return type
+            $currentArgs = func_get_args();
+            if (func_num_args() == ($maxArgs+1)) {
+                $debug = array_pop($currentArgs);
+                $clientClone->setDebug($debug);
+            }
+
+            $xmlrpcArgs = array();
+            foreach($currentArgs as $i => $arg) {
+                if ($i == $maxArgs) {
+                    break;
                 }
-                while($buildit && class_exists($xmlrpcclassname))
-                {
-                    $xmlrpcclassname .= 'x';
+                $pType = $mSig[$i+1];
+                if ($pType == 'i4' || $pType == 'int' || $pType == 'boolean' || $pType == 'double' ||
+                    $pType == 'string' || $pType == 'dateTime.iso8601' || $pType == 'base64' || $pType == 'null'
+                ) {
+                    // by building directly xmlrpc values when type is known and scalar (instead of encode() calls),
+                    // we make sure to honour the xmlrpc signature
+                    $xmlrpcArgs[] = new $valueClass($arg, $pType);
+                } else {
+                    $xmlrpcArgs[] = $encoder->encode($arg, $encodeOptions);
                 }
+            }
 
-                /// @todo add function setdebug() to new class, to enable/disable debugging
-                $source = "class $xmlrpcclassname\n{\nvar \$client;\n\n";
-                $source .= "function $xmlrpcclassname()\n{\n";
-                $source .= $this->build_client_wrapper_code($client, $verbatim_client_copy, $prefix);
-                $source .= "\$this->client =& \$client;\n}\n\n";
-                $opts = array('simple_client_copy' => 2, 'return_source' => true,
-                    'timeout' => $timeout, 'protocol' => $protocol,
-                    'encode_php_objs' => $encode_php_objects, 'prefix' => $prefix,
-                    'decode_php_objs' => $decode_php_objects
-                    );
-                /// @todo build javadoc for class definition, too
-                foreach($mlist as $mname)
-                {
-                    if ($methodfilter == '' || preg_match($methodfilter, $mname))
-                    {
-                        $opts['new_function_name'] = preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
-                            array('_', ''), $mname);
-                        $methodwrap = wrap_xmlrpc_method($client, $mname, $opts);
-                        if ($methodwrap)
-                        {
-                            if (!$buildit)
-                            {
-                                $source .= $methodwrap['docstring'];
-                            }
-                            $source .= $methodwrap['source']."\n";
-                        }
-                        else
-                        {
-                            error_log('XML-RPC: will not create class method to wrap remote method '.$mname);
-                        }
-                    }
-                }
-                $source .= "}\n";
-                if ($buildit)
-                {
-                    $allOK = 0;
-                    eval($source.'$allOK=1;');
-                    // alternative
-                    //$xmlrpcfuncname = create_function('$m', $innercode);
-                    if($allOK)
-                    {
-                        return $xmlrpcclassname;
-                    }
-                    else
-                    {
-                        error_log('XML-RPC: could not create class '.$xmlrpcclassname.' to wrap remote server '.$client->server);
-                        return false;
+            $req = new $reqClass($methodName, $xmlrpcArgs);
+            // use this to get the maximum decoding flexibility
+            $clientClone->return_type = 'xmlrpcvals';
+            $resp = $clientClone->send($req, $timeout, $protocol);
+            if ($resp->faultcode()) {
+                if ($decodeFault) {
+                    if (is_string($faultResponse) && ((strpos($faultResponse, '%faultCode%') !== false) ||
+                            (strpos($faultResponse, '%faultString%') !== false))) {
+                        $faultResponse = str_replace(array('%faultCode%', '%faultString%'),
+                            array($resp->faultCode(), $resp->faultString()), $faultResponse);
                     }
+                    return $faultResponse;
+                } else {
+                    return $resp;
                 }
-                else
-                {
-                    return array('class' => $xmlrpcclassname, 'code' => $source, 'docstring' => '');
-                }
+            } else {
+                return $encoder->decode($resp->value(), $decodeOptions);
             }
-        }
+        };
+
+        return $function;
     }
 
     /**
-    * Given the necessary info, build php code that creates a new function to
-    * invoke a remote xmlrpc method.
-    * Take care that no full checking of input parameters is done to ensure that
-    * valid php code is emitted.
-    * Note: real spaghetti code follows...
-    */
-    protected function build_remote_method_wrapper_code($client, $methodname, $xmlrpcfuncname,
-        $msig, $mdesc='', $timeout=0, $protocol='', $client_copy_mode=0, $prefix='xmlrpc',
-        $decode_php_objects=false, $encode_php_objects=false, $decode_fault=false,
-        $fault_response='')
+     * @param Client $client
+     * @param string $methodName
+     * @param array $extraOptions
+     * @param string $newFuncName
+     * @param array $mSig
+     * @param string $mDesc
+     * @return array
+     */
+    public function buildWrapMethodSource($client, $methodName, array $extraOptions, $newFuncName, $mSig, $mDesc='')
     {
-        $code = "function $xmlrpcfuncname (";
-        if ($client_copy_mode < 2)
-        {
-            // client copy mode 0 or 1 == partial / full client copy in emitted code
-            $innercode = $this->build_client_wrapper_code($client, $client_copy_mode, $prefix);
-            $innercode .= "\$client->setDebug(\$debug);\n";
-            $this_ = '';
+        $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+        $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+        $encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
+        $decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
+        $clientCopyMode = isset($extraOptions['simple_client_copy']) ? (int)($extraOptions['simple_client_copy']) : 0;
+        $prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
+        if (isset($extraOptions['return_on_fault'])) {
+            $decodeFault = true;
+            $faultResponse = $extraOptions['return_on_fault'];
+        } else {
+            $decodeFault = false;
+            $faultResponse = '';
         }
-        else
-        {
+
+        $namespace = '\\PhpXmlRpc\\';
+
+        $code = "function $newFuncName (";
+        if ($clientCopyMode < 2) {
+            // client copy mode 0 or 1 == full / partial client copy in emitted code
+            $verbatimClientCopy = !$clientCopyMode;
+            $innerCode = $this->buildClientWrapperCode($client, $verbatimClientCopy, $prefix, $namespace);
+            $innerCode .= "\$client->setDebug(\$debug);\n";
+            $this_ = '';
+        } else {
             // client copy mode 2 == no client copy in emitted code
-            $innercode = '';
+            $innerCode = '';
             $this_ = 'this->';
         }
-        $innercode .= "\$msg = new {$prefix}msg('$methodname');\n";
+        $innerCode .= "\$req = new {$namespace}Request('$methodName');\n";
 
-        if ($mdesc != '')
-        {
+        if ($mDesc != '') {
             // take care that PHP comment is not terminated unwillingly by method description
-            $mdesc = "/**\n* ".str_replace('*/', '* /', $mdesc)."\n";
-        }
-        else
-        {
-            $mdesc = "/**\nFunction $xmlrpcfuncname\n";
+            $mDesc = "/**\n* " . str_replace('*/', '* /', $mDesc) . "\n";
+        } else {
+            $mDesc = "/**\nFunction $newFuncName\n";
         }
 
         // param parsing
+        $innerCode .= "\$encoder = new {$namespace}Encoder();\n";
         $plist = array();
-        $pcount = count($msig);
-        for($i = 1; $i < $pcount; $i++)
-        {
+        $pCount = count($mSig);
+        for ($i = 1; $i < $pCount; $i++) {
             $plist[] = "\$p$i";
-            $ptype = $msig[$i];
-            if($ptype == 'i4' || $ptype == 'int' || $ptype == 'boolean' || $ptype == 'double' ||
-                $ptype == 'string' || $ptype == 'dateTime.iso8601' || $ptype == 'base64' || $ptype == 'null')
-            {
-                // only build directly xmlrpcvals when type is known and scalar
-                $innercode .= "\$p$i = new {$prefix}val(\$p$i, '$ptype');\n";
-            }
-            else
-            {
-                if ($encode_php_objects)
-                {
-                    $innercode .= "\$p$i = php_{$prefix}_encode(\$p$i, array('encode_php_objs'));\n";
-                }
-                else
-                {
-                    $innercode .= "\$p$i = php_{$prefix}_encode(\$p$i);\n";
+            $pType = $mSig[$i];
+            if ($pType == 'i4' || $pType == 'int' || $pType == 'boolean' || $pType == 'double' ||
+                $pType == 'string' || $pType == 'dateTime.iso8601' || $pType == 'base64' || $pType == 'null'
+            ) {
+                // only build directly xmlrpc values when type is known and scalar
+                $innerCode .= "\$p$i = new {$namespace}Value(\$p$i, '$pType');\n";
+            } else {
+                if ($encodePhpObjects) {
+                    $innerCode .= "\$p$i = \$encoder->encode(\$p$i, array('encode_php_objs'));\n";
+                } else {
+                    $innerCode .= "\$p$i = \$encoder->encode(\$p$i);\n";
                 }
             }
-            $innercode .= "\$msg->addparam(\$p$i);\n";
-            $mdesc .= '* @param '.$this->xmlrpc_2_php_type($ptype)." \$p$i\n";
+            $innerCode .= "\$req->addparam(\$p$i);\n";
+            $mDesc .= '* @param ' . $this->xmlrpc2PhpType($pType) . " \$p$i\n";
         }
-        if ($client_copy_mode < 2)
-        {
+        if ($clientCopyMode < 2) {
             $plist[] = '$debug=0';
-            $mdesc .= "* @param int \$debug when 1 (or 2) will enable debugging of the underlying {$prefix} call (defaults to 0)\n";
+            $mDesc .= "* @param int \$debug when 1 (or 2) will enable debugging of the underlying {$prefix} call (defaults to 0)\n";
         }
         $plist = implode(', ', $plist);
-        $mdesc .= '* @return '.$this->xmlrpc_2_php_type($msig[0])." (or an {$prefix}resp obj instance if call fails)\n*/\n";
+        $mDesc .= '* @return ' . $this->xmlrpc2PhpType($mSig[0]) . " (or an {$namespace}Response obj instance if call fails)\n*/\n";
 
-        $innercode .= "\$res = \${$this_}client->send(\$msg, $timeout, '$protocol');\n";
-        if ($decode_fault)
-        {
-            if (is_string($fault_response) && ((strpos($fault_response, '%faultCode%') !== false) || (strpos($fault_response, '%faultString%') !== false)))
-            {
-                $respcode = "str_replace(array('%faultCode%', '%faultString%'), array(\$res->faultCode(), \$res->faultString()), '".str_replace("'", "''", $fault_response)."')";
-            }
-            else
-            {
-                $respcode = var_export($fault_response, true);
+        $innerCode .= "\$res = \${$this_}client->send(\$req, $timeout, '$protocol');\n";
+        if ($decodeFault) {
+            if (is_string($faultResponse) && ((strpos($faultResponse, '%faultCode%') !== false) || (strpos($faultResponse, '%faultString%') !== false))) {
+                $respCode = "str_replace(array('%faultCode%', '%faultString%'), array(\$res->faultCode(), \$res->faultString()), '" . str_replace("'", "''", $faultResponse) . "')";
+            } else {
+                $respCode = var_export($faultResponse, true);
             }
+        } else {
+            $respCode = '$res';
         }
-        else
-        {
-            $respcode = '$res';
-        }
-        if ($decode_php_objects)
-        {
-            $innercode .= "if (\$res->faultcode()) return $respcode; else return php_{$prefix}_decode(\$res->value(), array('decode_php_objs'));";
-        }
-        else
-        {
-            $innercode .= "if (\$res->faultcode()) return $respcode; else return php_{$prefix}_decode(\$res->value());";
+        if ($decodePhpObjects) {
+            $innerCode .= "if (\$res->faultcode()) return $respCode; else return \$encoder->decode(\$res->value(), array('decode_php_objs'));";
+        } else {
+            $innerCode .= "if (\$res->faultcode()) return $respCode; else return \$encoder->decode(\$res->value());";
         }
 
-        $code = $code . $plist. ") {\n" . $innercode . "\n}\n";
+        $code = $code . $plist . ") {\n" . $innerCode . "\n}\n";
 
-        return array('source' => $code, 'docstring' => $mdesc);
+        return array('source' => $code, 'docstring' => $mDesc);
     }
 
     /**
-    * Given necessary info, generate php code that will rebuild a client object
-    * Take care that no full checking of input parameters is done to ensure that
-    * valid php code is emitted.
-    */
-    protected function build_client_wrapper_code($client, $verbatim_client_copy, $prefix='xmlrpc')
+     * Similar to wrapXmlrpcMethod, but will generate a php class that wraps
+     * all xmlrpc methods exposed by the remote server as own methods.
+     * For more details see wrapXmlrpcMethod.
+     *
+     * For a slimmer alternative, see the code in demo/client/proxy.php
+     *
+     * Note that unlike wrapXmlrpcMethod, we always have to generate php code here. It seems that php 7 will have anon classes...
+     *
+     * @param Client $client the client obj all set to query the desired server
+     * @param array $extraOptions list of options for wrapped code. See the ones from wrapXmlrpcMethod plus
+     *              - string method_filter      regular expression
+     *              - string new_class_name
+     *              - string prefix
+     *              - bool   simple_client_copy set it to true to avoid copying all properties of $client into the copy made in the new class
+     *
+     * @return mixed false on error, the name of the created class if all ok or an array with code, class name and comments (if the appropriatevoption is set in extra_options)
+     */
+    public function wrapXmlrpcServer($client, $extraOptions = array())
     {
-        $code = "\$client = new {$prefix}_client('".str_replace("'", "\'", $client->path).
+        $methodFilter = isset($extraOptions['method_filter']) ? $extraOptions['method_filter'] : '';
+        $timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
+        $protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
+        $newClassName = isset($extraOptions['new_class_name']) ? $extraOptions['new_class_name'] : '';
+        $encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
+        $decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
+        $verbatimClientCopy = isset($extraOptions['simple_client_copy']) ? !($extraOptions['simple_client_copy']) : true;
+        $buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
+        $prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
+        $namespace = '\\PhpXmlRpc\\';
+
+        $reqClass = $namespace . 'Request';
+        $decoderClass = $namespace . 'Encoder';
+
+        $req = new $reqClass('system.listMethods');
+        $response = $client->send($req, $timeout, $protocol);
+        if ($response->faultCode()) {
+            error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method list from remote server');
+
+            return false;
+        } else {
+            $mList = $response->value();
+            if ($client->return_type != 'phpvals') {
+                $decoder = new $decoderClass();
+                $mList = $decoder->decode($mList);
+            }
+            if (!is_array($mList) || !count($mList)) {
+                error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve meaningful method list from remote server');
+
+                return false;
+            } else {
+                // pick a suitable name for the new function, avoiding collisions
+                if ($newClassName != '') {
+                    $xmlrpcClassName = $newClassName;
+                } else {
+                    $xmlrpcClassName = $prefix . '_' . preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
+                            array('_', ''), $client->server) . '_client';
+                }
+                while ($buildIt && class_exists($xmlrpcClassName)) {
+                    $xmlrpcClassName .= 'x';
+                }
+
+                /// @todo add function setdebug() to new class, to enable/disable debugging
+                $source = "class $xmlrpcClassName\n{\npublic \$client;\n\n";
+                $source .= "function __construct()\n{\n";
+                $source .= $this->buildClientWrapperCode($client, $verbatimClientCopy, $prefix, $namespace);
+                $source .= "\$this->client = \$client;\n}\n\n";
+                $opts = array(
+                    'return_source' => true,
+                    'simple_client_copy' => 2, // do not produce code to copy the client object
+                    'timeout' => $timeout,
+                    'protocol' => $protocol,
+                    'encode_php_objs' => $encodePhpObjects,
+                    'decode_php_objs' => $decodePhpObjects,
+                    'prefix' => $prefix,
+                );
+                /// @todo build phpdoc for class definition, too
+                foreach ($mList as $mName) {
+                    if ($methodFilter == '' || preg_match($methodFilter, $mName)) {
+                        // note: this will fail if server exposes 2 methods called f.e. do.something and do_something
+                        $opts['new_function_name'] = preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
+                            array('_', ''), $mName);
+                        $methodWrap = $this->wrapXmlrpcMethod($client, $mName, $opts);
+                        if ($methodWrap) {
+                            if (!$buildIt) {
+                                $source .= $methodWrap['docstring'];
+                            }
+                            $source .= $methodWrap['source'] . "\n";
+                        } else {
+                            error_log('XML-RPC: ' . __METHOD__ . ': will not create class method to wrap remote method ' . $mName);
+                        }
+                    }
+                }
+                $source .= "}\n";
+                if ($buildIt) {
+                    $allOK = 0;
+                    eval($source . '$allOK=1;');
+                    if ($allOK) {
+                        return $xmlrpcClassName;
+                    } else {
+                        error_log('XML-RPC: ' . __METHOD__ . ': could not create class ' . $xmlrpcClassName . ' to wrap remote server ' . $client->server);
+                        return false;
+                    }
+                } else {
+                    return array('class' => $xmlrpcClassName, 'code' => $source, 'docstring' => '');
+                }
+            }
+        }
+    }
+
+    /**
+     * Given necessary info, generate php code that will build a client object just like the given one.
+     * Take care that no full checking of input parameters is done to ensure that
+     * valid php code is emitted.
+     * @param Client $client
+     * @param bool $verbatimClientCopy when true, copy all of the state of the client, except for 'debug' and 'return_type'
+     * @param string $prefix used for the return_type of the created client
+     * @param string $namespace
+     *
+     * @return string
+     */
+    protected function buildClientWrapperCode($client, $verbatimClientCopy, $prefix = 'xmlrpc', $namespace = '\\PhpXmlRpc\\' )
+    {
+        $code = "\$client = new {$namespace}Client('" . str_replace("'", "\'", $client->path) .
             "', '" . str_replace("'", "\'", $client->server) . "', $client->port);\n";
 
         // copy all client fields to the client that will be generated runtime
         // (this provides for future expansion or subclassing of client obj)
-        if ($verbatim_client_copy)
-        {
-            foreach($client as $fld => $val)
-            {
-                if($fld != 'debug' && $fld != 'return_type')
-                {
+        if ($verbatimClientCopy) {
+            foreach ($client as $fld => $val) {
+                if ($fld != 'debug' && $fld != 'return_type') {
                     $val = var_export($val, true);
                     $code .= "\$client->$fld = $val;\n";
                 }
@@ -933,5 +1111,4 @@ class Wrapper
         //$code .= "\$client->setDebug(\$debug);\n";
         return $code;
     }
-
-}
\ No newline at end of file
+}