Sets the value in the provided {@link InputComponent}, making any necessary conversions

@param component
@param value
491181
public static void setValueFor(final ConverterFactory converterFactory, final InputComponent<?, ?> component,
            final Object value)
   {
      if (component instanceof SingleValued)
      {
         setSingleInputValue(converterFactory, component, value, false);
      }
      else if (component instanceof ManyValued)
      {
         setManyInputValue(converterFactory, component, value, false);
      }
   }
205005
public void setRootComponent(final MvcComponent component) {
        if (uiThreadRunner.isOnUiThread()) {
            try {
                graph.setRootComponent(component);
            } catch (Graph.IllegalRootComponentException e) {
                throw new MvcGraphException(e.getMessage(), e);
            }
        } else {
            uiThreadRunner.post(new Runnable() {
                @Override
                public void run() {
                    try {
                        graph.setRootComponent(component);
                    } catch (Graph.IllegalRootComponentException e) {
                        throw new MvcGraphException(e.getMessage(), e);
                    }
                }
            });
        }
    }
419542
@Override
    public UIComponent createComponent(ValueExpression componentExpression,
                                       FacesContext context,
                                       String componentType)
          throws FacesException {
        return getWrapped().createComponent(componentExpression, context, componentType);
    }
1127337
@SuppressLint("CommitPrefEdits")
  public void set(float value) {
    // Method created in an attempt to avoid unnecessary autoboxing
    Editor editor = getPreferences().edit().putFloat(getKey(), value);
    PREF_SAVER.save(editor);
  }
873366
public void validate(FacesContext context,
                         UIComponent  component,
                         Object       value) throws ValidatorException {
	if (null == context || null == component) {
	    throw new NullPointerException();
	}
        try {
            methodBinding.invoke(context, new Object[] {context, component, 
							value});
        } 
	catch (EvaluationException ee) {
	    Throwable cause = this.getExpectedCause(ValidatorException.class,
						    ee);
	    if (cause instanceof ValidatorException) {
		throw ((ValidatorException) cause);
	    }
	    if (cause instanceof RuntimeException) {
		throw ((RuntimeException) cause);
	    }
	    throw new IllegalStateException(ee);
        }
	
	
    }
1339536
public List<ICalComponent> setComponent(ICalComponent component) {
		return components.replace(component.getClass(), component);
	}
106582
@SuppressWarnings("unchecked")
    public void setFormValue(Object value) {

        if (value instanceof List<?>) {
            List<String> keys = (List<String>)value;
            Set<String> keySet = new HashSet<String>(keys);
            int i = 0;
            for (Map.Entry<String, String> entry : m_items.entrySet()) {
                String key = entry.getKey();
                CmsCheckBox checkbox = m_checkboxes.get(i);
                checkbox.setChecked(keySet.contains(key));
                i += 1;
            }
        }
    }
649587
@Override
	public void setModel(final WebComponent component, final WebModel model) {
		map.put(component, model);
	}
712243
public final void setValue(String value) {

        if ((null == value) || value.isEmpty()) {
            setDefaultValue();
        } else {
            try {
                tryToSetParsedValue(value);
            } catch (@SuppressWarnings("unused") Exception e) {
                CmsDebugLog.consoleLog("Could not set invalid serial date value: " + value);
                setDefaultValue();
            }
        }
        notifyOnValueChange();
    }
1349064
@Override
    public final void setDiscriminator(String value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setDiscriminator", value);
        if (value == null || isValidDiscriminator(value)) {
            super.setDiscriminator(value);
        }
        else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "setDiscriminator", "IllegalArgumentException");
            throw new IllegalArgumentException(value);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setDiscriminator");
    }
1354000
public void setInputWidth(final int inputWidth) {
		if (inputWidth > 100) {
			throw new IllegalArgumentException(
					"inputWidth (" + inputWidth + ") cannot be greater than 100 percent.");
		}
		getOrCreateComponentModel().inputWidth = Math.max(0, inputWidth);
	}
152204
public void addConverterComponent(ValueConverter<?, ?> converter) {

    if (converter instanceof AbstractRecursiveValueConverter) {
      ((AbstractRecursiveValueConverter<?, ?>) converter).setComposedValueConverter(this);
    }
    if (converter instanceof AbstractComponent) {
      ((AbstractComponent) converter).initialize();
    }
    addConverter(converter);
  }
463411
void setValue(T bean, String value) {
    ref.writeValue(converter.fromCharacters(value), bean);
  }
1278422
public void setValueItem(AValue value) {
        
        this.avalue=value;
	if (value!=null) {
	    Object o=SQLValueConverter.convertFromAValue(value);
	    if (o!=null) {
	    	if (o instanceof QualifiedName) {
	    		this.value=o;
	    	} else {
	    		this.value = o.toString();
	    	}
	    }
	}
    }
54757
@SuppressWarnings("unchecked")
    private static void injectComponent(final FacadeReady<?> component, final Field field, final Object... keyParts) {

        try {
            if (Command.class.isAssignableFrom(field.getType())) {
                ClassUtility.setFieldValue(field, component, component.localFacade().globalFacade().commandFacade().retrieve((Class<Command>) field.getType(), keyParts));
            } else if (Service.class.isAssignableFrom(field.getType())) {
                ClassUtility.setFieldValue(field, component, component.localFacade().globalFacade().serviceFacade().retrieve((Class<Service>) field.getType(), keyParts));
            } else if (Model.class.isAssignableFrom(field.getType())) {
                ClassUtility.setFieldValue(field, component, component.localFacade().globalFacade().uiFacade().retrieve((Class<Model>) field.getType(), keyParts));
            }
        } catch (IllegalArgumentException | CoreException e) {
            LOGGER.error(COMPONENT_INJECTION_FAILURE, component.getClass(), e);
        }

    }
919248
static @NonNull TextComponent of(final char value) {
    if(value == '\n') return Component0.NEWLINE;
    if(value == ' ') return Component0.SPACE;
    return TextComponent.of(String.valueOf(value));
  }
268326
@Override
    public void setValue(Object value) {
        if (value != null) {
            Calendar c = (Calendar) value;
            ((JTextField) editor).setText(DEFAULT_DATE_FORMAT.format(c.getTime()));
        }
    }