@static

@return string[]
542018
public static function getStatusList()
    {
        // @todo: check for a complete list of available CloudFront statuses
        return [
            self::STATUS_OK => 'Completed',
            self::STATUS_TO_SEND => 'STATUS_TO_SEND',
            self::STATUS_TO_FLUSH => 'STATUS_TO_FLUSH',
            self::STATUS_ERROR => 'STATUS_ERROR',
            self::STATUS_WAITING => 'InProgress',
        ];
    }
7021
public static function getArray()
    {
        $var = new Vars();
        $list = array();
        foreach ($var->get_all()->getModels() as $item) {
            $list[$item->key] = $item->value;
        }
        return $list;
    }
1091612
public function toArray()
    {
        return [
            'name'     => $this->getName(),
            'label'    => $this->getLabel(),
            'width'    => $this->getWidth(),
            'fixed'    => $this->isFixed(),
            'minWidth' => $this->getMinWidth(),
            'sortable' => $this->getSortable(),
            'type'     => $this->getType(),
        ];
    }
244887
public function toArray() {
        $out = [];
        for ($i=static::ROWS;$i-->0;) {
            $out[$i] = $this[$i]->toArray();
        }
        return $out;
    }
548799
public static final function values() {
			if (!static::isDone())
				static::autoload();

			$key = get_called_class();

			if (array_key_exists($key, self::$types))
				return self::$types[$key];

			return array();
		}
1103248
static function getSearches() {
		static $search_types = null; // Cheap cache
		if ( ! is_array( $search_types ) ) {
			$classes = [];
			$files = glob( __DIR__ . '/types/*.php' );
			foreach ( $files as $file ) {
				preg_match( '/class-(.*?)\.php/', $file, $match );
				$class = __NAMESPACE__ . '\Types\\' . ucfirst( $match[1] );
				if ( class_exists( $class ) ) {
					$classes[] = new $class;
				}
			}
			$search_types = $classes;
		}
		return $search_types;
	}
129168
public function getMessages() : array
    {
        $messages = [];

        foreach ($this->getLogs() as $log) {
            foreach ($log->getMessages() as $message) {
                $messages[] = $message;
            }
        }

        return $messages;
    }
811652
public static function getConfiguration(): array
    {
        static $configuration;
        if (\is_array($configuration)) {
            return $configuration;
        }
        if (VersionNumberUtility::convertVersionStringToArray(VersionNumberUtility::getCurrentTypo3Version())['version_main'] < 9) {
            $configuration = isset($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['staticfilecache']) ? (array)\unserialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['staticfilecache']) : [];
        } else {
            $configuration = (array)GeneralUtility::makeInstance(ExtensionConfiguration::class)->get('staticfilecache');
        }

        return $configuration;
    }
1342992
public function getParams()
    {
        $params = [];
        foreach ($this as $key => $value) {
            $pname = (string) ltrim(strtolower(preg_replace('/[A-Z]/', '_$0', $key)), '_');
            $params[$pname] = $value;
        }
        return $params;
    }
19032
final public static function getValues(): array
    {
        if (isset(self::$cache[static::class])) {
            return self::$cache[static::class];
        }

        $rc = new \ReflectionClass(static::class);

        return self::$cache[static::class] = $rc->getConstants();
    }
348116
public function getStaticVersions(): array
	{
		$result = false;
		try
		{
			// Fetch StaticData from JSON files
			$result = DataDragonAPI::getStaticVersions();
			if (!$result) throw new ServerException("StaticData failed to be loaded.");

			$this->result_data = $result;
		}
		catch (DataDragonExceptions\ArgumentException $ex)
		{
			throw new RequestException($ex->getMessage(), $ex->getCode());
		}
		finally
		{
			// Return data
			return $result;
		}
	}
338202
public static function getAll(): array
    {
        if (empty(self::$trees)) {
            self::$trees = self::all()->all();
        }

        return self::$trees;
    }
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;
  }
726835
protected function getStaticFields()
	{
		$splHash = spl_object_hash($this);
		$fields  = [
			$splHash => [],
		];
		foreach ($this->staticFields as $field => $data)
		{
			if( !isset($this->info[$field]) )
				continue;
			$fieldValue = $this->info[$field];
			if ( ! isset($fields[$splHash][$data]))
			{
				$fields[$splHash][$data] = [];
			}
			$fields[$splHash][$data][] = $fieldValue;
		}

		$fields += parent::getStaticFields();

		return $fields;
	}
121506
public static function activeLocales(): array
    {
        $locales = app(ModuleService::class)
            ->findByInterface(ModuleLanguageInterface::class, false, true)
            ->map(static function (ModuleLanguageInterface $module): LocaleInterface {
                return $module->locale();
            });

        if ($locales->isEmpty()) {
            return [new LocaleEnUs()];
        }

        return $locales->all();
    }
191084
public function toArray()
    {
        return [
            'userAgent'          => $this->userAgent,
            'browser'            => $this->browser,
            'version'            => $this->version,
            'majorVersion'       => $this->majorVersion,
            'minorVersion'       => $this->minorVersion,
            'browserWithVersion' => $this->browserWithVersion,
            'publisher'          => $this->publisher,
            'platform'           => $this->platform,
            'device'             => $this->device,
            'devicePointer'      => $this->devicePointer,
            'isMobile'           => $this->isMobile,
            'isTablet'           => $this->isTablet(),
            'isCrawler'          => $this->isCrawler,
        ];
    }
25108
public static function getShells() : array
    {
        // Return the cached result if it's already available.
        if (static::$shells !== null) {
            return static::$shells;
        }

        // Ensure this method will be ran once at most.
        static::$shells = [];

        // Can't easily check on Windows even if Cygwin or the likes are available.
        if (static::isWindows()) {
            return static::$shells;
        }

        if (file_exists($file = '/etc/shells')) {
            $cat = trim(shell_exec('cat '.$file.' 2> /dev/null'));

            foreach (explode(PHP_EOL, $cat) as $path) {
                // Ignore this line if it doesn't begin with a filepath.
                if ($path[0] != '/') {
                    continue;
                }

                $name = substr($path, strrpos($path, '/') + 1);

                static::$shells[$name] = $path;
            }
        }

        return static::$shells;
    }