Get an array of all static methods implemented by the current class

Merges trait methods
Filters out this trait

@return array|ReflectionMethod[]
@throws \ReflectionException
17838
public function getStaticMethods(): array
    {
        if (null !== $this->staticMethods) {
            return $this->staticMethods;
        }
        $this->staticMethods = $this->reflectionClass->getMethods(
            \ReflectionMethod::IS_STATIC
        );

        return $this->staticMethods;
    }
1363788
static function all(): array
    {
        $instances = [];

        foreach (static::getMap() as $key => $value) {
            $instances[$key] = self::$instanceCache[static::class][$key]
                ?? (self::$instanceCache[static::class][$key] = new static($key, $value));
        }

        return $instances;
    }
946515
final protected function method():array{
    $arr = [];
    foreach((new \ReflectionClass($this))->getMethods(\ReflectionMethod::IS_PUBLIC) as $m){
      if(strpos($m->name,'__')!==0)
        if($m->class===self::class){
          if(ctype_upper($m->name))
            $arr[$m->name] = $m;
        }
        elseif(ctype_print($m->name))
          $arr[strtoupper($m->name)] = $m;
    }
    return $arr;
  }
654732
public static function toArray()
  {
    $self   = new \ReflectionClass(get_called_class());
    $return = array();
    foreach ($self->getConstants() as $value)
    {
      array_push($return, $value);
    }

    return $return;
  }
1346832
private function getProxyMethods(): array
    {
        if (null !== $this->reflectionProxyMethods) {
            return $this->reflectionProxyMethods;
        }

        $proxyMethods = [];
        $methods = $this->getClassMethods();

        foreach ($methods as $method) {
            $docComment = $method->getDocComment();

            if (\strpos($docComment, 'Transactional') !== false) {
                $annotation = $this->annotationReader->getMethodAnnotation(
                    $method,
                    Transactional::class
                );

                if ($annotation) {
                    $proxyMethods[] = $method;
                }
            }
        }

        $this->reflectionProxyMethods = $proxyMethods;

        return $proxyMethods;
    }
1123281
public function declaredMethods(): array
    {
        $methods = [];
        foreach ($this->getMethods() as $method) {
            if ($method->getDeclaringClass()->getName() != $this->getName()) {
                continue;
            }

            $methods[] = $method;
        }

        return $methods;
    }
933777
public function getMethods()
    {
        if (!$this->__methods) {
            $methods = array();

            $reflection = new ReflectionClass($this);
            foreach ($reflection->getMethods() as $method) {
                $methods[] = $method->name;
            }

            $this->__methods = array_merge($methods, array_keys($this->_mixed_methods));
        }

        return $this->__methods;
    }
333206
public function getMethods()
    {
        return array_reduce(
            $this->_models,
            function ($result, $item) {
                $result[$item['method']] = $item['method'];
                return $result;
            },
            []
        );
    }
156873
static public function getImplementations()
    {
        $list = array();
        foreach ( self::$implementations as $name => $className )
        {
            $list[] = $name;
        }
        return $list;
    }
1047160
public function getAllUpdateMethods() {
    $update_methods = [];
    $methods = get_class_methods($this->updateClassName);
    foreach ($methods as $method_name) {
      $reflectionMethod = new \ReflectionMethod($this->updateClassName, $method_name);
      $annotations = $this->annotationsReader->getMethodAnnotation($reflectionMethod, 'Acquia\Blt\Annotations\Update');
      if ($annotations) {
        $update_methods[$method_name] = $annotations;
      }
    }

    return $update_methods;
  }
950002
public function getMethods()
    {
        if (!$this->__methods)
        {
            $methods = array();
            $object = $this->getDelegate();

            if (!($object instanceof KObjectMixable))
            {
                $reflection = new ReflectionClass($object);
                foreach ($reflection->getMethods() as $method) {
                    $methods[] = $method->name;
                }
            }
            else $methods = $object->getMethods();

            $this->__methods = $methods;
        }

        return $this->__methods;
    }
102750
public static function allKeys()
    {
        static $allKeys = null;

        if (is_null($allKeys)) {
            $allKeys = array_values((new ReflectionClass(get_called_class()))->getConstants());
        }

        return $allKeys;
    }
1206844
public function getMethods()
    {
        if (!$this->__methods) {
            $methods = array();
            $object  = $this->getObject();

            if (!($object instanceof AnObject)) {
                $reflection	= new ReflectionClass($object);
                foreach ($reflection->getMethods() as $method) {
                    $methods[] = $method->name;
                }
            } else {
                $methods = $object->getMethods();
            }

            $this->__methods = array_merge(parent::getMethods(), $methods);
        }

        return $this->__methods;
    }
425210
public function toArray()
    {
        // First, call the trait method before filtering
        // with Entity specific methods
        $attributes = $this->attributesToArray($this->attributes);

        foreach ($this->attributes as $key => $attribute) {
            if (in_array($key, $this->hidden)) {
                unset($attributes[$key]);
                continue;
            }
            if ($this->hasGetMutator($key)) {
                $method = 'get'.$this->getMutatorMethod($key);
                $attributes[$key] = $this->$method($attribute);
            }
        }

        return $attributes;
    }
966596
public function getImplementedInterfaces()
    {
        $result = array();
        foreach ($this->getReflectionClass()->getInterfaces() as $interface)
        {
            $result[] = Type::byReflectionClass($interface);
        }
        return $result;
    }
1345800
public function methods() {
        return $this->cache(__METHOD__, function() {
            return array_unique(array_merge(
                $this->publicMethods(),
                $this->protectedMethods(),
                $this->privateMethods(),
                $this->staticMethods()
            ));
        });
    }
1223520
public function getMethods() {
    $methods = array();
    foreach ($this->methodsOrder as $methodName) {
      $method = $this->methods[$methodName];
      if ($method->getDeclaringClass()->equals($this)) {
        $methods[$method->getName()] = $method;
      }
    }
    return $methods;
  }