abstract protected  void addFacesListener(FacesListener listener)
Add the specified FacesListener  to the set of listeners
registered to receive event notifications from this UIComponent .
It is expected that UIComponent  classes acting as event sources
will have corresponding typesafe APIs for registering listeners of the
required type, and the implementation of those registration methods
will delegate to this method. For example:
public class FooEvent extends FacesEvent { ... }

public interface FooListener extends FacesListener {
public void processFoo(FooEvent event);
}

public class FooComponent extends UIComponentBase {
...
public void addFooListener(FooListener listener) {
addFacesListener(listener);
}
public void removeFooListener(FooListener listener) {
removeFacesListener(listener);
}
...
}

 abstract public  void broadcast(FacesEvent event) throws AbortProcessingException
Broadcast the specified FacesEvent  to all registered
event listeners who have expressed an interest in events of this
type. Listeners are called in the order in which they were
added.

 abstract public  void decode(FacesContext context)
Decode any new state of this UIComponent  from the
request contained in the specified FacesContext , and store
this state as needed.

During decoding, events may be enqueued for later processing
(by event listeners who have registered an interest), by calling
queueEvent().

 public  void encodeAll(FacesContext context) throws IOException 
{
        if (!isRendered()) {
            return;
        }
        encodeBegin(context);
        if (getRendersChildren()) {
            encodeChildren(context);
        }
        else            if (this.getChildCount()  > 0) {
                Iterator kids = getChildren().iterator();
                while (kids.hasNext()) {
                    UIComponent kid = (UIComponent) kids.next();
                    kid.encodeAll(context);
                }
            }
        encodeEnd(context);
}

If this component returns true from #isRendered , render this component and all its children that return true from isRendered(), regardless of the value of the #getRendersChildren flag.

 abstract public  void encodeBegin(FacesContext context) throws IOException
If our rendered property is true,
render the beginning of the current state of this
UIComponent  to the response contained in the specified
FacesContext .


If a Renderer  is associated with this UIComponent ,
the actual encoding will be delegated to
Renderer#encodeBegin(FacesContext, UIComponent) .

 abstract public  void encodeChildren(FacesContext context) throws IOException
If our rendered property is true,
render the child UIComponent s of this UIComponent .
This method will only be called
if the rendersChildren property is true.

If a Renderer  is associated with this UIComponent ,
the actual encoding will be delegated to
Renderer#encodeChildren(FacesContext, UIComponent) .

 abstract public  void encodeEnd(FacesContext context) throws IOException
If our rendered property is true,
render the ending of the current state of this
UIComponent .

If a Renderer  is associated with this UIComponent ,
the actual encoding will be delegated to
Renderer#encodeEnd(FacesContext, UIComponent) .

 abstract public UIComponent findComponent(String expr)
Search for and return the UIComponent  with an id
that matches the specified search expression (if any), according to the
algorithm described below.

For a method to find a component given a simple
clientId, see #invokeOnComponent .

Component identifiers are required to be unique within the scope of
the closest ancestor NamingContainer  that encloses this
component (which might be this component itself). If there are no
NamingContainer  components in the ancestry of this component,
the root component in the tree is treated as if it were a
NamingContainer , whether or not its class actually implements
the NamingContainer  interface.

