Call the queue method on the handler class.

@param  string  $class
@param  string  $method
@param  array  $arguments
@return void
438173
protected function callQueueMethodOnHandler($class, $method, $arguments)
	{
		$handler = (new ReflectionClass($class))->newInstanceWithoutConstructor();

		$handler->queue($this->resolveQueue(), 'Illuminate\Events\CallQueuedHandler@call', [
			'class' => $class, 'method' => $method, 'data' => serialize($arguments),
		]);
	}
1367621
private function call($method, array $args)
    {
        $request = $this->rpcProtocol->encodeRequest($method, $args);

        $response = $this->transport->request($request);

        $response = $this->rpcProtocol->decodeValue($response);

        if ($response instanceof \Exception) {
            throw $response;
        }

        return $response;
    }
1112762
protected function call($method, $args)
    {
        $method = str_replace("_", ".", $method);
        $request = new $this->requestClass($this->apiKey, $method, $args, $this->secure);
        return $request->execute();
    }
1226188
protected function executeCallback($class, $method, $args, Closure $closure)
    {
        $skipUri = $this->getContainer('config')->get('rinvex.repository.cache.skip_uri');

        // Check if cache is enabled
        if ($this->getCacheLifetime() && ! $this->getContainer('request')->has($skipUri)) {
            return $this->cacheCallback($class, $method, $args, $closure);
        }

        // Cache disabled, just execute qurey & return result
        $result = call_user_func($closure);

        // We're done, let's clean up!
        $this->resetRepository();

        return $result;
    }
333756
public static function __callstatic($method, $arguments)
	{
		$content = count($arguments) ? $arguments[0] : null;
		return self::createSub($method, $content);
	}
165247
protected function callOnceBeforeMethodHooks($classInstance, $method, array $args = [])
    {
        $method = self::getCalledMethod($method);

        $onceBeforeMethodName = 'onceBefore'.ucfirst($method);
        if ( ! isset($this->instanceOnceCalledMethods['before'][$onceBeforeMethodName])) {
            if (isset($this->hooks[$onceBeforeMethodName])) {
                foreach ($this->hooks[$onceBeforeMethodName] as $callable) {
                    try {
                        $return = $this->callCallable($classInstance, $callable, $args, $method, false);
                    } catch (CancelPropagationException $e) {
                        break;
                    }

                    if ($return !== null) {
                        return $return;
                    }
                }

                $this->instanceOnceCalledMethods['before'][$onceBeforeMethodName] = true;
            }
        }

        $return = $this->callGlobalOnceBeforeMethodHooks($classInstance, $method, $onceBeforeMethodName);

        if ($return !== null) {
            return $return;
        }
    }
979779
public function handle(string $method, array $arguments)
    {
        $upMethod = strtoupper($method);
        $context  = array_shift($arguments);

        if (in_array($upMethod, self::$asynCommand)) {
            $sql = '';
            if ($upMethod == 'GO') {
                if (!empty($arguments[1])) {
                    $sql = trim($arguments[1]);
                } else {
                    $sql = $this->getDBQueryBuilder($context)->getStatement(false);
                }
            }

            if (!empty($sql) && empty($arguments[0]) && !empty($this->slaves)) {
                if (stripos($sql, 'SELECT') === 0 || stripos($sql, 'SHOW') === 0) {
                    $rand     = array_rand($this->slaves);
                    $poolName = $this->slaves[$rand];
                } else {
                    $poolName = $this->master;
                }
            } else {
                $poolName = $this->master;
            }

            $pool = getInstance()->getAsynPool($poolName);
            if ($pool == null) {
                throw new Exception("mysql pool $poolName not register!");
            }
            $this->getDBQueryBuilder($context)->mysqlPool = $pool;
            if (method_exists($this->getDBQueryBuilder(), $method)) {
                return $this->getDBQueryBuilder($context)->{$method}(...$arguments);
            } else {
                array_push($arguments, $context);
                return $this->getDBQueryBuilder($context)->mysqlPool->{$method}(...$arguments);
            }
        }

        $this->getDBQueryBuilder($context)->{$method}(...$arguments);

        return $this->__wrapper;
    }
1166742
protected function handle_request( $method, $request_method, array $arguments = [] ) {
		if ( empty( $method ) || 'page' === $method ) {
			$page = max( ( isset( $arguments[0] ) ? intval( $arguments[0] ) : 1 ), 1 );
			$this->pager( $page );
			exit;
		} else {
			// Call method if exists.
			if ( $this->invoke( $method, $request_method, $arguments ) ) {
				exit;
			} else {
				$this->method_not_found();
			}
		}
	}
1270570
private function executeMethod($method, $args = [])
    {
        if (method_exists($this, $method)) {
            return call_user_func_array([$this, $method], $args);
        }
    }
624998
protected function doRun($method, array $args=[]) {
		ob_start();
		$result = call_user_func_array($method, array_merge([$this], $args));
		$controllerBuffer =  ob_get_clean();

		if($result !== null)
			return $result;
		if($controllerBuffer)
			return $controllerBuffer;
		return null;
	}
780347
protected function createQueuedHandlerCallable($class, $method)
    {
        return function () use ($class, $method) {
            $arguments = array_map(function ($a) {
                return is_object($a) ? clone $a : $a;
            }, func_get_args());

            if (method_exists($class, 'queue')) {
                $this->callQueueMethodOnHandler($class, $method, $arguments);
            } else {
                $this->queueHandler($class, $method, $arguments);
            }
        };
    }
