Assert that the specified method exists on the class.

@param string $method
@param string $class
@param string $msg

@return void
345901
public static function assertMethodExists(string $method, string $class, string $msg = '')
    {
        if ($msg === '') {
            $msg = "Expected the class '$class' to have method '$method'.";
        }

        static::assertTrue(method_exists($class, $method), $msg);
    }
648016
protected function callOnceBeforeHooks($classInstance, $method, array $args = [])
    {
        $return = $this->callOnceBeforeAllHooks($classInstance, $method, $args);

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

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

        if ($return !== null) {
            return $return;
        }
    }
1163797
protected function trriggerUnusedMethodError ($method) {
		/** @var $this \MvcCore\Ext\Routers\Modules\IRoute */
		$selfClass = version_compare(PHP_VERSION, '5.5', '>') ? self::class : __CLASS__;
		trigger_error("[$selfClass] The method `$method` is not used in this extended class.", E_USER_WARNING);
		return $this;
	}
125026
private function matchExecution(string $class, string $method, array $executions): bool
    {
        foreach ($executions as $execution) {
            $executionAry = \explode('::', $execution);
            if (\count($executionAry) < 2) {
                continue;
            }

            // Class
            list($executionClass, $executionMethod) = $executionAry;
            if ($executionClass !== $class) {
                continue;
            }

            // Method
            $reg = '/^(?:' . $executionMethod . ')$/';
            if (\preg_match($reg, $method)) {
                return true;
            }
        }

        return false;
    }
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),
		]);
	}
822184
static public function instance($class,$method='') {
        $identify   =   $class.$method;
        if(!isset(self::$_instance[$identify])) {
            if(class_exists($class)){
                $o = new $class();
                if(!empty($method) && method_exists($o,$method))
                    self::$_instance[$identify] = call_user_func(array(&$o, $method));
                else
                    self::$_instance[$identify] = $o;
            }
            else
                self::halt(L('_CLASS_NOT_EXIST_').':'.$class);
        }
        return self::$_instance[$identify];
    }
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;
        }
    }
1106966
public function callMethod($class, $method, array $args = array())
    {
        $method = $this->findMethod($class, $method);
        $method->setAccessible(true);

        return $method->invokeArgs(
            is_object($class) ? $class : null,
            $args
        );
    }
314968
public static function hasApplied($class, $method) {
		foreach (static::_ids($class, $method) as $id) {
			if (isset(static::$_filters[$id])) {
				return true;
			}
		}
		return false;
	}
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);
            }
        };
    }
864019
protected function callOnceBeforeAllHooks($classInstance, $method)
    {
        $method = self::getCalledMethod($method);

        $hooks = $this->hooks['once']['beforeAll'];

        if ( ! $this->instanceOnceBeforeAllCalled && $hooks) {

            if ( ! empty($hooks)) {
                $return = $this->callAllHookCallables($classInstance, $method, $hooks);

                $this->instanceOnceBeforeAllCalled = true;

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

        $staticHooks = self::$staticHooks['global']['once']['beforeAll'];

        if ( ! $this->globalOnceBeforeAllCalled && $staticHooks) {
            if ( ! empty($staticHooks)) {
                $return = $this->callAllHookCallables($classInstance, $method, $staticHooks);

                $this->globalOnceBeforeAllCalled = true;

                if ($return !== null) {
                    return $return;
                }
            }
        }
    }
402327
public function setMethod($method)
	{
		parent::setMethod($method);
		$method = strtolower($method);
		if($method == "aes-256-ecb")
		{
			$this->_type = MCRYPT_RIJNDAEL_128;
			$this->_mode = "ecb";
		}
		elseif($method == "aes-256-cbc")
		{
			$this->_type = MCRYPT_RIJNDAEL_128;
			$this->_mode = "cbc";
		}
	}
92834
protected function addMessages($method, array $messages)
    {
        // If there was exactly 1 message, it wasn't put in an array of messages.
        if (array_key_exists('code', $messages)) {
            $messages = array($messages);
        }
        foreach ($messages as $message) {
            call_user_func(array($this, $method), $message);
        }
        return $this;
    }
1257377
public static function isRequest($msg): bool
    {
        return is_object($msg) && property_exists($msg, 'id') && isset($msg->method);
    }
653809
private function checkMethodExists($method)
    {
        if (! $this->controllerClass->hasMethod($method)) {
            throw new MissingControllerMethodException(
                sprintf(
                    "Method %s::%s() is not defined in controller.",
                    $this->controllerClass->getShortName(),
                    $method
                )
            );
        }
    }
8757
protected function classExists(string $class, string $message): void
    {
        if (!class_exists($class)) {
            $this->log($message, Project::MSG_ERR);
            throw new BuildException($message);
        }
    }
458360
public function addMethod(Method $method): void
    {
        $this->methods[(string) $method->getFqsen()] = $method;
    }