Classes available in finder scope.

@return array
973981
protected function availableClasses(): array
    {
        $classes = [];

        foreach ($this->availableReflections() as $reflection) {
            $classes = array_merge($classes, $reflection->getClasses());
        }

        return $classes;
    }
772428
public function findFiles()
    {
        $search = (new Finder())->files();
        // Add in paths
        foreach ($this->paths as $path) {
            if (is_readable($path)) {
                $search->in($path);
            }
        }
        // Add in names
        foreach ($this->files as $pattern) {
            $search->name($pattern);
        }

        $array = array();
        foreach ($search as $f) {
            $array[] = $f->getRealPath();
        }

        return $array;

    }
1195526
public function getFiles()
    {
        $finders = [
            MainConfigurationFinder::class,
            ContextualConfigurationFinder::class,
            PluginsConfigurationFinder::class,
        ];

        // Filter out non-existing folders
        $folders = $this->getFolders();
        if (!$folders) {
            return [];
        }

        $files = [];
        foreach ($folders as $folder) {
            foreach ($finders as $finder) {
                /** @var AbstractConfigurationFinder $finder */
                $finder = new $finder($this->files, $folder);
                $files = array_merge($files, $finder->getFiles());
            }
        }

        // Load consolidated configuration
        $folder = $this->paths->getRocketeerPath();
        if ($this->files->has($folder)) {
            $consolidated = new ConsolidatedConfigurationFinder($this->files, $folder);
            $files = array_merge($files, $consolidated->getFiles());
        }

        return $files;
    }
959558
public static function get_browser_version_classes() {
        $classes = array();
        if (self::is_edge()) {
            $classes[] = 'edge';
        } else if (self::is_ie()) {
            $classes[] = 'ie';
            for ($i = 12; $i >= 6; $i--) {
                if (self::check_ie_version($i)) {
                    $classes[] = 'ie'.$i;
                    break;
                }
            }
        } else if (self::is_firefox() || self::is_gecko() || self::check_camino_version()) {
            $classes[] = 'gecko';
            if (preg_match('/rv\:([1-2])\.([0-9])/', self::get_user_agent_string(), $matches)) {
                $classes[] = "gecko{$matches[1]}{$matches[2]}";
            }
        } else if (self::is_chrome()) {
            $classes[] = 'chrome';
            if (self::is_webkit_android()) {
                $classes[] = 'android';
            }
        } else if (self::is_webkit()) {
            if (self::is_safari()) {
                $classes[] = 'safari';
            }
            if (self::is_safari_ios()) {
                $classes[] = 'ios';
            } else if (self::is_webkit_android()) {
                $classes[] = 'android'; // Old pre-Chrome android browsers.
            }
        } else if (self::is_opera()) {
            $classes[] = 'opera';
        }
        return $classes;
    }
1302662
public function getClasses()
        {
            $classes = [];

            foreach ($this->configurations as $name => $data) {
                if (strpos($name, 'alias') === 0) {
                    continue;
                }

                $classes[] = $name;
            }

            return $classes;
        }
231432
public function getClasses()
    {
        $classes = $this->getAttribute("class");
        return (strlen($classes) > 0) ? trim($this->removeMultipleSpaces($classes)) : "";
    }
892555
public static function getUserClasses()
    {
        $classes = [];
        //
        $namespace = "Vinala\App\Support\Lumos";
        //
        foreach (get_declared_classes() as $value) {
            if (str_contains($value, $namespace)) {
                $classes[] = $value;
            }
        }

        return $classes;
    }
189040
private function findClasses()
    {
        $classes       = array();
        $namespaceName = $this->getName();
        // classes can be only top-level nodes in the namespace, so we can scan them directly
        foreach ($this->namespaceNode->stmts as $namespaceLevelNode) {
            if ($namespaceLevelNode instanceof ClassLike) {
                $classShortName = $namespaceLevelNode->name->toString();
                $className = $namespaceName ? $namespaceName .'\\' . $classShortName : $classShortName;

                $namespaceLevelNode->setAttribute('fileName', $this->fileName);
                $classes[$className] = new ReflectionClass($className, $namespaceLevelNode);
            }
        }

        return $classes;
    }
