Zend_Server_Reflection_Function_Abstract Class Reference

Inheritance diagram for Zend_Server_Reflection_Function_Abstract:

Public Member Functions
	__construct (Reflector $r, $namespace=null, $argv=array())
	__call ($method, $args)
	__get ($key)
	__set ($key, $value)
	setNamespace ($namespace)
	getNamespace ()
	setDescription ($string)
	getDescription ()
	getPrototypes ()
	getInvokeArguments ()
	__wakeup ()

Protected Member Functions
	_addTree (Zend_Server_Reflection_Node $parent, $level=0)
	_buildTree ()
	_buildSignatures ($return, $returnDesc, $paramTypes, $paramDesc)
	_reflect ()

Protected Attributes
	$_reflection
	$_argv = array()
	$_config = array()
	$_class
	$_description = ''
	$_namespace
	$_prototypes = array()

Detailed Description

Definition at line 53 of file Abstract.php.

Constructor & Destructor Documentation

__construct()

__construct	(	Reflector	$r,
			$namespace = null,
			$argv = array()
	)

Constructor

Parameters

ReflectionFunction

$r

Definition at line 110 of file Abstract.php.

    {
        // In PHP 5.1.x, ReflectionMethod extends ReflectionFunction. In 5.2.x,
        // both extend ReflectionFunctionAbstract. So, we can't do normal type
        // hinting in the prototype, but instead need to do some explicit
        // testing here.
        if ((!$r instanceof ReflectionFunction)
            && (!$r instanceof ReflectionMethod)) {
            #require_once 'Zend/Server/Reflection/Exception.php';
            throw new Zend_Server_Reflection_Exception('Invalid reflection class');
        }
        $this->_reflection = $r;

        // Determine namespace
        if (null !== $namespace){
            $this->setNamespace($namespace);
        }

        // Determine arguments
        if (is_array($argv)) {
            $this->_argv = $argv;
        }

        // If method call, need to store some info on the class
        if ($r instanceof ReflectionMethod) {
            $this->_class = $r->getDeclaringClass()->getName();
        }

        // Perform some introspection
        $this->_reflect();
    }

Member Function Documentation

__call()

__call	(		$method,
			$args
	)

Proxy reflection calls

Parameters

string	$method
array	$args

Returns

mixed

Definition at line 377 of file Abstract.php.

    {
        if (method_exists($this->_reflection, $method)) {
            return call_user_func_array(array($this->_reflection, $method), $args);
        }

        #require_once 'Zend/Server/Reflection/Exception.php';
        throw new Zend_Server_Reflection_Exception('Invalid reflection method ("' .$method. '")');
    }

__get()

__get

(

$key

)

Retrieve configuration parameters

Values are retrieved by key from $_config. Returns null if no value found.

Parameters

string

$key

Returns

mixed

Definition at line 396 of file Abstract.php.

    {
        if (isset($this->_config[$key])) {
            return $this->_config[$key];
        }

        return null;
    }

__set()

__set	(		$key,
			$value
	)

Set configuration parameters

Values are stored by $key in $_config.

Parameters

string	$key
mixed	$value

Returns

void

Definition at line 414 of file Abstract.php.

    {
        $this->_config[$key] = $value;
    }

__wakeup()

__wakeup

(

)

Wakeup from serialization

Reflection needs explicit instantiation to work correctly. Re-instantiate reflection object on wakeup.

Returns

void

Definition at line 505 of file Abstract.php.

    {
        if ($this->_reflection instanceof ReflectionMethod) {
            $class = new ReflectionClass($this->_class);
            $this->_reflection = new ReflectionMethod($class->newInstance(), $this->getName());
        } else {
            $this->_reflection = new ReflectionFunction($this->getName());
        }
    }

_addTree()

_addTree ( Zend_Server_Reflection_Node  $parent,   $level = 0  )

protected

Create signature node tree

Recursive method to build the signature node tree. Increments through each array in $_sigParams, adding every value of the next level to the current value (unless the current value is null).

Parameters

Zend_Server_Reflection_Node	$parent
int	$level

Returns

void

Definition at line 153 of file Abstract.php.

    {
        if ($level >= $this->_sigParamsDepth) {
            return;
        }

        foreach ($this->_sigParams[$level] as $value) {
            $node = new Zend_Server_Reflection_Node($value, $parent);
            if ((null !== $value) && ($this->_sigParamsDepth > $level + 1)) {
                $this->_addTree($node, $level + 1);
            }
        }
    }

_buildSignatures()

_buildSignatures (   $return,   $returnDesc,   $paramTypes,   $paramDesc  )

protected

Build method signatures