440091
protected function callBeforeHooks($classInstance, $method, array $args = [])
    {
        $return = $this->callBeforeAllHooks($classInstance, $method);

        if ($return !== null) {
            return $return;
        }

        $return = $this->callBeforeMethodHooks($classInstance, $method, $args);

        if ($return !== null) {
            return $return;
        }

        $return = $this->callOnceBeforeHooks($classInstance, $method, $args);

        if ($return !== null) {
            return $return;
        }
    }
1076192
public function call($class, $method, &$a = null, &$b = null, &$c = null, &$d = null, &$e = null)
    {
        if (!is_callable(array($class, $method))) {
            return false;
        }

        try {
            $instance = Container::get($class);
            $instance->{$method}($a, $b, $c, $d, $e);
            $this->called[$method][$class] = array($class, $method);
            return array($a, $b, $c, $d, $e);
        } catch (Exception $exc) {
            return false;
        }
    }
287220
protected function createQueuedHandlerCallable($class, $method)
    {
        return function () use ($class, $method) {
            $arguments = array_map(function ($a) {
                return is_object($a) ? clone $a : $a;
            }, func_get_args());

            if ($this->handlerWantsToBeQueued($class, $arguments)) {
                $this->queueHandler($class, $method, $arguments);
            }
        };
    }
215324
protected function fireWebSocketHandler($handler, $method, ...$arguments)
    {
        if ($handler == null) {
            return;
        }

        try {
            call_user_func([$handler, $method], ...$arguments);
        } catch (Exception $e) {
            $this->reportException($e);
        } catch (Throwable $e) {
            $this->reportException(new FatalThrowableError($e));
        }
    }
69642
public function callMethod($method, $args)
	{
		$methodDetails = isset($this->methods[$method]) ? $this->methods[$method] : null;
		if (!$methodDetails) {
			throw new Exception("$method does not have an appropriate mapping");
		}

		$body = null;

		// use the method params to try caching the results
		// need to add in the baseUrl we're connecting to, and any global params
		// because the cache might be connecting via different users, and the
		// different users will have different sessions. This might need to be
		// tweaked to handle separate user logins at a later point in time
		$uri = $this->baseUrl . (isset($methodDetails['url']) ? $methodDetails['url'] : '');
		// 	check for any replacements that are required
		if (preg_match_all('/{(\w+)}/', $uri, $matches)) {
			foreach ($matches[1] as $match) {
				if (isset($args[$match])) {
					$uri = str_replace('{'.$match.'}', $args[$match], $uri);
				}
			}
		}

		$cacheKey = md5($uri . $method . var_export($args, true) . var_export($this->globalParams, true));

		$requestType = isset($methodDetails['method']) ? $methodDetails['method'] : 'GET';
		$cache = isset($methodDetails['cache']) ? $methodDetails['cache'] : self::$cache_length;
		if (mb_strtolower($requestType) == 'get' && $cache) {
			$body = CacheService::inst()->get($cacheKey);
		}

		if (!$body) {


			// Note that case is important! Some servers won't respond correctly
			// to get or Get requests
			$requestType = isset($methodDetails['method']) ? $methodDetails['method'] : 'GET';

			$client = $this->getClient($uri);
			$client->setMethod($requestType);

			// set the encoding type
			$client->setEncType(isset($methodDetails['enctype']) ? $methodDetails['enctype'] : Zend_Http_Client::ENC_URLENCODED);

			$paramMethod = $requestType == 'GET' ? 'setParameterGet' : 'setParameterPost';
			if ($this->globalParams) {
				foreach ($this->globalParams as $key => $value) {
					$client->$paramMethod($key, $value);
				}
			}

			if (isset($methodDetails['params'])) {
				$paramNames = $methodDetails['params'];
				foreach ($paramNames as $index => $pname) {

					if (isset($args[$pname])) {
						$client->$paramMethod($pname, $args[$pname]);
					} else if (isset($args[$index])) {
						$client->$paramMethod($pname, $args[$index]);
					}
				}
			}

			if (isset($methodDetails['get'])) {
				foreach ($methodDetails['get'] as $k => $v) {
					$client->setParameterGet($k, $v);
				}
			}

			if (isset($methodDetails['post'])) {
				foreach ($methodDetails['post'] as $k => $v) {
					$client->setParameterPost($k, $v);
				}
			}

			if (isset($methodDetails['raw']) && $methodDetails['raw']) {
				$client->setRawData($args['raw_body']);
			}

			// request away
			$response = $client->request();

			if ($response->isSuccessful()) {
				$body = $response->getBody();
				if ($cache) {
					CacheService::inst()->store($cacheKey, $body, $cache);
				}
			} else {
				if ($response->getStatus() == 500) {
					error_log("Failure: ".$response->getBody());
					error_log(var_export($client, true));
				}
				throw new FailedRequestException("Failed executing $method: ".$response->getMessage()." for request to $uri (".$client->getUri(true).')', $response->getBody());
			}
		}

		$returnType = isset($methodDetails['return']) ? $methodDetails['return'] : 'raw';

		// see what we need to do with it
		if (isset($this->returnHandlers[$returnType])) {
			$handler = $this->returnHandlers[$returnType];
			return $handler->handleReturn($body);
		} else {
			return $body;
		}
	}
1236026
public function call(string $method, array $arguments): ResponseInterface
    {
        try {
            return $this->__soapCall($method, $arguments, null, $this->getHeader());
        } catch (\Exception $e) {
            $exception = new ClientException($e->getMessage(), $e->getCode(), $e);

            if ($this->debug) {
                $exception->request = ClientException::formatXml($this->__getLastRequest());
                $exception->response = ClientException::formatXml($this->__getLastResponse());
            }

            throw $exception;
        }
    }