Calls object function with given parameters

@param string $functionName
@param array $parameters
@return mixed
171692
public function callFunction($functionName, $parameters)
    {
        if ($functionName == 'getList') {
            $oObject = $this->getObject();
            $mResponse = $this->_formArrayFromList($oObject->getList());
        } else {
            $mResponse = parent::callFunction($functionName, $parameters);
        }

        return $mResponse;
    }
1168787
protected function CreateFunctionCall($functionName, array $params = array(), $alias = '', $distinctParams = false)
    {
        return new FunctionCall($this->connection, $functionName, $params, $alias, $distinctParams);
    }
998726
protected function callScope( callable $scope, $parameters = [] )
	{
		array_unshift( $parameters, $this );

		$query = $this->getQuery();

		// We will keep track of how many wheres are on the query before running the
		// scope so that we can properly group the added scope constraints in the
		// query as their own isolated nested where statement and avoid issues.
		$originalWhereCount = count( $query->wheres );

		$result = call_user_func_array( $scope, $parameters ) ?: $this;

		if ( $this->shouldNestWheresForScope( $query, $originalWhereCount ) )
		{
			$this->nestWheresForScope( $query, $originalWhereCount );
		}

		return $result;
	}
740754
public function callAction($method, $parameters)
    {
        $this->responseArray['type'] = Response::TYPE_CONTENT;
        $this->responseArray['method'] = Request::method();
        $this->responseArray['code'] = Response::NO_ERROR;

        if (isset($this->requiredFields[$method]) and is_array($this->requiredFields[$method])) {
            $this->validateParameters($this->requiredFields[$method]);
        }

        $response = parent::callAction($method, $parameters);

        if ($response instanceof RedirectResponse) {
            $this->responseArray['type'] = Response::TYPE_REDIRECT;
            $this->responseArray['targetUrl'] = $response->getTargetUrl();
            $this->responseArray['code'] = $response->getStatusCode();
        } else {
            if ($response instanceof View) {
                return new JsonResponse($response->render());
            } else {
                if ($response instanceof JsonResponse) {
                    return $response;
                }
            }
        }

        return (new Response(config('app.debug')))->createResponse($this->responseArray);
    }
1218827
public function call($function, array $parameters = [])
    {
        $inspector = new ReflectionFunction($function);

        $dependencies = $inspector->getParameters();
        $dependencies = $this->process('', $parameters, $dependencies);

        return call_user_func_array($function, $dependencies);
    }
1216996
private function exists($className, $functionName)
    {
        return
            function_exists($this->getFullFunctionName($className, $functionName))
            || method_exists($className, $functionName);
    }
269925
public function invokeMethod(&$object, $methodName, array $parameters = [])
    {
        $method = $this->getMethodInstance($object, $methodName);
        $method->setAccessible(true);

        return $method->invokeArgs($object, $parameters);
    }
322590
public function call($callback, array $parameters = array())
    {
        $this->events[] = $event = new CallbackEvent($this->mutex, $callback, $parameters);

        return $event;
    }
545551
public function call($command, array $parameters = [])
    {
        array_unshift($parameters, $command);

        $this->lastOutput = new BufferedOutput;

        $this->setCatchExceptions(false);

        $result = $this->run(new ArrayInput($parameters), $this->lastOutput);

        $this->setCatchExceptions(true);

        return $result;
    }
1146458
public function build($functionName)
    {
        if (!function_exists($functionName)) {
            return;
        }
        $function            = new \ReflectionFunction($functionName);
        $signatureParameters = [];
        $bodyParameters      = [];
        foreach ($function->getParameters() as $reflectionParameter) {
            if ($this->isVariadic($reflectionParameter)) {
                break;
            }
            $parameter = $reflectionParameter->isPassedByReference()
                ? "&$$reflectionParameter->name"
                : "$$reflectionParameter->name";
            
            $signatureParameter = $reflectionParameter->isOptional()
                ? sprintf("%s = '%s'", $parameter, MockFunctionGenerator::DEFAULT_ARGUMENT)
                : $parameter;

            $signatureParameters[] = $signatureParameter;
            $bodyParameters[]      = $parameter;
        }
        $this->signatureParameters = implode(", ", $signatureParameters);
        $this->bodyParameters      = implode(", ", $bodyParameters);
    }
