{@inheritdoc}

@throws ComponentNotFound If an unsupported element type is given.
8582
public function create($model, string $column): Component
    {
        if (!isset($this->gridElementTypes[$model->type])) {
            throw ComponentNotFound::forModel($model);
        }

        $className = $this->gridElementTypes[$model->type];

        return new $className(
            $model,
            $this->templateEngine,
            $this->translator,
            $this->gridProvider,
            $this->scopeMatcher,
            $this->colorRotate,
            $this->responseTagger,
            $column
        );
    }
346252
protected InputContainerElements scan(final UIComponent component, InputContainerElements elements,
            final FacesContext context) {
        if (elements == null) {
            elements = new InputContainerElements();
        }

        // NOTE we need to walk the tree ignoring rendered attribute because it's condition
        // could be based on what we discover
        if ((elements.getLabel() == null) && (component instanceof HtmlOutputLabel)) {
            elements.setLabel((HtmlOutputLabel) component);
        } else if (component instanceof EditableValueHolder) {
            elements.registerInput((EditableValueHolder) component, getDefaultValidator(context), context);
        } else if (component instanceof UIMessage) {
            elements.registerMessage((UIMessage) component);
        }
        // may need to walk smarter to ensure "element of least suprise"
        for (UIComponent child : component.getChildren()) {
            scan(child, elements, context);
        }

        return elements;
    }
50723
@Override
    public final void processComponent(String propertyName, final JComponent component) {

        final AbstractOverlayHandler overlayHandler = this.createOverlayHandler(propertyName, component);

        // Wait until has parent and overlay is correctly installed
        final PropertyChangeListener wait4ParentListener = new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent e) {

                final JComponent targetComponent = overlayHandler.getTargetComponent();
                final JComponent overlay = overlayHandler.getOverlay();

                // Install overlay
                final int position = AbstractOverlayFormComponentInterceptor.this.getPosition();
                final Boolean success = AbstractOverlayFormComponentInterceptor.this.//
                        getOverlayService().installOverlay(targetComponent, overlay, position, null);

                if (success) {
                    targetComponent.removePropertyChangeListener(//
                            AbstractOverlayFormComponentInterceptor.ANCESTOR_PROPERTY, this);
                }
            }
        };

        component.addPropertyChangeListener(//
                AbstractOverlayFormComponentInterceptor.ANCESTOR_PROPERTY, wait4ParentListener);
    }
1217220
public function replaceBy (array $components = null)
  {
    $p = $this->getIndex ();
    if ($p !== false) {
      array_splice ($this->parent->children, $p, 1, $components);
      $this->parent->attach ($components);
    }
    else {
      $t = ComponentInspector::inspectSet ($this->parent->children);
      throw new ComponentException($this,
        "The component was not found on the parent's children.<h3>The children are:</h3><fieldset>$t</fieldset>");
    }
  }
246090
function(component, components) {
        var deps, depsName, depsConfig;
        if (Type.assert(Type.STRING, component.name)) {
            deps = this.getDependency(component.name);
            if (Type.isArray(deps)) {
                while (true) {
                    depsName = deps.shift();
                    if (!depsName) {
                        break;
                    }
                    if (!this.has(depsName)) {
                        if (!!components) {
                            depsConfig = this.find(depsName, components);
                            if (depsConfig) {
                                this.set(depsName, depsConfig);
                                break;
                            }
                        }
                        this.set(depsName, {});
                    }
                }
            }
        }
    }
924474
@Override
    public ValidationResult<?> validate(final OptionalConfigurationComponent<?> configurationComponent) {
        if (configurationComponent instanceof ValidatingConfigurationComponent) {
            @SuppressWarnings("rawtypes")
            final ValidatingConfigurationComponent<?> validatingComponent = (ValidatingConfigurationComponent) configurationComponent;
            return validatingComponent.validate();
        } else {
            final Class<?> componentClass = configurationComponent.getClass();
            final Validator<?> validator = validators.get(componentClass);
            if (validator != null) {
                @SuppressWarnings({"unchecked", "rawtypes"})
                final ValidationResult<?> validationResult = ((Validator) validator).validate(configurationComponent);
                return validationResult;
            } else {
                throw new IllegalArgumentException("No validator for class " + componentClass.getCanonicalName());
            }
        }
    }
426181
protected function Neg()
	{
	    throw XPath2Exception::withErrorCodeAndParams( "XPTY0004", Resources::UnaryOperatorNotDefined,
			array(
				"fn:unary-minus",
				SequenceType::WithTypeCodeAndCardinality( SequenceType::GetXmlTypeCodeFromObject( $this->_value ), XmlTypeCardinality::One )
			)
		);
	}
