The standard component type for this component.

The standard component family for this component.

The message identifier of the javax.faces.application.FacesMessage to be created if a value not matching the available options is specified. 

 public UISelectMany() 
{
        super();
        setRendererType("javax.faces.Listbox");
}

Create a new UISelectMany instance with default property values.

 protected boolean compareValues(Object previous,
    Object value) 
{
        if ((previous == null) && (value != null)) {
            return (true);
        } else if ((previous != null) && (value == null)) {
            return (true);
        } else if ((previous == null)) {
            return (false);
        }
        boolean valueChanged = false;
        Object oldarray[];
        Object newarray[];
        // The arrays may be arrays of primitives;  for simplicity,
        // perform the boxing here.
        if (!(previous instanceof Object[])) {
            previous = toObjectArray(previous);
        }
        if (!(value instanceof Object[])) {
            value = toObjectArray(value);
        }
        // If values are still not of the type Object[], it is perhaps a
        // mistake by the renderers, so return false, so that
        // ValueChangedEvent is not queued in this case.
        if (!(previous instanceof Object[]) || 
              !(value instanceof Object[])) {
              return false;
        }
        oldarray = (Object[]) previous;
        newarray = (Object[])value;
        // If we got here then both the arrays cannot be null
        // if their lengths vary, return false.
        if ( oldarray.length != newarray.length) {
            return true;
        }
        // make sure every element in the previous array occurs the same
        // number of times in the current array. This should help us
        // to find out the values changed are not. Since we cannot assume
        // the browser will send the elements in the same order everytime,
        // it will not suffice to just compare the element position and position.
        int count1;
        int count2;
        for ( int i= 0; i <  oldarray.length; ++i ) {
            count1 = countElementOccurrence(oldarray[i], oldarray);
            count2 = countElementOccurrence(oldarray[i], newarray);
            if ( count1 != count2 ) {
                valueChanged = true;
                break;
            }     
        }    
        return valueChanged;
}

Return true if the new value is different from the previous value. Value comparison must not be sensitive to element order.

 public String getFamily() 
{
        return (COMPONENT_FAMILY);
}

 public Object[] getSelectedValues() 
{
        return ((Object[]) getValue());
}

Return the currently selected values, or null if there are no currently selected values. This is a typesafe alias for getValue().

 public ValueBinding getValueBinding(String name) 
{
        if ("selectedValues".equals(name)) {
            return (super.getValueBinding("value"));
        } else {
            return (super.getValueBinding(name));
        }
}

Return any ValueBinding set for value if a ValueBinding for selectedValues is requested; otherwise, perform the default superclass processing for this method.

This method relies on the superclass to provide the ValueExpression to ValueBinding wrapping.

 public ValueExpression getValueExpression(String name) 
{
        if ("selectedValues".equals(name)) {
            return (super.getValueExpression("value"));
        } else {
            return (super.getValueExpression(name));
        }
}

Return any ValueExpression set for value if a ValueExpression for selectedValues is requested; otherwise, perform the default superclass processing for this method.

 public  void setSelectedValues(Object[] selectedValues) 
{
        setValue(selectedValues);
}

Set the currently selected values, or null to indicate that there are no currently selected values. This is a typesafe alias for setValue().

 public  void setValueBinding(String name,
    ValueBinding binding) 
{
        if ("selectedValues".equals(name)) {
            super.setValueBinding("value", binding);
        } else {
            super.setValueBinding(name, binding);
        }
}

Store any ValueBinding specified for selectedValues under value instead; otherwise, perform the default superclass processing for this method.

This method relies on the superclass to wrap the argument ValueBinding in a ValueExpression.

 public  void setValueExpression(String name,
    ValueExpression binding) 
{
        if ("selectedValues".equals(name)) {
            super.setValueExpression("value", binding);
        } else {
            super.setValueExpression(name, binding);
        }
}

Store any ValueExpression specified for selectedValues under value instead; otherwise, perform the default superclass processing for this method.

 protected  void validateValue(FacesContext context,
    Object value) 
{
        super.validateValue(context, value);
        // Skip validation if it is not necessary
        if (!isValid() || (value == null)) {
            return;
        }
        boolean doAddMessage = false;
        // Ensure that the values match one of the available options
        // Don't arrays cast to "Object[]", as we may now be using an array
        // of primitives
        Converter converter = getConverter();
        for (Iterator i = getValuesIterator(value); i.hasNext(); ) {
            Iterator items = new SelectItemsIterator(context, this);
            Object currentValue = i.next();
            if (!SelectUtils.matchValue(context,
                                        this,
                                        currentValue,
                                        items,
                                        converter)) {
                doAddMessage = true;
                break;
            }
        }
        // Ensure that if the value is noSelection and a
        // value is required, a message is queued
        if (isRequired()) {
            for (Iterator i = getValuesIterator(value); i.hasNext();) {
                Iterator items = new SelectItemsIterator(context, this);
                Object currentValue = i.next();
                if (SelectUtils.valueIsNoSelectionOption(context,
                        this,
                        currentValue,
                        items,
                        converter)) {
                    doAddMessage = true;
                    break;
                }
            }
        }
        if (doAddMessage) {
            // Enqueue an error message if an invalid value was specified
            FacesMessage message =
                    MessageFactory.getMessage(context,
                    INVALID_MESSAGE_ID,
                    MessageFactory.getLabel(context, this));
            context.addMessage(getClientId(context), message);
            setValid(false);
        }
}

In addition to the standard validation behavior inherited from UIInput , ensure that any specified values are equal to one of the available options. Before comparing each option, coerce the option value type to the type of this component's value following the Expression Language coercion rules. If the specified value is not equal to any of the options, enqueue an error message and set the valid property to false.

This method must explicitly support a value argument that is a single value or a value argument that is a Collection or Array of values.

If #isRequired returns true, and the current value is equal to the value of an inner UISelectItem whose UISelectItem#isNoSelectionOption method returns true, enqueue an error message and set the valid property to false.