Answers a list of the enabled components within the extended object.

@return ArrayList
349043
public function getEnabledComponents()
    {
        // Create Components List:
        
        $components = ArrayList::create();
        
        // Merge Template Components:
        
        if ($template = $this->getPageTemplate()) {
            $components->merge($template->getEnabledComponents());
        }
        
        // Merge Layout Components:
        
        if ($layout = $this->getPageLayout()) {
            $components->merge($layout->getEnabledComponents());
        }
        
        // Answer Components List:
        
        return $components;
    }
639200
public function ComponentListingItems()
    {
        $manyMany = singleton($this->ListType)->config()->many_many;
        $tagClass = isset($manyMany[$this->ComponentFilterName]) ? $manyMany[$this->ComponentFilterName] : '';
        if (!$tagClass) {
            return new ArrayList();
        }
        $result = DataList::create($tagClass);
        if ($this->ComponentFilterWhere
            && ($componentWhereFilters = $this->ComponentFilterWhere->getValue())
        ) {
            $result = $result->filter($componentWhereFilters);
        }
        return $result;
    }
792530
public static function get_enabled_plugins() {
        $disabledsubplugins = array();
        $config = get_config('editor_tinymce', 'disabledsubplugins');
        if ($config) {
            $config = explode(',', $config);
            foreach ($config as $sp) {
                $sp = trim($sp);
                if ($sp !== '') {
                    $disabledsubplugins[$sp] = $sp;
                }
            }
        }

        $enabled = array();
        $installed = core_component::get_plugin_list('tinymce');
        foreach ($installed as $plugin => $fulldir) {
            if (isset($disabledsubplugins[$plugin])) {
                continue;
            }
            $enabled[$plugin] = $plugin;
        }

        return $enabled;
    }
334959
public static function get_search_areas_list($enabled = false) {

        // Two different arrays, we don't expect these arrays to be big.
        if (static::$allsearchareas !== null) {
            if (!$enabled) {
                return static::$allsearchareas;
            } else {
                return static::$enabledsearchareas;
            }
        }

        static::$allsearchareas = array();
        static::$enabledsearchareas = array();
        $searchclasses = \core_component::get_component_classes_in_namespace(null, 'search');

        foreach ($searchclasses as $classname => $classpath) {
            $areaname = substr(strrchr($classname, '\\'), 1);
            $componentname = strstr($classname, '\\', 1);
            if (!static::is_search_area($classname)) {
                continue;
            }

            $areaid = static::generate_areaid($componentname, $areaname);
            $searchclass = new $classname();
            static::$allsearchareas[$areaid] = $searchclass;
            if ($searchclass->is_enabled()) {
                static::$enabledsearchareas[$areaid] = $searchclass;
            }
        }

        if ($enabled) {
            return static::$enabledsearchareas;
        }
        return static::$allsearchareas;
    }
1049359
public function getInterfaces()
    {
        $extendedInterfaces = [];
        $interfaces = parent::getInterfaces();
        foreach ($interfaces as $interface) {
            $extendedInterfaces[] = new ClassReflection($interface->getName());
        }
        return $extendedInterfaces;
    }
1085412
public function getComponents()
    {
        $components = [
            'Base'                          => 'GetOlympus\Zeus\Base\Controller\Base',
            'BaseWidget'                    => 'GetOlympus\Zeus\Base\Controller\BaseWidget',
            'Helpers'                       => 'GetOlympus\Zeus\Helpers\Controller\Helpers',

            'AdminPage'                     => 'GetOlympus\Zeus\AdminPage\Controller\AdminPage',
            'Ajax'                          => 'GetOlympus\Zeus\Ajax\Controller\Ajax',
            'Configuration'                 => 'GetOlympus\Zeus\Configuration\Controller\Configuration',
            'Cron'                          => 'GetOlympus\Zeus\Cron\Controller\Cron',
            'Error'                         => 'GetOlympus\Zeus\Error\Controller\Error',
            'Field'                         => 'GetOlympus\Zeus\Field\Controller\Field',
            'Hook'                          => 'GetOlympus\Zeus\Hook\Controller\Hook',
            'Metabox'                       => 'GetOlympus\Zeus\Metabox\Controller\Metabox',
            'Option'                        => 'GetOlympus\Zeus\Option\Controller\Option',
            'Posttype'                      => 'GetOlympus\Zeus\Posttype\Controller\Posttype',
            'PosttypeHook'                  => 'GetOlympus\Zeus\Posttype\Controller\PosttypeHook',
            'Render'                        => 'GetOlympus\Zeus\Render\Controller\Render',
            'Request'                       => 'GetOlympus\Zeus\Request\Controller\Request',
            'Template'                      => 'GetOlympus\Zeus\Template\Controller\Template',
            'Term'                          => 'GetOlympus\Zeus\Term\Controller\Term',
            'TermHook'                      => 'GetOlympus\Zeus\Term\Controller\TermHook',
            'Translate'                     => 'GetOlympus\Zeus\Translate\Controller\Translate',
            'WalkerSingle'                  => 'GetOlympus\Zeus\WalkerSingle\Controller\WalkerSingle',
            'Widget'                        => 'GetOlympus\Zeus\Widget\Controller\Widget',
        ];

        // Iterate on externals
        foreach ($this->externals as $shortname => $classname) {
            $components[$shortname] = $classname;
        }

        return $components;
    }