Builds method signatures using the array of return types and the array of parameters types

Parameters

array	$return	Array of return types
string	$returnDesc	Return value description
array	$params	Array of arguments (each an array of types)
array	$paramDesc	Array of parameter descriptions

Returns

array

Definition at line 200 of file Abstract.php.

    {
        $this->_return         = $return;
        $this->_returnDesc     = $returnDesc;
        $this->_paramDesc      = $paramDesc;
        $this->_sigParams      = $paramTypes;
        $this->_sigParamsDepth = count($paramTypes);
        $signatureTrees        = $this->_buildTree();
        $signatures            = array();

        $endPoints = array();
        foreach ($signatureTrees as $root) {
            $tmp = $root->getEndPoints();
            if (empty($tmp)) {
                $endPoints = array_merge($endPoints, array($root));
            } else {
                $endPoints = array_merge($endPoints, $tmp);
            }
        }

        foreach ($endPoints as $node) {
            if (!$node instanceof Zend_Server_Reflection_Node) {
                continue;
            }

            $signature = array();
            do {
                array_unshift($signature, $node->getValue());
                $node = $node->getParent();
            } while ($node instanceof Zend_Server_Reflection_Node);

            $signatures[] = $signature;
        }

        // Build prototypes
        $params = $this->_reflection->getParameters();
        foreach ($signatures as $signature) {
            $return = new Zend_Server_Reflection_ReturnValue(array_shift($signature), $this->_returnDesc);
            $tmp    = array();
            foreach ($signature as $key => $type) {
                $param = new Zend_Server_Reflection_Parameter($params[$key], $type, (isset($this->_paramDesc[$key]) ? $this->_paramDesc[$key] : null));
                $param->setPosition($key);
                $tmp[] = $param;
            }

            $this->_prototypes[] = new Zend_Server_Reflection_Prototype($return, $tmp);
        }
    }

_buildTree()

_buildTree ( )

protected

Build the signature tree

Builds a signature tree starting at the return values and descending through each method argument. Returns an array of Zend_Server_Reflection_Nodes.

Returns

array

Definition at line 176 of file Abstract.php.

    {
        $returnTree = array();
        foreach ((array) $this->_return as $value) {
            $node = new Zend_Server_Reflection_Node($value);
            $this->_addTree($node);
            $returnTree[] = $node;
        }

        return $returnTree;
    }

_reflect()

_reflect ( )

protected

Use code reflection to create method signatures

Determines the method help/description text from the function DocBlock comment. Determines method signatures using a combination of ReflectionFunction and parsing of DocBlock

Parameters

and

Returns

values.

Parameters

ReflectionFunction

$function

Returns

array

