Returns if the given method is implemented by one of the decorators.

@param string $name Method name.

@return bool
430405
public function providesMethod($name)
    {
        if (method_exists($this, $name)) {
            return true;
        }
        if ($this->text instanceof Generic) {
            return $this->text->providesMethod($name);
        }
        return false;
    }
571845
public function isMethodProtected($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return (isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_VISIBILITY]) && $this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName][self::DATA_METHOD_VISIBILITY] === self::VISIBILITY_PROTECTED);
    }
1058039
protected function _isMethodExists($method)
    {
        if ( $return = method_exists($this, $method) ) {
            ## it must be exists also be public accessible
            $ref    = $this->_newReflection();
            $ref    = $ref->getMethod($method);
            $return = $ref->isPublic();
        }

        return $return;
    }
810977
public function & getMethod( $name )
	{
		if( isset( $this->methods[$name] ) )
			return $this->methods[$name];
		throw new RuntimeException( "Method '$name' is unknown" );
	}
954203
public function __isset($name) 
    {
        $getter = 'get' . $name;
        if (method_exists($this, $getter)) {
            return $this->$getter() !== null;
        }
        
        $name = strtolower($name);
        
        return array_key_exists($name, $this->attrs);
    }
1076365
public function hasMethod($methodName)
    {
        return \method_exists($this, $methodName) || \method_exists($this, $this->public_function_prefix . $methodName);
    }
1031775
public static function hasBehavior($name) {
		static::_initializeBehaviors();

		try {
			list($model, $class) = static::_classesForBehavior($name);
		} catch (Exception $e) {
			return false;
		}
		return isset(static::$_behaviors[$model][$class]);
	}
721242
public function hasPublicMethod(string $method)
    {
        if(! method_exists($this, $method)) return false;

        $reflection = new \ReflectionMethod($this, $method);
        if(! $reflection->isPublic()) return false;

        return true;
    }
682636
public function isValid($name)
    {
        if (parent::isValid($name)) {
            return true;
        }
        if (is_array($name)) {
            list($cls, $method) = $name;
            if (is_object($cls)) {
                return false; // No need to convert
            }
            if (is_array($method)) {
                return true; // Need to convert
            }
        } elseif (is_string($name) && strpos($name, '::') > 0) {
            list($cls, $method) = explode('::', $name);
        } else {
            return false; // Can't handle this, maybe already callable
        }

        /** @deprecated Deprecated since 3.3, to be removed in 4.0. */
        if (isset($this->classmap[$cls])) {
            return true; // Will use service definition
        }
        if (!class_exists($cls) || !method_exists($cls, $method)) {
            return false; // Can't handle this
        }
        $refMethod = new \ReflectionMethod($cls, $method);
        if ($refMethod->isStatic()) {
            return false; // Already valid
        }
        $constructor = $refMethod->getDeclaringClass()->getConstructor();
        // We can create the class if no constructor params, else can't handle it
        return $constructor === null || $constructor->getNumberOfRequiredParameters() === 0;
    }
1213534
public function hasMethod($name)
    {
        return method_exists($this, $name)
            || (isset($this->_hookTrait) && $this->hookHasCallbacks('method-'.$name))
            || $this->hasGlobalMethod($name);
    }
598794
public function hasCache($name)
    {
        if (isset($this->_caches[$name])
            || $this->hasCacheTemplate($name)
        ) {
            return true;
        }
        return false;
    }
917675
public static function isSingleton($name)
    {
        if (!static::exists($name)) {
            return false;
        }
        if (empty(static::$classNames[$name]['singleton']) &&
            empty(static::$classAliases[$name]['singleton'])
        ) {
            return false;
        }

        return true;
    }
655979
public function hasLogger($name)
    {
        return isset($this->channels[$name]) && ($this->channels[$name] instanceof Logger);
    }
623036
public function getMethod($name)
    {
        return (isset($this->_methods[$name])) ? $this->_methods[$name] : null;
    }
179502
public function hasMethod($name)
    {
        return method_exists($this, $name)
            || isset($this->hooks['method-'.$name])
            || isset($this->app->hooks['global-method-'.$name]);
    }
437511
public function __isset($name)
    {
        if (is_object($this->value)) {
            return isset($this->value->{$name});
        }

        if (is_array($this->value) || $this->value instanceof ArrayObject) {
            return isset($this->value[$name]);
        }

        return false;
    }
118837
public function isSupportedMethod($method) {
        if (!is_string($method)) throw new IllegalTypeException('Illegal type of parameter $method: '.gettype($method));
        return isset($this->methods[strtoupper($method)]);
    }