A search expression consists of either an
identifier (which is matched exactly against the id
property of a UIComponent , or a series of such identifiers
linked by the NamingContainer#SEPARATOR_CHAR  character value.
The search algorithm should operates as follows, though alternate
alogrithms may be used as long as the end result is the same:

Identify the UIComponent  that will be the base for searching,
by stopping as soon as one of the following conditions is met:

If the search expression begins with the the separator character
(called an "absolute" search expression),
the base will be the root UIComponent  of the component
tree. The leading separator character will be stripped off,
and the remainder of the search expression will be treated as
a "relative" search expression as described below.
Otherwise, if this UIComponent  is a
NamingContainer  it will serve as the basis.
Otherwise, search up the parents of this component. If
a NamingContainer  is encountered, it will be the base.

Otherwise (if no NamingContainer  is encountered)
the root UIComponent  will be the base.

The search expression (possibly modified in the previous step) is now
a "relative" search expression that will be used to locate the
component (if any) that has an id that matches, within
the scope of the base component. The match is performed as follows:

If the search expression is a simple identifier, this value is
compared to the id property, and then recursively
through the facets and children of the base UIComponent 
(except that if a descendant NamingContainer  is found,
its own facets and children are not searched).
If the search expression includes more than one identifier
separated by the separator character, the first identifier is
used to locate a NamingContainer  by the rules in the
previous bullet point. Then, the findComponent()
method of this NamingContainer  will be called, passing
the remainder of the search expression.

 abstract public Map getAttributes()
Return a mutable Map representing the attributes
(and properties, see below) associated wth this UIComponent ,
keyed by attribute name (which must be a String). The returned
implementation must support all of the standard and optional
Map methods, plus support the following additional
requirements:

The Map implementation must implement
the java.io.Serializable interface.
Any attempt to add a null key or value must
throw a NullPointerException.
Any attempt to add a key that is not a String must throw
a ClassCastException.
If the attribute name specified as a key matches a property
of this UIComponent 's implementation class, the following
methods will have special behavior:

containsKey - Return false.
get() - If the property is readable, call
the getter method and return the returned value (wrapping
primitive values in their corresponding wrapper classes);
otherwise throw IllegalArgumentException.
put() - If the property is writeable, call
the setter method to set the corresponding value (unwrapping
primitive values in their corresponding wrapper classes).
If the property is not writeable, or an attempt is made to
set a property of primitive type to null,
throw IllegalArgumentException.
remove - Throw
IllegalArgumentException.

 List getAttributesThatAreSet(boolean create) 
{
        // Class.getPackage() returns null for Groovy based-classes.
        Package pkg = this.getClass().getPackage();
        if (pkg != null) {
            String pkgName = this.getClass().getPackage().getName();
            if (create
                && Arrays.binarySearch(OPTIMIZED_PACKAGES, pkgName)  >= 0) {
                if (attributesThatAreSet == null) {
                    attributesThatAreSet = new ArrayList< String >(6);
                }
            }
        }
        return attributesThatAreSet;
}

 abstract public int getChildCount()
Return the number of child UIComponent s that are
associated with this UIComponent . If there are no
children, this method must return 0. The method must not cause
the creation of a child component list.

 abstract public List getChildren()
Return a mutable List representing the child
UIComponent s associated with this component. The returned
implementation must support all of the standard and optional
List methods, plus support the following additional
requirements:

The List implementation must implement
the java.io.Serializable interface.
Any attempt to add a null must throw
a NullPointerException
Any attempt to add an object that does not implement
UIComponent  must throw a ClassCastException.
Whenever a new child component is added, the parent
property of the child must be set to this component instance.
If the parent property of the child was already
non-null, the child must first be removed from its previous
parent (where it may have been either a child or a facet).
Whenever an existing child component is removed, the
parent property of the child must be set to
null.

 abstract public String getClientId(FacesContext context)
Return a client-side identifier for this component, generating
one if necessary. The associated Renderer , if any,
will be asked to convert the clientId to a form suitable for
transmission to the client.

The return from this method must be the same value throughout
the lifetime of the instance, unless the id property
of the component is changed, or the component is placed in
a NamingContainer  whose client ID changes (for example,
UIData ). However, even in these cases, consecutive
calls to this method must always return the same value. The
implementation must follow these steps in determining the
clientId:

Find the closest ancestor to this component in the view
hierarchy that implements NamingContainer. Call
getContainerClientId() on it and save the result as
the parentId local variable. Call #getId  on
this component and save the result as the
myId local variable. If myId is
null, call
context.getViewRoot().createUniqueId() and assign
the result to myId. If parentId is
non-null, let myId equal parentId
+ NamingContainer.SEPARATOR_CHAR + myId. Call Renderer#convertClientId , passing myId, and return
the result.

 public String getContainerClientId(FacesContext context) 
{
        if (context == null) {
            throw new NullPointerException();
        }
        return this.getClientId(context);
}

Allow components that implement NamingContainer to selectively disable prepending their clientId to their descendent's clientIds by breaking the prepending logic into a seperately callable method. See #getClientId for usage.

By default, this method will call through to #getClientId and return the result.

 abstract protected FacesContext getFacesContext()
Convenience method to return the FacesContext  instance
for the current request.

 abstract protected FacesListener[] getFacesListeners(Class clazz)
Return an array of registered FacesListener s that are
instances of the specified class. If there are no such registered
listeners, a zero-length array is returned. The returned
array can be safely be cast to an array strongly typed to
an element type of clazz.

 abstract public UIComponent getFacet(String name)
Convenience method to return the named facet, if it exists, or
null otherwise. If the requested facet does not
exist, the facets Map must not be created.

 public int getFacetCount() 
{
        return (getFacets().size());
}

Return the number of facet UIComponent s that are associated with this UIComponent . If there are no facets, this method must return 0. The method must not cause the creation of a facet component map.

For backwards compatability with classes that extend UIComponent directly, a default implementation is provided that simply calls #getFacets and then calls the size() method on the returned Map. A more optimized version of this method is provided in UIComponentBase#getFacetCount .

 abstract public Map getFacets()
Return a mutable Map representing the facet
UIComponent s associated with this UIComponent ,
keyed by facet name (which must be a String). The returned
implementation must support all of the standard and optional
Map methods, plus support the following additional
requirements:

The Map implementation must implement
the java.io.Serializable interface.
Any attempt to add a null key or value must
throw a NullPointerException.
Any attempt to add a key that is not a String must throw
a ClassCastException.
Any attempt to add a value that is not a UIComponent 
must throw a ClassCastException.
Whenever a new facet UIComponent  is added:

The parent property of the component must be set to
this component instance.
If the parent property of the component was already
non-null, the component must first be removed from its previous
parent (where it may have been either a child or a facet).

Whenever an existing facet UIComponent  is removed:

The parent property of the facet must be
set to null.

 abstract public Iterator getFacetsAndChildren()
Return an Iterator over the facet followed by child
UIComponent s of this UIComponent .
Facets are returned in an undefined order, followed by
all the children in the order they are stored in the child list. If this
component has no facets or children, an empty Iterator
is returned.

The returned Iterator must not support the
remove() operation.

 abstract public String getFamily()
Return the identifier of the component family to which this
component belongs. This identifier, in conjunction with the value
of the rendererType property, may be used to select
the appropriate Renderer  for this component instance.

 abstract public String getId()
Return the component identifier of this UIComponent .

 abstract public UIComponent getParent()
Return the parent UIComponent  of this
UIComponent, if any. A component must allow child
components to be added to and removed from the list of children
of this component, even though the child component returns null
from getParent( ).

 abstract protected Renderer getRenderer(FacesContext context)
Convenience method to return the Renderer  instance
associated with this component, if any; otherwise, return
null.

 abstract public String getRendererType()
Return the Renderer  type for this UIComponent 
(if any).

 abstract public boolean getRendersChildren()
Return a flag indicating whether this component is responsible
for rendering its child components. The default implementation
in UIComponentBase#getRendersChildren  tries to find the
renderer for this component. If it does, it calls Renderer#getRendersChildren  and returns the result. If it
doesn't, it returns false. As of version 1.2 of the JavaServer
Faces Specification, component authors are encouraged to return
true from this method and rely on UIComponentBase#encodeChildren .

 abstract public ValueBinding getValueBinding(String name)Deprecated! This -  has been replaced by #getValueExpression .

Call through to #getValueExpression  and examine the
result. If the result is an instance of the wrapper class
mandated in #setValueBinding , extract the
ValueBinding instance and return it. Otherwise,
wrap the result in an implementation of
ValueBinding, and return it.

 public ValueExpression getValueExpression(String name) 
{
    
        ValueExpression result = null;
        if (name == null) {
            throw new NullPointerException();
        }
        if (bindings == null) {
            if (!isUIComponentBase()) {
                ValueBinding binding = getValueBinding(name);
                if (null != binding) {
                    result = new ValueExpressionValueBindingAdapter(binding);
                    // Cache this for future reference.
                    //noinspection CollectionWithoutInitialCapacity
                    bindings = new HashMap< String, ValueExpression >();
                    bindings.put(name, result);
                }
            }
            return (result);
        } else {
            return (bindings.get(name));
        }
}

Return the ValueExpression used to calculate the value for the specified attribute or property name, if any.

This method must be overridden and implemented for components that comply with JSF 1.2 and later.

 public boolean invokeOnComponent(FacesContext context,
    String clientId,
    ContextCallback callback) throws FacesException 
{
        if (null == context || null == clientId || null == callback) {
            throw new NullPointerException();
        }
        boolean found = false;
        if (clientId.equals(this.getClientId(context))) {
            try {
                callback.invokeContextCallback(context, this);
                return true;
            } catch (Exception e) {
                throw new FacesException(e);
            }
        } else {
            Iterator< UIComponent > itr = this.getFacetsAndChildren();
            while (itr.hasNext() && !found) {
                found = itr.next().invokeOnComponent(context, clientId,
                        callback);
            }
        }
        return found;
}

Starting at this component in the View hierarchy, search for a component with a clientId equal to the argument clientId and, if found, call the ContextCallback#invokeContextCallback method on the argument callback, passing the current FacesContext and the found component as arguments. This method is similar to #findComponent but it does not support the leading NamingContainer#SEPARATOR_CHAR syntax for searching from the root of the View.

The default implementation will first check if this.getClientId() is equal to the argument clientId. If so, call the ContextCallback#invokeContextCallback method on the argument callback, passing through the FacesContext argument and passing this as the component argument. If an Exception is thrown by the callback, wrap it in a FacesException and re-throw it. Otherwise, return true.

Otherwise, for each component returned by #getFacetsAndChildren , call invokeOnComponent() passing the arguments to this method, in order. The first time invokeOnComponent() returns true, abort traversing the rest of the Iterator and return true.

When calling ContextCallback#invokeContextCallback the implementation of this method must guarantee that the state of the component passed to the callback correctly reflects the component's position in the View hierarchy with respect to any state found in the argument clientId. For example, an iterating component such as UIData will need to set its row index to correctly reflect the argument clientId before finding the appropriate child component backed by the correct row. When the callback returns, either normally or by throwing an Exception the implementation of this method must restore the state of the view to the way it was before invoking the callback.

If none of the elements from #getFacetsAndChildren returned true from invokeOnComponent(), return false.

Simple usage example to find a component by clientId.

private UIComponent found = null;

private void doFind(FacesContext context, String clientId) {
context.getViewRoot().invokeOnComponent(context, clientId,
new ContextCallback() {
public void invokeContextCallback(FacesContext context,
UIComponent component) {
found = component;
}
});
}

 abstract public boolean isRendered()
Return true if this component (and its children)
should be rendered during the Render Response phase
of the request processing lifecycle.

 abstract public  void processDecodes(FacesContext context)
Perform the component tree processing required by the
Apply Request Values phase of the request processing
lifecycle for all facets of this component, all children of this
component, and this component itself, as follows.

If the rendered property of this UIComponent 
is false, skip further processing.
Call the processDecodes() method of all facets
and children of this UIComponent , in the order determined
by a call to getFacetsAndChildren().
Call the decode() method of this component.
If a RuntimeException is thrown during
decode processing, call FacesContext#renderResponse 
and re-throw the exception.

 abstract public  void processRestoreState(FacesContext context,
    Object state)
Perform the component tree processing required by the
Restore View phase of the request processing
lifecycle for all facets of this component, all children of this
component, and this component itself, as follows.

Call the processRestoreState() method of all
facets and children of this UIComponent  in the order
determined by a call to getFacetsAndChildren().
Call the restoreState() method of this component.


This method may not be called if the state saving method is
set to server.

 abstract public Object processSaveState(FacesContext context)
Perform the component tree processing required by the state
saving portion of the Render Response phase of the
request processing lifecycle for all facets of this component,
all children of this component, and this component itself, as
follows.
 


consult the transient property of this
component. If true, just return null.

Call the processSaveState() method of all facets
and children of this UIComponent  in the order determined
by a call to getFacetsAndChildren(), skipping
children and facets that are transient.

Call the saveState() method of this component.

Encapsulate the child state and your state into a
Serializable Object and return it.



This method may not be called if the state saving method is
set to server.

 abstract public  void processUpdates(FacesContext context)
Perform the component tree processing required by the
Update Model Values phase of the request processing
lifecycle for all facets of this component, all children of this
component, and this component itself, as follows.

If the rendered property of this UIComponent 
is false, skip further processing.
Call the processUpdates() method of all facets
and children of this UIComponent , in the order determined
by a call to getFacetsAndChildren().

 abstract public  void processValidators(FacesContext context)
Perform the component tree processing required by the
Process Validations phase of the request processing
lifecycle for all facets of this component, all children of this
component, and this component itself, as follows.

If the rendered property of this UIComponent 
is false, skip further processing.
Call the processValidators() method of all facets
and children of this UIComponent , in the order determined
by a call to getFacetsAndChildren().

 abstract public  void queueEvent(FacesEvent event)
Queue an event for broadcast at the end of the current request
processing lifecycle phase. The default implementation in
UIComponentBase  must delegate this call to the
queueEvent() method of the parent UIComponent .

 abstract protected  void removeFacesListener(FacesListener listener)
Remove the specified FacesListener  from the set of listeners
registered to receive event notifications from this UIComponent .

 abstract public  void setId(String id)
Set the component identifier of this UIComponent  (if any).
Component identifiers must obey the following syntax restrictions:

Must not be a zero-length String.
First character must be a letter or an underscore ('_').
Subsequent characters must be a letter, a digit,
an underscore ('_'), or a dash ('-').



Component identifiers must also obey the following semantic
restrictions (note that this restriction is NOT
enforced by the setId() implementation):

The specified identifier must be unique among all the components
(including facets) that are descendents of the nearest ancestor
UIComponent  that is a NamingContainer , or within
the scope of the entire component tree if there is no such
ancestor that is a NamingContainer .

 abstract public  void setParent(UIComponent parent)
Set the parent UIComponent of this
UIComponent. This method must
never be called by developers; a UIComponent 's internal
implementation will call it as components are added to or
removed from a parent's child List or
facet Map.

 abstract public  void setRendered(boolean rendered)
Set the rendered property of this
UIComponent .

 abstract public  void setRendererType(String rendererType)
Set the Renderer  type for this UIComponent ,
or null for components that render themselves.

 abstract public  void setValueBinding(String name,
    ValueBinding binding)Deprecated! This -  has been replaced by #setValueExpression .

Wrap the argument binding in an implementation of
ValueExpression  and call through to #setValueExpression .

 public  void setValueExpression(String name,
    ValueExpression binding) 
{
        if (name == null) {
            throw new NullPointerException();
        } else if ("id".equals(name) || "parent".equals(name)) {
            throw new IllegalArgumentException();
        }
        if (binding != null) {
            if (!binding.isLiteralText()) {
                if (bindings == null) {
                    //noinspection CollectionWithoutInitialCapacity
                    bindings = new HashMap< String, ValueExpression >();
                }
                // add this binding name to the 'attributesThatAreSet' list
                List< String > sProperties = getAttributesThatAreSet(true);
                if (sProperties != null && !sProperties.contains(name)) {
                    sProperties.add(name);
                }
                bindings.put(name, binding);
            } else {
                ELContext context =
                    FacesContext.getCurrentInstance().getELContext();
                try {
                    getAttributes().put(name, binding.getValue(context));
                } catch (ELException ele) {
                    throw new FacesException(ele);
                }
            }
        } else {
            if (bindings != null) {
                // remove this binding name from the 'attributesThatAreSet' list
                List< String > sProperties = getAttributesThatAreSet(false);
                if (sProperties != null) {
                    sProperties.remove(name);
                }
                bindings.remove(name);
                if (bindings.isEmpty()) {
                    bindings = null;
                }
            }
        }
}

Set the ValueExpression used to calculate the value for the specified attribute or property name, if any.

The implementation must call ValueExpression#isLiteralText on the argument expression. If isLiteralText() returns true, invoke ValueExpression#getValue on the argument expression and pass the result as the value parameter in a call to this.#getAttributes() .put(name, value) where name is the argument name. If an exception is thrown as a result of calling ValueExpression#getValue , wrap it in a javax.faces.FacesException and re-throw it. If isLiteralText() returns false, simply store the un-evaluated expression argument in the collection of ValueExpressions under the key given by the argument name.

This method must be overridden and implemented for components that comply with JSF 1.2 and later.