Declares the subcomponents for this component.

These are not necessarily child classes, just components this needs.

@return
An array of subcomponent types.
497266
public function requiredComponents() {
    $theme_data = $this->component_data;
    //drush_print_r($theme_data);

    drupal_theme_initialize();
    $theme_registry = theme_get_registry();

    $components = array();
    foreach ($this->component_data['themeables'] as $theme_hook_name) {
      $hook = $theme_hook_name;
      // Iteratively strip everything after the last '--' delimiter, until an
      // implementation is found.
      // (We use -- rather than __ because they're easier to type!)
      // TODO: allow both!
      while ($pos = strrpos($hook, '--')) {
        $hook = substr($hook, 0, $pos);
        if (isset($theme_registry[$hook])) {
          break;
        }
      }
      if (!isset($theme_registry[$hook])) {
        // Bad name. Skip it.
        continue;
      }
      //drush_print_r($hook);

      if (isset($theme_registry[$hook]['template'])) {
        $components[$theme_hook_name] = 'themeTemplate';

        // Store data about this theme hook that we've found.
        $this->component_data['theme_hook_bases'][$theme_hook_name] = $hook;
      }
      else {
        // Fall through, as 'function' is optional in hook_theme().
        // TODO: we don't do theme functions yet -- need a system to add code
        // to existing files!
        //$components[$theme_hook_name] = 'theme_function';
      }
    }

    //drush_print_r($components);
    return $components;
  }
216054
public Set<Component> getRegisteredComponents() {
      Set<Component> set = new HashSet<>();
      for (ComponentRef<?> c : basicComponentRegistry.getRegisteredComponents()) {
         ComponentMetadata metadata = c.wired() != null ?
                                      componentMetadataRepo.getComponentMetadata(c.wired().getClass()) : null;
         Component component = new Component(c, metadata);
         set.add(component);
      }
      return set;
   }
1343671
protected String getComponentModules(List<String> componentIds) {

        Set<String> comps = new HashSet<String>();
        List<CmsSetupComponent> components = CmsCollectionsGenericWrapper.list(m_components.elementList());
        for (CmsSetupComponent comp : components) {
            if (componentIds.contains(comp.getId())) {
                comps.addAll(getComponentModules(comp));
            }

        }

        StringBuffer buf = new StringBuffer();
        List<String> moduleNames = sortModules(getAvailableModules().values());
        boolean first = true;
        for (String moduleName : moduleNames) {
            if (!first) {
                buf.append("|");
            }
            if (comps.contains(moduleName)) {
                buf.append(moduleName);
            }
            first = false;
        }

        return buf.toString();
    }
1296676
public List<AbstractPanel> getPanels() {
        List<AbstractPanel> panels = new ArrayList<>();
        for (Component component : fullTabList) {
            if (component instanceof AbstractPanel) {
                panels.add((AbstractPanel) component);
            }
        }
        return panels;
    }
1234450
@SuppressWarnings("unchecked")
  public V getComponent() {
	if (this.component == null) {
	  try {
		this.component =
			(V) Application.getControllerManager().getComponentBuilder()
				.build(this);
	  } catch (Exception e) {
		throw new ControllerException("Component Build Error", e);
	  }

	  if (this.component == null) {
		throw new ControllerException("NULL Component.");
	  }
	}
	return this.component;
  }
1190135
public Iterable<String> components() {
    ImmutableList.Builder<String> components = ImmutableList.builder();
    buildComponents(components);
    return components.build();
  }
952885
public function getComponentTypes()
    {
        $types = array(
            'cart' => $this->translation->text('Cart'),
            'payment' => $this->translation->text('Payment'),
            'shipping' => $this->translation->text('Shipping')
        );

        $this->hook->attach('order.component.types', $types);
        return $types;
    }
749597
static TypeName arrayComponent(TypeName type) {
    return type instanceof ArrayTypeName
        ? ((ArrayTypeName) type).componentType
        : null;
  }
1258242
@SuppressWarnings("unchecked")
  public <T> @NonNull Collection<Collection<T>> components() {
    return (Collection<Collection<T>>) this.components;
  }