797909
protected function call_closure( $closure, array $parameters = [] ) {
		if ( $closure instanceof Closure ) {
			$rc      = new ReflectionFunction( $closure );
			$args    = $rc->getParameters();
		} else if ( $closure instanceof ReflectionClass ) {
			$rc = $closure;

			if ( $constructor = $rc->getConstructor() ) {
				$args = $constructor->getParameters();
			} else {
				$args = [];
			}

			$closure = function () use ( $rc ) {
				return $rc->newInstanceArgs( func_get_args() );
			};
		}

		if ( $closure instanceof Closure === false ) {
			return $closure;
		}

		$args    = is_array( $args ) ? $args : [];
		$params  = $parameters;
		$classes = [
			$this->get_class_prefix( get_class( $this ) ),
			get_class( $this ),
			get_parent_class( $this )
		];

		foreach ( (array) $args as $index => $arg ) {
			if ( $arg->getClass() === null ) {
				continue;
			}

			if ( in_array( $arg->getClass()->name, $classes, true ) ) {
				$parameters[$index] = $this;
			} else if ( $this->bound( $arg->getClass()->name ) ) {
				$parameters[$index] = $this->make( $arg->getClass()->name );
			}
		}

		if ( ! empty( $args ) && empty( $parameters ) ) {
			$parameters[0] = $this;
		}

		if ( count( $args ) > count( $parameters ) ) {
			$parameters = array_merge( $parameters, $params );
		}

		return $this->call_closure( call_user_func_array( $closure, $parameters ), $parameters );
	}
1290792
public function call($command, array $parameters = [])
    {
        $this->bootstrap();

        return $this->getArtisan()->call($command, $parameters);
    }
919462
function FunctionCall($functionName, array $params = array(), $alias = '', $distinctParams = false)
    {
        return parent::CreateFunctionCall($functionName, $params, $alias, $distinctParams);
    }
1353708
public function call($callback, array $parameters = array(), $defaultMethod = null)
    {
        if ($this->isCallableWithAtSign($callback) || $defaultMethod) {
            return $this->callClass($callback, $parameters, $defaultMethod);
        }

        $dependencies = $this->getMethodDependencies($callback, $parameters);

        return call_user_func_array($callback, $dependencies);
    }
568343
public function call($callback, array $parameters = [])
    {
        switch (count($parameters)) {
            case 0:
                return call_user_func($callback);
            case 1:
                return call_user_func($callback, $parameters[0]);
            case 2:
                return call_user_func($callback, $parameters[0], $parameters[1]);
            case 3:
                return call_user_func($callback, $parameters[0], $parameters[1], $parameters[2]);
            case 4:
                return call_user_func($callback, $parameters[0], $parameters[1], $parameters[2], $parameters[3]);
        }

        return call_user_func_array($callback, $parameters);
    }
1233696
private function setOptionArrays(array $arrays, $functionName)
    {
        if (count($arrays) && !$this->options) {
            $this->options = $arrays[0] instanceof ArrayObject ? $arrays[0] : new ArrayObject($arrays[0]);
        }

        $options = $this->getOptions();
        foreach ($this->filterTraversable($arrays) as $array) {
            foreach ($array as $key => $value) {
                $this->withVariableReference($options, $key, function (&$base, $name) use ($functionName, $value) {
                    $base[$name] = isset($base[$name]) && is_array($base[$name]) && is_array($value)
                        ? $functionName($base[$name], $value)
                        : $value;
                });
            }
        }

        return $this;
    }
113258
function isParameterArray( $functionName, $parameterName )
    {
        if ( isset( $this->FunctionList[$functionName]['parameters'] ) )
        {
            $parameterList = $this->FunctionList[$functionName]['parameters'];
            foreach ( $parameterList as $parameter )
            {
                if ( $parameter['name'] == $parameterName )
                {
                    if ( $parameter['type'] == 'array' )
                    {
                        return true;
                    }
                    return false;
                }
            }
        }
        return false;
    }