collects the components from adminTool
@return all AdminComponents with a main menu and at least one non-hidden (visible) menu entry
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;
	}
507586
public List<IntArrayList> findComponents() {
        int nodes = graph.getNodes();
        for (int start = 0; start < nodes; start++) {
            if (nodeIndex[start] == 0
                    && !ignoreSet.contains(start)
                    && !graph.isNodeRemoved(start))
                strongConnect(start);
        }

        return components;
    }
160095
public int[] getSelectedComponents ()
    {
        int[] values = new int[_selected.size()];
        Iterator<Integer> iter = _selected.values().iterator();
        for (int ii = 0; iter.hasNext(); ii++) {
            values[ii] = iter.next().intValue();
        }
        return values;
    }
1296676
public List<AbstractPanel> getPanels() {
        List<AbstractPanel> panels = new ArrayList<>();
        for (Component component : fullTabList) {
            if (component instanceof AbstractPanel) {
                panels.add((AbstractPanel) component);
            }
        }
        return panels;
    }
471596
def admin_component_sections
      @admin_component_sections ||= begin
        Para::ComponentSection.ordered.includes(:components).tap do |sections|
          sections.flat_map(&:components).each(&method(:decorate))
        end
      end
    end
1138457
public function getComponents () : array
    {
        if (null === $this->components)
        {
            $this->components = $this->loader->loadComponents($this);
        }

        return $this->components;
    }
1010333
public Collection<AdminObject> getAdminObjects()
   {
      if (adminObjects == null)
         return Collections.emptyList();
      
      return Collections.unmodifiableCollection(adminObjects);
   }
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;
    }
311263
public static Collection<Component> getComponentsList() {
    TransactionLogger instance = getInstance();
    if (instance == null) {
      return null;
    }

    return instance.components.values();
  }
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;
    }
354072
protected function getAllMenus()
    {
        if (!empty(self::$menus)) {
            return self::$menus;
        }

        $components = PluginManager::getInstance()->findComponents('Menu', 'Piwik\\Plugin\\Menu');

        self::$menus = array();
        foreach ($components as $component) {
            self::$menus[] = StaticContainer::get($component);
        }

        return self::$menus;
    }
732104
public function componentsList()
    {
        $function = function () {

            $widgets = app('antares.widget')->make('menu.top.right')->items();

            if (!isset($widgets["ui-components-selector"])) {
                return [];
            }
            $childs = $widgets["ui-components-selector"]->childs;
            if (empty($childs)) {
                return [];
            }
            $disabled = Registry::get('ui-components.disabled');
            $viewed   = Registry::get('ui-components.viewed');

            foreach ($childs as $index => $child) {
                $classname = array_get($child->attributes, 'classname');
                if (!is_null($viewed) and ! $viewed->contains($classname)) {
                    unset($childs[$index]);
                }
                if (!is_null($disabled) and $disabled->contains($classname)) {
                    unset($childs[$index]);
                }
            }
            return $childs;
        };
        return new Twig_SimpleFunction(
                'components_list', $function
        );
    }
1100179
private function prepareDirectories()
	{
		if ($this->hasAdmin)
		{
			$this->_mkdir($this->getBuildFolder() . "/administrator/components/com_" . $this->getExtensionName());
		}

		if ($this->hasFront)
		{
			$this->_mkdir($this->getBuildFolder() . "/components/com_" . $this->getExtensionName());
		}
	}
911677
final public function getComponents()
    {
        if ($this->components === null) {
            $this->setComponents($this->getDefaultComponents());
        }
        return $this->components;
    }
1165274
public Collection<ComponentBuilder> getComponentBuilders() {
        final Collection<ComponentBuilder> result = new ArrayList<>();
        result.addAll(_filterComponentBuilders);
        result.addAll(_transformerComponentBuilders);
        result.addAll(_analyzerComponentBuilders);
        return result;
    }
110901
public List<AdminobjectType<ResourceadapterType<T>>> getAllAdminobject()
   {
      List<AdminobjectType<ResourceadapterType<T>>> list = new ArrayList<AdminobjectType<ResourceadapterType<T>>>();
      List<Node> nodeList = childNode.get("adminobject");
      for(Node node: nodeList)
      {
         AdminobjectType<ResourceadapterType<T>>  type = new AdminobjectTypeImpl<ResourceadapterType<T>>(this, "adminobject", childNode, node);
         list.add(type);
      }
      return list;
   }
11534
public function getComponents()
    {
        $result = [];

        foreach ($this->children as $childGroup) {
            foreach ($childGroup as $child) {
                if ($child instanceof self) {
                    $result[] = $child;
                }
            }
        }

        return $result;
    }