615517
@Override
    public Set<Class<?>> getComponents() {
        Set<Class<?>> set = new HashSet<>();
        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        Consumer<JsonArray> reader = array -> {
            if (array != null && array.size() > 0) {
                for (int i = 0; i < array.size(); i++) {
                    try {
                        set.add(cl.loadClass(array.getString(i)));
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };

        JsonArray features = config.getJsonArray(CONFIG_FEATURES, null);
        JsonArray components = config.getJsonArray(CONFIG_COMPONENTS, null);

        reader.accept(features);
        reader.accept(components);

        return set;
    }
979654
public String htmlComponents() {

        StringBuffer html = new StringBuffer(1024);
        Iterator<CmsSetupComponent> itComponents = CmsCollectionsGenericWrapper.<CmsSetupComponent> list(
            m_components.elementList()).iterator();
        while (itComponents.hasNext()) {
            CmsSetupComponent component = itComponents.next();
            html.append(htmlComponent(component));
        }
        return html.toString();
    }
74897
private function getComponents()
    {
        // Order of components being registered is extremely important!
        return array(
            new Component\Request(),
            new Component\Paginator(),
            new Component\Db(),
            new Component\MapperFactory(),
            new Component\SessionBag(),
            new Component\AuthManager(),
            new Component\AuthAttemptLimit(),
            new Component\ParamBag(),
            new Component\AppConfig(),
            new Component\Config(),
            new Component\ModuleManager(),
            new Component\Translator(),
            new Component\Response(),
            new Component\FlashBag(),
            new Component\FormAttribute(),
            new Component\ValidatorFactory(),
            new Component\WidgetFactory(),
            new Component\UrlBuilder(),
            new Component\View(),
            new Component\Profiler(),
            new Component\Cache(),
            new Component\CsrfProtector(),
            new Component\Captcha(),
            // Dispatcher always must be very last component to be registered
            new Component\Dispatcher()
        );
    }
1153909
public List<Object> getAll() {
		List<Object> components = new ArrayList<Object>();

		synchronized (_lock) {
			for (Reference reference : _references)
				components.add(reference.getComponent());
		}

		return components;
	}
1026210
protected function getComponents()
    {
        if ($this->_components === null) {
            if ($this->_string === null) {
                return [];
            }
            $this->_components = $this->parseUri($this->_string);
        }
        return $this->_components;
    }
516222
public static function get_component_names() : array {
        $componentnames = [];
        // Get all plugins.
        foreach (self::get_plugin_types() as $plugintype => $typedir) {
            foreach (self::get_plugin_list($plugintype) as $pluginname => $plugindir) {
                $componentnames[] = $plugintype . '_' . $pluginname;
            }
        }
        // Get all subsystems.
        foreach (self::get_core_subsystems() as $subsystemname => $subsystempath) {
            $componentnames[] = 'core_' . $subsystemname;
        }
        return $componentnames;
    }
434891
private void addDirectSubTypes(XClass type, ArrayList subTypes)
    {
        if (type.isInterface())
        {
            if (type.getExtendingInterfaces() != null)
            {
                subTypes.addAll(type.getExtendingInterfaces());
            }
            // we have to traverse the implementing classes as these array contains all classes that
            // implement the interface, not only those who have an "implement" declaration
            // note that for whatever reason the declared interfaces are not exported via the XClass interface
            // so we have to get them via the underlying class which is hopefully a subclass of AbstractClass
            if (type.getImplementingClasses() != null)
            {
                Collection declaredInterfaces = null;
                XClass     subType;

                for (Iterator it = type.getImplementingClasses().iterator(); it.hasNext(); )
                {
                    subType = (XClass)it.next();
                    if (subType instanceof AbstractClass)
                    {
                        declaredInterfaces = ((AbstractClass)subType).getDeclaredInterfaces();
                        if ((declaredInterfaces != null) && declaredInterfaces.contains(type))
                        {
                            subTypes.add(subType);
                        }
                    }
                    else
                    {
                        // Otherwise we have to live with the bug
                        subTypes.add(subType);
                    }
                }
            }
        }
        else
        {
            subTypes.addAll(type.getDirectSubclasses());
        }
    }
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;
	}