571900
public function getClassFiles()
    {
        foreach ($this->getFlattenedAutoloadConfiguration() as $configuration) {
            $normalizedAutoloadPath = $this->normalizeAutoloadPath($configuration['mappingType'], $configuration['namespace'], $configuration['classPath']);
            if (!is_dir($normalizedAutoloadPath)) {
                continue;
            }
            foreach ($this->getClassesInNormalizedAutoloadPath($normalizedAutoloadPath, $configuration['namespace']) as $className => $classPath) {
                yield $className => $classPath;
            }
        }
    }
20301
private function classes(): string
    {
        $classes = 'alert';

        if ($this->bg_color !== null) {
            $classes .= ' alert-' . $this->bg_color;
        }

        if ($this->text_color !== null) {
            $classes .= ' text-' . $this->text_color;
        }

        return $classes;
    }
272274
public function getClassNames()
    {
        $classes = array_merge(
            parent::getClassNames(),
            [
                $this->IconSizeClass,
                $this->CornerStyleClass
            ]
        );
        
        return $classes;
    }
1207302
public function getScopes()
    {
        if ($this->scopes === null) {
            $this->scopes = $this->formatScopes(
                $this->server->getAccessTokenStorage()->getScopes($this)
            );
        }

        return $this->scopes;
    }
399197
protected function getClassNameOptions()
    {
        $hidden  = [];
        $classes = [];
        
        foreach ($this->dbObject('ClassName')->enumValues() as $class) {
            
            if ($class == self::class || !in_array($class, ClassInfo::subclassesFor($this))) {
                continue;
            }
            
            if ($hide = Config::inst()->get($class, 'hide_ancestor')) {
                $hidden[$hide] = true;
            }
            
            if (!$class::singleton()->canCreate()) {
                continue;
            }
            
            $classes[$class] = $class::singleton()->i18n_singular_name();
            
        }
        
        foreach ($hidden as $class => $hide) {
            unset($classes[$class]);
        }
        
        return $classes;
    }
603184
public function getScopes(): array
    {
        if ($this->scopes === null) {
            $event = new RegisterScopesEvent([
                'scopes' => [
                    self::GLOBAL_SCOPE
                ]
            ]);

            $this->trigger(
                self::EVENT_REGISTER_SCOPES,
                $event
            );

            $this->scopes = $event->scopes;
        }

        return $this->scopes;
    }
1354398
public function getDisabledModuleClasses()
    {
        $disabledModules = $this->getDisabledModules();
        $disabledModuleClasses = [];
        if (isset($disabledModules) && is_array($disabledModules)) {
            //get all disabled module paths
            $extensions = $this->getModuleConfigParametersByKey(static::MODULE_KEY_EXTENSIONS);
            $modules = $this->getModulesWithExtendedClass();
            $modulePaths = $this->getModuleConfigParametersByKey(static::MODULE_KEY_PATHS);

            foreach ($disabledModules as $moduleId) {
                if (!array_key_exists($moduleId, $extensions)) {
                    $path = $modulePaths[$moduleId];
                    if (!isset($path)) {
                        $path = $moduleId;
                    }
                    foreach ($modules as $moduleClasses) {
                        foreach ($moduleClasses as $moduleClass) {
                            if (strpos($moduleClass, $path . "/") === 0) {
                                $disabledModuleClasses[] = $moduleClass;
                            }
                        }
                    }
                } else {
                    $disabledModuleClasses = array_merge($disabledModuleClasses, $extensions[$moduleId]);
                }
            }
        }

        return $disabledModuleClasses;
    }
758340
protected function getTableClasses()
  {
    $classes = "";

    if($this->table_striped)
    {
      $classes.= "table-striped ";
    }
    if($this->table_bordered)
    {
      $classes.= "table-bordered ";
    }
    if($this->table_hover)
    {
      $classes.= "table-hover ";
    }
    if($this->table_condensed)
    {
      $classes.= "table-condensed ";
    }

    $classes.= $this->getTableExtraClassesString();

    return $classes;
  }
456481
public function getClasses()
    {
        $owner = $this->owner;
        $classes = array();
        $classes[] = $owner->ClassName;
        if ($owner->ClassName == 'PlaceablePage') {
            $classes[] = $owner->PageType()->Type;
        }
        $owner->extend('updateClasses', $classes);
        return implode(' ', $classes);
    }