136460
function (root, componentType) {
    return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
      return ReactTestUtils.isCompositeComponentWithType(inst, componentType);
    });
  }
1135356
public void addAdditionalElement(Component component) {

        m_additionalElements.add(new InfoElementBean(m_additionalElements.size() + 1, component));
        removeClickListener(m_clickListener);
        m_clickListener = getClickListener(m_htmlLines, m_additionalElements);
        addClickListener(m_clickListener);
    }
7756
protected function addComponent($component, $value)
    {
        $this->validateComponentExists($component);

        // We need to make sure the value we're given isn't empty before adding it into our components.
        if (! empty($value)) {
            $this->components[$component][] = $value;
        }
    }
749597
static TypeName arrayComponent(TypeName type) {
    return type instanceof ArrayTypeName
        ? ((ArrayTypeName) type).componentType
        : null;
  }
1249321
function Component($el) {
    var definitions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

    _classCallCheck(this, Component);

    this.$el = $el;
    this.componentName = '';
    this.parent = null;
    this.definitions = [];
    this.refs = {};
    this._componentInstances = [];

    if (definitions) {
      this.init(definitions);
    }
  }
119246
static function assertElementNotFound( $search, $element, $pageSection = null, $type = 'element' )
    {
        $section = ( $pageSection === null ) ? "" : " in '$pageSection' page section";
        Assertion::assertEmpty( $element, "Found '$search' $type" . $section );
    }
270079
public function assertVueIsNot($key, $value, $componentSelector = null)
    {
        PHPUnit::assertNotEquals($value, $this->vueAttribute($componentSelector, $key));

        return $this;
    }
544430
public function enableComponent($name)
    {
        if (!array_key_exists($name, $this->components)) {
            throw new NotValidCompoenentException($name . ' component is not valid');
        }

        $this->components[$name] = true;

        return $this;
    }
177007
@Override
	public void doRender(final WComponent component, final WebXmlRenderContext renderContext) {
		WValidationErrors errors = (WValidationErrors) component;
		XmlStringBuilder xml = renderContext.getWriter();

		if (errors.hasErrors()) {
			xml.appendTagOpen("ui:validationerrors");
			xml.appendAttribute("id", component.getId());
		xml.appendOptionalAttribute("class", component.getHtmlClass());
			xml.appendOptionalAttribute("track", component.isTracking(), "true");
			xml.appendOptionalAttribute("title", errors.getTitleText());
			xml.appendClose();

			for (GroupedDiagnositcs nextGroup : errors.getGroupedErrors()) {
				// Render each diagnostic message in this group.
				for (Diagnostic nextMessage : nextGroup.getDiagnostics()) {
					xml.appendTagOpen("ui:error");
					WComponent forComponent = nextMessage.getComponent();

					if (forComponent != null) {
						UIContextHolder.pushContext(nextMessage.getContext());

						try {
							xml.appendAttribute("for", forComponent.getId());
						} finally {
							UIContextHolder.popContext();
						}
					}

					xml.appendClose();

					// DiagnosticImpl has been extended to support rendering
					// of a WComponent as the message.
					if (nextMessage instanceof DiagnosticImpl) {
						WComponent messageComponent = ((DiagnosticImpl) nextMessage)
								.createDiagnosticErrorComponent();

						// We add the component to a throw-away container so that it renders with the correct ID.
						WContainer container = new WContainer() {
							@Override
							public String getId() {
								return component.getId();
							}
						};

						container.add(messageComponent);
						messageComponent.paint(renderContext);
						container.remove(messageComponent);
						container.reset();
					} else {
						xml.append(nextMessage.getDescription());
					}

					xml.appendEndTag("ui:error");
				}
			}

			xml.appendEndTag("ui:validationerrors");
		}
	}
537086
final void checkReturnType(TypeElement autoValueClass, ExecutableElement getter) {
    TypeMirror type = getter.getReturnType();
    if (type.getKind() == TypeKind.ARRAY) {
      TypeMirror componentType = ((ArrayType) type).getComponentType();
      if (componentType.getKind().isPrimitive()) {
        warnAboutPrimitiveArrays(autoValueClass, getter);
      } else {
        errorReporter.reportError(
            "An @"
                + simpleAnnotationName
                + " class cannot define an array-valued property unless it is a primitive array",
            getter);
      }
    }
  }