```php
ClassHelper::getEventNames(yii\base\View::class);
```
@param $className
@return array
327666
public static function getEventNames($className)
    {
        $result = [];
        $reflection = new \ReflectionClass($className);
        foreach ($reflection->getConstants() as $name => $value) {
            if (!preg_match('/^EVENT/', $name)) {
                continue;
            }
            $result[$name] = $value;
        }
        return $result;
    }
150358
public function classToTableName($className)
    {
        $className = $this->getRelativeClass($className);
        $className = ltrim(strtolower(preg_replace('/[A-Z]/', '_$0', $className)), '_');

        return $this->prefix . $className;
    }
74759
public function fetchAllClass(string $classname) : array
    {
        $this->stmt->setFetchMode(\PDO::FETCH_CLASS, $classname);
        return $this->stmt->fetchAll();
    }
1322728
public function getListeners(string $eventName = ''): array
    {
        $this->sortListeners($eventName);
        if ('' !== $eventName) {
            return \array_key_exists($eventName, $this->listeners) ? $this->listeners[$eventName] : [];
        }
        return $this->listeners;
    }
95893
public static function getClassAnnotations($className)
    {
        if (!isset(self::$annotationCache[$className])) {
            $class = new \ReflectionClass($className);
            self::$annotationCache[$className] = self::parseAnnotations($class->getDocComment());
        }

        return self::$annotationCache[$className];
    }
1190104
public function getListeners($eventName = NULL)
	{
		if($eventName === NULL)
		{
			$listeners = [];
			
			foreach(array_keys($this->listeners) as $k)
			{
				$listeners[$k] = [];
				
				foreach(clone $this->listeners[$k] as $listener)
				{
					$listeners[$k][] = $listener;
				}
			}
			
			ksort($listeners);
			
			return $listeners;
		}
		
		if($eventName instanceof \ReflectionClass)
		{
			$eventName = $eventName->name;
		}
		
		if(empty($this->listeners[$eventName]))
		{
			return [];
		}
		
		$listeners = [];
		
		foreach(clone $this->listeners[$eventName] as $listener)
		{
			$listeners[] = $listener;
		}
		
		return $listeners;
	}
653568
public function getValues($className)
    {
        if(isset($this->data['EnumItem'][$className]))
        {
            return array_keys($this->data['EnumItem'][$className]);
        }
        else
        {
            return [];
        }
    }
264388
public function getEvent($name)
    {

        if (!isset($this->_events))
            $this->_events = [];

        if (!isset($this->_events[$name])) {

            $className = $this->getEventClassName();
            $this->_events[$name] = new $className($name);
        }

        return $this->_events[$name];
    }
125224
public function getList($eventName)
    {
        $eventName = $this->cleanEventName($eventName);

        if ($eventName === '*') {
            throw new Exception('* is unsafe event name!');
        }

        $result = array();
        $ePaths = explode('.', $eventName);

        foreach ($this->_list as $eName => $eData) {

            if ($eName === $eventName) {
                $result = array_merge($result, $eData);

            } elseif (strpos($eName, '*') !== false) {
                $eNameParts = explode('.', $eName);

                if ($this->_isContainPart($eNameParts, $ePaths)) {
                    $result = array_merge($result, $eData);
                }
            }
        }

        if (count($result) > 0) {
            // Sorting
            usort($result, function ($item1, $item2) {
                return $item2[0] - $item1[0];
            });

            return array_map(function ($item) {
                return $item[1];
            }, $result);
        }

        return array();
    }
1266736
public static function classToIndex($className)
    {
        if (false === is_string($className)) {
            return '';
        }
        $modelClass = strtolower($className);
        return StringHelper::basename($modelClass);
    }
477887
protected function getClassName($className = null)
    {
        $parts = explode('\\', $className ?: $this->className);

        return $parts[count($parts) - 1];
    }
697026
public function getResultsAsObjects($classname)
    {
        $new = array();
        foreach ((array) $this->results as $result) {
            if (is_array($result))
                $new[] = new $classname($result);
            else
                $new[] = $result;
        }
        return $new;
    }
779223
public static function mapClassNameToFileName($className)
    {
        $arr = preg_split('/(?=[A-Z])/', $className);
        unset($arr[0]); // remove the first element ('')
        $fileName = static::getCurrentTimestamp() . '_' . strtolower(implode($arr, '_')) . '.php';

        return $fileName;
    }
437912
static public function getParents($className)
    {
        $parents = [];
        $parent = new \ReflectionClass($className);
        while (true) {
            $parent = $parent->getParentClass();
            if (!$parent) {
                break;
            } else {
                $parents[] = $parent->getName();
            }
        }
        return $parents;
    }
228494
public function getListeners(string $eventName = ''): array
    {
        if (0 !== \count($this->serviceListeners)) {
            if ('' === $eventName) {
                $this->lazyLoadServices(\array_keys($this->serviceListeners));
            } elseif (\array_key_exists($eventName, $this->serviceListeners)) {
                $this->lazyLoadServices([$eventName]);
            }
        }
        return parent::getListeners($eventName);
    }
1349034
public function getModuleNameByClassName($className)
    {
        $resultModuleName = $this->autoDetectModuleNameByClassName($className);
        if (null === $resultModuleName) {
            $errMsg = sprintf('Unable to determine the module name for a class of %s', $className);
            throw new Exception\ResolveModuleNameException($errMsg);
        }

        return $resultModuleName;
    }
1046034
public static function getConfigFromDomainClass($className) {
		$definition = ClassHelper::normalizeComponentConfig($className);
		/** @var Domain $domain */
		$domain = Yii::createObject($definition);
		$config = $domain->config();
		return $config;
	}