Definition at line 259 of file Abstract.php.

    {
        $function           = $this->_reflection;
        $helpText           = '';
        $signatures         = array();
        $returnDesc         = '';
        $paramCount         = $function->getNumberOfParameters();
        $paramCountRequired = $function->getNumberOfRequiredParameters();
        $parameters         = $function->getParameters();
        $docBlock           = $function->getDocComment();

        if (!empty($docBlock)) {
            // Get help text
            if (preg_match(':/\*\*\s*\r?\n\s*\*\s(.*?)\r?\n\s*\*(\s@|/):s', $docBlock, $matches))
            {
                $helpText = $matches[1];
                $helpText = preg_replace('/(^\s*\*\s)/m', '', $helpText);
                $helpText = preg_replace('/\r?\n\s*\*\s*(\r?\n)*/s', "\n", $helpText);
                $helpText = trim($helpText);
            }

            // Get return type(s) and description
            $return     = 'void';
            if (preg_match('/@return\s+(\S+)/', $docBlock, $matches)) {
                $return = explode('|', $matches[1]);
                if (preg_match('/@return\s+\S+\s+(.*?)(@|\*\/)/s', $docBlock, $matches))
                {
                    $value = $matches[1];
                    $value = preg_replace('/\s?\*\s/m', '', $value);
                    $value = preg_replace('/\s{2,}/', ' ', $value);
                    $returnDesc = trim($value);
                }
            }

            // Get param types and description
            if (preg_match_all('/@param\s+([^\s]+)/m', $docBlock, $matches)) {
                $paramTypesTmp = $matches[1];
                if (preg_match_all('/@param\s+\S+\s+(\$\S+)\s+(.*?)(?=@|\*\/)/s', $docBlock, $matches))
                {
                    $paramDesc = $matches[2];
                    foreach ($paramDesc as $key => $value) {
                        $value = preg_replace('/\s?\*\s/m', '', $value);
                        $value = preg_replace('/\s{2,}/', ' ', $value);
                        $paramDesc[$key] = trim($value);
                    }
                }
            }
        } else {
            $helpText = $function->getName();
            $return   = 'void';

            // Try and auto-determine type, based on reflection
            $paramTypesTmp = array();
            foreach ($parameters as $i => $param) {
                $paramType = 'mixed';
                if ($param->isArray()) {
                    $paramType = 'array';
                }
                $paramTypesTmp[$i] = $paramType;
            }
        }

        // Set method description
        $this->setDescription($helpText);

        // Get all param types as arrays
        if (!isset($paramTypesTmp) && (0 < $paramCount)) {
            $paramTypesTmp = array_fill(0, $paramCount, 'mixed');
        } elseif (!isset($paramTypesTmp)) {
            $paramTypesTmp = array();
        } elseif (count($paramTypesTmp) < $paramCount) {
            $start = $paramCount - count($paramTypesTmp);
            for ($i = $start; $i < $paramCount; ++$i) {
                $paramTypesTmp[$i] = 'mixed';
            }
        }

        // Get all param descriptions as arrays
        if (!isset($paramDesc) && (0 < $paramCount)) {
            $paramDesc = array_fill(0, $paramCount, '');
        } elseif (!isset($paramDesc)) {
            $paramDesc = array();
        } elseif (count($paramDesc) < $paramCount) {
            $start = $paramCount - count($paramDesc);
            for ($i = $start; $i < $paramCount; ++$i) {
                $paramDesc[$i] = '';
            }
        }

        if (count($paramTypesTmp) != $paramCount) {
            #require_once 'Zend/Server/Reflection/Exception.php';
            throw new Zend_Server_Reflection_Exception(
               'Variable number of arguments is not supported for services (except optional parameters). '
             . 'Number of function arguments in ' . $function->getDeclaringClass()->getName() . '::'
             . $function->getName() . '() must correspond to actual number of arguments described in the '
             . 'docblock.');
        }

        $paramTypes = array();
        foreach ($paramTypesTmp as $i => $param) {
            $tmp = explode('|', $param);
            if ($parameters[$i]->isOptional()) {
                array_unshift($tmp, null);
            }
            $paramTypes[] = $tmp;
        }

        $this->_buildSignatures($return, $returnDesc, $paramTypes, $paramDesc);
    }

getDescription()

getDescription

(

)

Retrieve the description

Returns

void

Definition at line 471 of file Abstract.php.

    {
        return $this->_description;
    }

getInvokeArguments()

getInvokeArguments

(

)

Retrieve additional invocation arguments

Returns

array

Definition at line 492 of file Abstract.php.

    {
        return $this->_argv;
    }

getNamespace()

getNamespace

(

)

Return method's namespace

Returns

string

Definition at line 445 of file Abstract.php.

    {
        return $this->_namespace;
    }

getPrototypes()

getPrototypes

(

)

Retrieve all prototypes as array of Zend_Server_Reflection_Prototypes

Returns

array

Definition at line 482 of file Abstract.php.

    {
        return $this->_prototypes;
    }

setDescription()

setDescription

(

$string

)

Set the description

Parameters

string

$string

Returns

void

Definition at line 456 of file Abstract.php.

    {
        if (!is_string($string)) {
            #require_once 'Zend/Server/Reflection/Exception.php';
            throw new Zend_Server_Reflection_Exception('Invalid description');
        }

        $this->_description = $string;
    }

setNamespace()

setNamespace

(

$namespace

)

Set method's namespace

Parameters

string

$namespace

Returns

void

Definition at line 425 of file Abstract.php.

    {
        if (empty($namespace)) {
            $this->_namespace = '';
            return;
        }

        if (!is_string($namespace) || !preg_match('/[a-z0-9_\.]+/i', $namespace)) {
            #require_once 'Zend/Server/Reflection/Exception.php';
            throw new Zend_Server_Reflection_Exception('Invalid namespace');
        }

        $this->_namespace = $namespace;
    }

Field Documentation

$_argv

$_argv = array()

protected

Definition at line 64 of file Abstract.php.

$_class

$_class

protected

Definition at line 79 of file Abstract.php.

$_config

$_config = array()

protected

Definition at line 73 of file Abstract.php.

$_description

$_description = ''

protected

Definition at line 85 of file Abstract.php.

$_namespace

$_namespace

protected

Definition at line 91 of file Abstract.php.

$_prototypes

$_prototypes = array()

protected

Definition at line 97 of file Abstract.php.

$_reflection

$_reflection

protected

Definition at line 58 of file Abstract.php.

---

The documentation for this class was generated from the following file:

• vendor/magento/zendframework1/library/Zend/Server/Reflection/Function/Abstract.php