Pluck all sorters from class methods.

@return array
765584
public static function listOrderByKeys()
    {
        $classMethods = get_class_methods(get_class());
        $calledClassMethods = get_class_methods(get_called_class());

        $filteredMethods = array_filter(
            $calledClassMethods, function ($calledClassMethod) use ($classMethods) {
                return !in_array($calledClassMethod, $classMethods, true);
            }
        );

        $list = [];
        foreach ($filteredMethods as $k => $v) {
            $list[$v] = $v;
        }

        return $list;
    }
14687
public function getErrors(): array {
        $result = [];
        foreach ($this->getRawErrors() as $field => $error) {
            $result[] = $this->pluckError(['field' => $field] + $error);
        }
        return $result;
    }
227064
public function getMethods()
    {
        $behaviors = $this->getRepository()->getBehaviors();

        foreach ($behaviors as $behavior) {
            $this->mixin($behavior);
        }

        return parent::getMethods();
    }
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;
    }
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;
  }
980056
final protected function method():array{
    $arr = [];
    foreach((new \ReflectionClass($this))->getMethods(\ReflectionMethod::IS_PUBLIC) as $m){
      if($m->class === static::class)
        $arr[$m->name] = $m;
    }
    return $arr;
  }
1350043
protected function getSortableColumns()
    {
        if ($this->sortableColumns !== null) {
            return $this->sortableColumns;
        }

        $columns = $this->getColumns();
        $sortable = array_filter($columns, function ($column) {
            return $column->sortable;
        });

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

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

            $this->__methods = $methods;
        }

        return $this->__methods;
    }
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;
  }
966017
public function getSorter()
    {
        if (null === $this->sorter) {
            $this->sorter = new Sorter($this);
        }
        return $this->sorter;
    }
718318
public function getMethodNames() {
    return array_map(function (ClassMethodNode $node) {
      return $node->getName()->getText();
    }, $this->getMethods()->toArray());
  }
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;
  }
1010556
protected function getClassesToScan()
    {
        $classes = [];

        foreach ($this->scan as $class) {
            try {
                $classes[] = new ReflectionClass($class);
            } catch (ReflectionException $e) {
                //
            }
        }

        return $classes;
    }
1223197
protected function extractFilters()
    {
        $invoker = function($methodName) {
            return $this->$methodName();
        };
        $invoker = $invoker->bindTo($this->controller, $this->controller);
        $filters = [];
        
        foreach ($this->controller->getReflection()->getMethods() as $method) {
            $methodName = $method->getName();
            if (
                strpos($methodName, 'Filters') === strlen($methodName) - 7
            ) {
                $filters = array_merge_recursive($filters, $invoker($methodName));
            }
        }
        
        foreach ($this->controller->getAppControllersMethod('filters') as $closure) {
            $filters = array_merge_recursive($filters, $closure());
        }
        
        $filters = array_merge_recursive($filters, $invoker('filters'));
        
        return $filters;
    }
1367819
protected function getCustomSortingList() : array
    {
        $arEventResult = Event::fire('shopaholic.promo_block.sorting.get.list', [$this->sValue]);
        if (empty($arEventResult)) {
            return [];
        }

        $arElementIDList = [];
        foreach ($arEventResult as $arEventPromoBlockIDList) {
            if (empty($arEventPromoBlockIDList) || !is_array($arEventPromoBlockIDList)) {
                continue;
            }

            $arElementIDList = $arEventPromoBlockIDList;
            break;
        }

        return $arElementIDList;
    }
293963
public function getClasses()
    {
        $classes = explode(' ', $this->cssClass);
        $this->extend('updateClasses', $classes);
        $classes = implode(' ', $classes);

        return $classes;
    }
1185123
protected function collectGetters()
    {
        $getterz = [];
        $methods = get_class_methods($this);
        foreach ($methods as $method) {
            if (12 < strlen($method) && 'get' == substr($method, 0, 3)) {
                if ('Attribute' == substr($method, -9)) {
                    $getterz[] = $method;
                }
            }
        }
        $methods = [];

        foreach ($getterz as $getter) {
            $residual = substr($getter, 3);
            $residual = substr(/* @scrutinizer ignore-type */$residual, 0, -9);
            $methods[] = $residual;
        }
        return $methods;
    }