419055
public function getSubComponents() {
    $base_path = $this->getBaseComponentPath();

    $filter = function (Extension $module) use ($base_path) {
      return strlen(dirname($module->getPath())) > strlen($base_path);
    };

    return array_filter($this->getAll(), $filter);
  }
875715
protected function getExtensions()
    {
        if (null === $this->sorted) {
            ksort($this->extensions);
            $this->sorted = !empty($this->extensions)
                ? call_user_func_array('array_merge', $this->extensions)
                : [];
        }

        return $this->sorted;
    }
1058633
protected function findEnabledModules(): array
    {
        $aModules = Components::available(false);
        $aOut     = [];

        foreach ($aModules as $oModule) {
            $aOut[] = $this->determineModuleState($oModule->slug, $oModule->path . 'migrations/');
        }

        return array_filter($aOut);
    }
643085
public function getEnabledProviders()
    {
        $result = [];

        foreach (Port1HybridAuth::PROVIDERS as $provider) {
            if ((Boolean)$this->config->getByNamespace('Port1HybridAuth', strtolower($provider) . '_enabled')) {
                $label = $this->snippetManager->getNamespace('frontend/account/login')->get('SignInWith' . $provider);

                $result[$provider] = $label;
            }
        }
347349
public function getComponents()
    {
        if ($this->_components === null) {
            $this->_components = [];
            if ($config = $this->readConfig()) {
                foreach ($this->files as $current) {
                    if (isset($config[$current]['components'])) {
                        /** @var mixed[] $components */
                        $components = $config[$current]['components'];
                        if (is_array($components)) {
                            foreach ($components as $name => $component) {
                                if (($class = $this->findClass($component)) !== false) {
                                    $this->_components[$name][$class] = $class;
                                }
                            }
                        }
                    }
                }
            }
        }
        return $this->_components;
    }
140083
public function getComponentsFlattened() {
    $components = [];
    foreach ($this->getComponents() as $component) {
      $components[] = $component;
      if ($component instanceof ComponentNested) {
        /** @var \ChapterThree\AppleNewsAPI\Document\Components\ComponentNested $component */
        $descendants = $component->getComponentsFlattened();
        array_merge($components, $descendants);
      }
    }
    return $components;
  }
18203
public List<AdminComponent> getComponents() {
		List<AdminComponent> result = new ArrayList<>();
		
		for (AdminComponent adminComponent : adminTool.getComponents()) {
			if (null != adminComponent.getMainMenu()) {
				Stream<MenuEntry> nonHiddenMenues = adminComponent.getMainMenu().flattened().filter(me -> !me.isHide());
				if (nonHiddenMenues.count() == 0L) {
					LOGGER.trace("all menu entries hidden for component: " + adminComponent.getDisplayName());
					//do not return this menu item, because all entries are hidden
					continue;
				}
				result.add(adminComponent);
			}
		}
		return result;
	}
303506
public function listComponentDetails()
    {
        if ($this->detailsCache !== null) {
            return $this->detailsCache;
        }

        $details = [];
        foreach ($this->listComponents() as $componentAlias => $componentClass) {
            $details[$componentAlias] = $this->makeComponent($componentClass)->componentDetails();
        }

        return $this->detailsCache = $details;
    }
769359
public function enabledFields()
    {
        return array_merge(
            (is_string($this->guidAttribute) && !empty($this->guidAttribute)) ? [$this->guidAttribute] : [],
            (is_string($this->idAttribute) && !empty($this->idAttribute)) ? [$this->idAttribute] : [],
            $this->enabledTimestampFields(),
            $this->enabledIPFields()
        );
    }
1854
public function getItemProviders()
    {
        foreach ($this->modules->enabled() as $module) {
            $name = studly_case($module->getName());
            $class = 'Modules\\'.$name.'\\MenuExtenders\\MenuExtender';

            if (class_exists($class)) {
                $extender = $this->container->make($class);
                $this->extenders->put($module->getName(), [
                    'content' => $extender->getContentItems(),
                    'static'  => $extender->getStaticItems(),
                ]);
            }
        }

        return $this->extenders;
    }
392123
public function getListItemButtons()
    {
        $buttons = ArrayList::create();
        
        foreach ($this->owner->getListItemButtonsConfig() as $name => $spec) {
            
            if ($spec) {
                
                foreach ($spec as $item => $value) {
                    
                    $args = [];
                    
                    if (is_array($value)) {
                        $args  = $value;
                        $value = array_shift($args);
                    }
                    
                    $spec[$item] = $this->processListItemValue($value, $args);
                    
                }
                
                if (isset($spec['show']) && !$this->owner->{$spec['show']}) {
                    continue;
                }
                
                $href = isset($spec['href']) ? $spec['href'] : null;
                
                $type  = null;
                $extra = null;
                
                if ($renderer = $this->owner->getRenderer()) {
                    $type  = $renderer->ButtonTypeStyle;
                    $extra = $renderer->ButtonExtraClass;
                }
                
                if ($href) {
                    
                    $buttons->push(
                        ArrayData::create([
                            'Icon' => isset($spec['icon']) ? $spec['icon'] : null,
                            'Type' => isset($spec['type']) ? $spec['type'] : $type,
                            'HREF' => isset($spec['href']) ? $spec['href'] : null,
                            'Text' => isset($spec['text']) ? $spec['text'] : null,
                            'ExtraClass' => isset($spec['extraClass']) ? $spec['extraClass'] : $extra
                        ])
                    );
                    
                }
                
            }
            
        }
        
        return $buttons;
    }