/*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 package javax.faces.component;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFComponent;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFJspProperty;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFProperty;

 import javax.el.ValueExpression;

 import javax.faces.FacesException;

 import javax.faces.component.behavior.Behavior;

 import javax.faces.component.behavior.ClientBehavior;

 import javax.faces.component.visit.VisitCallback;

 import javax.faces.component.visit.VisitContext;

 import javax.faces.context.FacesContext;

 import javax.faces.el.ValueBinding;

 import javax.faces.event.AbortProcessingException;

 import javax.faces.event.BehaviorEvent;

 import javax.faces.event.FacesEvent;

 import javax.faces.event.FacesListener;

 import javax.faces.event.PostAddToViewEvent;

 import javax.faces.event.PostValidateEvent;

 import javax.faces.event.PreRemoveFromViewEvent;

 import javax.faces.event.PreRenderComponentEvent;

 import javax.faces.event.PreValidateEvent;

 import javax.faces.event.SystemEvent;

 import javax.faces.event.SystemEventListener;

 import javax.faces.render.RenderKit;

 import javax.faces.render.Renderer;

 import javax.faces.view.Location;

 import java.io.IOException;

 import java.io.Serializable;

 import java.lang.reflect.Array;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.faces.event.PhaseId;

 /**

  * Standard implementation of the UIComponent base class; all standard JSF components extend this class.

  * <p>

  * <i>Disclaimer</i>: The official definition for the behaviour of this class is the JSF 1.1 specification but for legal

  * reasons the specification cannot be replicated here. Any javadoc here therefore describes the current implementation

  * rather than the spec, though this class has been verified as correctly implementing the spec.

  * 

  * see Javadoc of <a href="http://java.sun.com/javaee/javaserverfaces/1.2/docs/api/index.html">JSF Specification</a> for

  * more.

  */

 @JSFComponent(type = "javax.faces.ComponentBase", family = "javax.faces.ComponentBase",

               desc = "base component when all components must inherit",

               tagClass = "javax.faces.webapp.UIComponentELTag", configExcluded = true)

 @JSFJspProperty(name = "binding", returnType = "javax.faces.component.UIComponent",

                 longDesc = "Identifies a backing bean property (of type UIComponent or appropriate subclass) to bind "

                            + "to this component instance. This value must be an EL expression.",

                 desc = "backing bean property to bind to this component instance")

 public abstract class UIComponentBase extends UIComponent

 {

     //private static Log log = LogFactory.getLog(UIComponentBase.class);

     private static Logger log = Logger.getLogger(UIComponentBase.class.getName());

     private static final Iterator<UIComponent> _EMPTY_UICOMPONENT_ITERATOR = new _EmptyIterator<UIComponent>();

     private static final String _STRING_BUILDER_KEY

             = "javax.faces.component.UIComponentBase.SHARED_STRING_BUILDER";

     static final int RESET_MODE_OFF = 0;

     static final int RESET_MODE_SOFT = 1;

     static final int RESET_MODE_HARD = 2;

     private _ComponentAttributesMap _attributesMap = null;

     private _PassThroughAttributesMap _passthroughAttributesMap = null;

     private List<UIComponent> _childrenList = null;

     private Map<String, UIComponent> _facetMap = null;

     private _DeltaList<FacesListener> _facesListeners = null;

     private String _clientId = null;

     private String _id = null;

     private UIComponent _parent = null;

     private boolean _transient = false;

     //private boolean _isRendererTypeSet = false;

     private String _rendererType;

     private String _markCreated;

     private String _facetName;

     //private boolean _addedByHandler = false;

     //private boolean _facetCreatedUIPanel = false;

     //private boolean _passthroughAttributesMapSet = false;

     private int _capabilities = 0;

     private final static int FLAG_IS_RENDERER_TYPE_SET = 1;

     private final static int FLAG_ADDED_BY_HANDLER = 2;

     private final static int FLAG_FACET_CREATED_UIPANEL = 4;

     private final static int FLAG_PASSTHROUGH_ATTRIBUTE_MAP_SET = 8;

     /**

      * This map holds ClientBehavior instances.

      * 

      *  Note that BehaviorBase implements PartialStateHolder, so this class 

      *  should deal with that fact on clearInitialState() and 

      *  markInitialState() methods.

      * 

      *  Also, the map used by this instance is not set from outside this class.

      *  

      *  Note it is possible (but maybe not expected/valid) to manipulate 

      *  the values of the map(the list) but not put instances on the map 

      *  directly, because ClientBehaviorHolder.getClientBehaviors says that 

      *  this method should return a non null unmodificable map.

      *  

      */

     private Map<String, List<ClientBehavior>> _behaviorsMap = null;

     private transient Map<String, List<ClientBehavior>> _unmodifiableBehaviorsMap = null;

     private transient FacesContext _facesContext;

     private transient Boolean _cachedIsRendered;

     private transient Renderer _cachedRenderer;

     public UIComponentBase()

     {

     }

     /**

      * Put the provided value-binding into a map of value-bindings associated with this component.

      * 

      * @deprecated Replaced by setValueExpression

      */

     @Override

     public void setValueBinding(String name, ValueBinding binding)

     {

         setValueExpression(name, binding == null ? null : new _ValueBindingToValueExpression(binding));

     }

     /**

      * Set an identifier for this component which is unique within the scope of the nearest ancestor NamingContainer

      * component. The id is not necessarily unique across all components in the current view.

      * <p>

      * The id must start with an underscore if it is generated by the JSF framework, and must <i>not</i> start with an

      * underscore if it has been specified by the user (eg in a JSP tag).

      * <p>

      * The first character of the id must be an underscore or letter. Following characters may be letters, digits,

      * underscores or dashes.

      * <p>

      * Null is allowed as a parameter, and will reset the id to null.

      * <p>

      * The clientId of this component is reset by this method; see getClientId for more info.

      * 

      * @throws IllegalArgumentException

      *             if the id is not valid.

      */

     @Override

     public void setId(String id)

     {

         isIdValid(id);

         _id = id;

         _clientId = null;

     }

     /**

      * <p>Set the parent <code>UIComponent</code> of this

      * <code>UIComponent</code>.</p>

      * 

      * @param parent The new parent, or <code>null</code> for the root node

      *  of a component tree

      */

     @Override

     public void setParent(UIComponent parent)

     {

         // removing kids OR this is UIViewRoot

         if (parent == null)

         {

             // not UIViewRoot...

             if (_parent != null && _parent.isInView())

             {

                 // trigger the "remove event" lifecycle

                 // and call setInView(false) for all children/facets

                 // doing this => recursive

                 FacesContext facesContext = getFacesContext();

                 if (facesContext.isProcessingEvents())

                 {

                     _publishPreRemoveFromViewEvent(facesContext, this);

                 }

                 else

                 {

                     _updateInView(this, false);

                 }

             }

             _parent = null;

         }

         else

         {

             _parent = parent;

             if (parent.isInView())

             {

                 // trigger the ADD_EVENT and call setInView(true)

                 // recursive for all kids/facets...

                 // Application.publishEvent(java.lang.Class, java.lang.Object)  must be called, passing 

                 // PostAddToViewEvent.class as the first argument and the newly added component as the second 

                 // argument.

                 FacesContext facesContext = parent.isCachedFacesContext() ?

                     parent.getFacesContext() : getFacesContext();

                 if (facesContext.isProcessingEvents())

                 {

                     _publishPostAddToViewEvent(facesContext, this);

                 }

                 else

                 {

                     _updateInView(this, true);

                 }

             }

         }

     }

     /**

      * Publish PostAddToViewEvent to the component and all facets and children.

      * 

      * @param context

      * @param component

      */

     private static void _publishPostAddToViewEvent(FacesContext context, UIComponent component)

     {

         component.setInView(true);

         context.getApplication().publishEvent(context, PostAddToViewEvent.class, component.getClass(), component);

         if (component.getChildCount() > 0)

         {

             // PostAddToViewEvent could cause component relocation

             // (h:outputScript, h:outputStylesheet, composite:insertChildren, composite:insertFacet)

             // so we need to check if the component was relocated or not

             List<UIComponent> children = component.getChildren();

             for (int i = 0; i < children.size(); i++)

             {

                 // spin on same index while component removed/replaced

                 // to prevent skipping components:

                 while (true)

                 {

                     UIComponent child = children.get(i);

                     child.pushComponentToEL(context, child);

                     try

                     {

                         _publishPostAddToViewEvent(context, child);

                     }

                     finally

                     {

                         child.popComponentFromEL(context);

                     }

                     if (i < children.size() && children.get(i) != child)

                     {

                         continue;

                     }

                     break;

                 }

             }

         }

         if (component.getFacetCount() > 0)

         {

             for (UIComponent child : component.getFacets().values())

             {

                 child.pushComponentToEL(context, child);

                 try

                 {

                     _publishPostAddToViewEvent(context, child);

                 }

                 finally

                 {

                     child.popComponentFromEL(context);

                 }

             }

         }        

     }

     /**

      * Publish PreRemoveFromViewEvent to the component and all facets and children.

      * 

      * @param context

      * @param component

      */

     private static void _publishPreRemoveFromViewEvent(FacesContext context, UIComponent component)

     {

         component.setInView(false);

         context.getApplication().publishEvent(context, PreRemoveFromViewEvent.class, component.getClass(), component);

         if (component.getChildCount() > 0)

         {

             for (int i = 0, childCount = component.getChildCount(); i < childCount; i++)

             {

                 UIComponent child = component.getChildren().get(i);

                 _publishPreRemoveFromViewEvent(context, child);

             }

         }

         if (component.getFacetCount() > 0)

         {

             for (UIComponent child : component.getFacets().values())

             {

                 _publishPreRemoveFromViewEvent(context, child);

             }

         }        

     }    

     private static void _updateInView(UIComponent component, boolean isInView)

     {

         component.setInView(isInView);

         if (component.getChildCount() > 0)

         {

             for (int i = 0, childCount = component.getChildCount(); i < childCount; i++)

             {

                 UIComponent child = component.getChildren().get(i);

                 _updateInView(child, isInView);

             }

         }

         if (component.getFacetCount() > 0)

         {

             for (UIComponent child : component.getFacets().values())

             {

                 _updateInView(child, isInView);

             }

         }        

     }  

     /**

      * 

      * @param eventName

      * @param behavior

      * 

      * @since 2.0

      */

     public void addClientBehavior(String eventName, ClientBehavior behavior)

     {

         Collection<String> eventNames = getEventNames();

         if(eventNames == null)

         {

             //component didn't implement getEventNames properly

             //log an error and return

             if(log.isLoggable(Level.SEVERE))

             {

                 log.severe("attempted to add a behavior to a component which did not properly "

                            + "implement getEventNames.  getEventNames must not return null");

                 return;

             }

         }

         if(eventNames.contains(eventName))

         {

             if(_behaviorsMap == null)

             {

                 _behaviorsMap = new HashMap<String,List<ClientBehavior>>();

             }

             List<ClientBehavior> behaviorsForEvent = _behaviorsMap.get(eventName);

             if(behaviorsForEvent == null)

             {

                 // Normally have client only 1 client behaviour per event name,

                 // so size 2 must be sufficient: 

                 behaviorsForEvent = new _DeltaList<ClientBehavior>(new ArrayList<ClientBehavior>(2));

                 _behaviorsMap.put(eventName, behaviorsForEvent);

             }

             behaviorsForEvent.add(behavior);

             _unmodifiableBehaviorsMap = null;

         }

     }

     /**

      * Invoke any listeners attached to this object which are listening for an event whose type matches the specified

      * event's runtime type.

      * <p>

      * This method does not propagate the event up to parent components, ie listeners attached to parent components

      * don't automatically get called.

      * <p>

      * If any of the listeners throws AbortProcessingException then that exception will prevent any further listener

      * callbacks from occurring, and the exception propagates out of this method without alteration.

      * <p>

      * ActionEvent events are typically queued by the renderer associated with this component in its decode method;

      * ValueChangeEvent events by the component's validate method. In either case the event's source property references

      * a component. At some later time the UIViewRoot component iterates over its queued events and invokes the

      * broadcast method on each event's source object.

      * 

      * @param event

      *            must not be null.

      */

     @Override

     public void broadcast(FacesEvent event) throws AbortProcessingException

     {

         if (event == null)

         {

             throw new NullPointerException("event");

         }

         if (event instanceof BehaviorEvent && event.getComponent() == this)

         {

             Behavior behavior = ((BehaviorEvent) event).getBehavior();

             behavior.broadcast((BehaviorEvent) event);

         }

         if (_facesListeners == null)

         {

             return;

         }

         // perf: _facesListeners is RandomAccess instance (javax.faces.component._DeltaList)

         for (int i = 0, size = _facesListeners.size(); i < size; i++)

         {

             FacesListener facesListener = _facesListeners.get(i);

             if (event.isAppropriateListener(facesListener))

             {

                 event.processListener(facesListener);

             }

         }

     }

     public void clearInitialState()

     {

         super.clearInitialState();

         if (_facesListeners != null)

         {

             _facesListeners.clearInitialState();

         }

         if (_behaviorsMap != null)

         {

             for (Map.Entry<String, List<ClientBehavior> > entry : _behaviorsMap.entrySet())

             {

                 ((PartialStateHolder) entry.getValue()).clearInitialState();

             }

         }

         if (_systemEventListenerClassMap != null)

         {

             for (Map.Entry<Class<? extends SystemEvent>, List<SystemEventListener>> entry : 

                 _systemEventListenerClassMap.entrySet())

             {

                 ((PartialStateHolder) entry.getValue()).clearInitialState();

             }

         }

         //_isRendererTypeSet = false;

         _capabilities &= ~(FLAG_IS_RENDERER_TYPE_SET);

     }

     /**

      * Check the submitted form parameters for data associated with this component. This default implementation

      * delegates to this component's renderer if there is one, and otherwise ignores the call.

      */

     @Override

     public void decode(FacesContext context)

     {

         if (context == null)

         {

             throw new NullPointerException("context");

         }

         setCachedRenderer(null);

         Renderer renderer = getRenderer(context);

         if (renderer != null)

         {

             setCachedRenderer(renderer);

             try

             {

                 renderer.decode(context, this);

             }

             finally

             {

                 setCachedRenderer(null);

             }

         }

     }

     public void encodeAll(FacesContext context) throws IOException

     {

         if (context == null)

         {

             throw new NullPointerException();

         }

         pushComponentToEL(context, this);

         try

         {

             setCachedIsRendered(null);

             boolean rendered;

             try

             {

                 setCachedFacesContext(context);

                 rendered = isRendered();

             }

             finally

             {

                 setCachedFacesContext(null);

             } 

             setCachedIsRendered(rendered);

             if (!rendered)

             {

                 setCachedIsRendered(null);

                 return;

             }

             setCachedRenderer(null);

             setCachedRenderer(getRenderer(context));

         }

         finally

         {

             popComponentFromEL(context);

         }

         try

         {

             //if (isRendered()) {

             this.encodeBegin(context);

             // rendering children

             boolean rendersChildren;

             try

             {

                 setCachedFacesContext(context);

                 rendersChildren = this.getRendersChildren();

             }

             finally

             {

                 setCachedFacesContext(null);

             }

             if (rendersChildren)

             {

                 this.encodeChildren(context);

             } // let children render itself

             else

             {

                 if (this.getChildCount() > 0)

                 {

                     for (int i = 0; i < this.getChildCount(); i++)

                     {

                         UIComponent comp = this.getChildren().get(i);

                         comp.encodeAll(context);

                     }

                 }

             }

             this.encodeEnd(context);

             //}

         }

         finally

         {

             setCachedIsRendered(null);

             setCachedRenderer(null);

         }

     }

     @Override

     public void encodeBegin(FacesContext context) throws IOException

     {

         if (context == null)

         {

             throw new NullPointerException("context");

         }

         try

         {

             setCachedFacesContext(context);

             // Call UIComponent.pushComponentToEL(javax.faces.context.FacesContext, javax.faces.component.UIComponent)

             pushComponentToEL(context, this);

             if (isRendered())

             {

                 // If our rendered property is true, render the beginning of the current state of this

                 // UIComponent to the response contained in the specified FacesContext.

                 // Call Application.publishEvent(java.lang.Class, java.lang.Object), passing BeforeRenderEvent.class as

                 // the first argument and the component instance to be rendered as the second argument.

                 // The main issue we have here is that the listeners are normally just registered

                 // to UIComponent, how do we deal with inherited ones?

                 // We have to ask the EG

                 context.getApplication().publishEvent(context,  PreRenderComponentEvent.class, UIComponent.class, this);

                 Renderer renderer = getRenderer(context);

                 if (renderer != null)

                 {

                     // If a Renderer is associated with this UIComponent, the actual encoding will be delegated to

                     // Renderer.encodeBegin(FacesContext, UIComponent).

                     renderer.encodeBegin(context, this);

                 }

             }

         }

         finally

         {

             setCachedFacesContext(null);

         }

     }

     @Override

     public void encodeChildren(FacesContext context) throws IOException

     {

         if (context == null)

         {

             throw new NullPointerException("context");

         }

         boolean isCachedFacesContext = isCachedFacesContext();

         try

         {

             if (!isCachedFacesContext)

             {

                 setCachedFacesContext(context);

             }

             if (isRendered())

             {

                 // If our rendered property is true, render the child UIComponents of this UIComponent.

                 Renderer renderer = getRenderer(context);

                 if (renderer == null)

                 {

                     // If no Renderer is associated with this UIComponent, iterate over each of the children of this

                     // component and call UIComponent.encodeAll(javax.faces.context.FacesContext).

                     if (getChildCount() > 0)

                     {

                         for (int i = 0, childCount = getChildCount(); i < childCount; i++)

                         {

                             UIComponent child = getChildren().get(i);

                             child.encodeAll(context);

                         }

                     }

                 }

                 else

                 {

                     // If a Renderer is associated with this UIComponent, the actual encoding will be delegated to

                     // Renderer.encodeChildren(FacesContext, UIComponent).

                     renderer.encodeChildren(context, this);

                 }

             }

         }

         finally

         {

             if (!isCachedFacesContext)

             {

                 setCachedFacesContext(null);

             }

         }

     }

     @Override

     public void encodeEnd(FacesContext context) throws IOException

     {

         if (context == null)

         {

             throw new NullPointerException("context");

         }

         try

         {

             setCachedFacesContext(context);

             if (isRendered())

             {

                 // If our rendered property is true, render the ending of the current state of this UIComponent.

                 Renderer renderer = getRenderer(context);

                 if (renderer != null)

                 {

                     // If a Renderer is associated with this UIComponent, the actual encoding will be delegated to

                     // Renderer.encodeEnd(FacesContext, UIComponent).

                     renderer.encodeEnd(context, this);

                 }

             }

         }

         finally

         {

             // Call UIComponent.popComponentFromEL(javax.faces.context.FacesContext). before returning regardless

             // of the value of the rendered property.

             popComponentFromEL(context);

             setCachedFacesContext(null);

         }

     }

     /**

      * Standard method for finding other components by id, inherited by most UIComponent objects.

      * <p>

      * The lookup is performed in a manner similar to finding a file in a filesystem; there is a "base" at which to

      * start, and the id can be for something in the "local directory", or can include a relative path. Here,

      * NamingContainer components fill the role of directories, and ":" is the "path separator". Note, however, that

      * although components have a strict parent/child hierarchy, component ids are only prefixed ("namespaced") with the

      * id of their parent when the parent is a NamingContainer.

      * <p>

      * The base node at which the search starts is determined as follows:

      * <ul>

      * <li>When expr starts with ':', the search starts with the root component of the tree that this component is in

      * (ie the ancestor whose parent is null).

      * <li>Otherwise, if this component is a NamingContainer then the search starts with this component.

      * <li>Otherwise, the search starts from the nearest ancestor NamingContainer (or the root component if there is no

      * NamingContainer ancestor).

      * </ul>

      * 

      * @param expr

      *            is of form "id1:id2:id3".

      * @return UIComponent or null if no component with the specified id is found.

      */

     @Override

     public UIComponent findComponent(String expr)

     {

         if (expr == null)

         {

             throw new NullPointerException("expr");

         }

         if (expr.length() == 0)

         {

             return null;

         }

         char separatorChar = getFacesContext().getNamingContainerSeparatorChar();

         UIComponent findBase;

         if (expr.charAt(0) == separatorChar)

         {

             findBase = _ComponentUtils.getRootComponent(this);

             expr = expr.substring(1);

         }

         else

         {

             if (this instanceof NamingContainer)

             {

                 findBase = this;

             }

             else

             {

                 findBase = _ComponentUtils.findParentNamingContainer(this, true /* root if not found */);

             }

         }

         int separator = expr.indexOf(separatorChar);

         if (separator == -1)

         {

             return _ComponentUtils.findComponent(findBase, expr, separatorChar);

         }

         String id = expr.substring(0, separator);

         findBase = _ComponentUtils.findComponent(findBase, id, separatorChar);

         if (findBase == null)

         {

             return null;

         }

         if (!(findBase instanceof NamingContainer))

         {

             throw new IllegalArgumentException("Intermediate identifier " + id + " in search expression " + expr

                     + " identifies a UIComponent that is not a NamingContainer");

         }

         return findBase.findComponent(expr.substring(separator + 1));

     }

     /**

      * Get a map through which all the UIComponent's properties, value-bindings and non-property attributes can be read

      * and written.

      * <p>

      * When writing to the returned map:

      * <ul>

      * <li>If this component has an explicit property for the specified key then the setter method is called. An

      * IllegalArgumentException is thrown if the property is read-only. If the property is readable then the old value

      * is returned, otherwise null is returned.

      * <li>Otherwise the key/value pair is stored in a map associated with the component.

      * </ul>

      * Note that value-bindings are <i>not</i> written by put calls to this map. Writing to the attributes map using a

      * key for which a value-binding exists will just store the value in the attributes map rather than evaluating the

      * binding, effectively "hiding" the value-binding from later attributes.get calls. Setter methods on components

      * commonly do <i>not</i> evaluate a binding of the same name; they just store the provided value directly on the

      * component.

      * <p>

      * When reading from the returned map:

      * <ul>

      * <li>If this component has an explicit property for the specified key then the getter method is called. If the

      * property exists, but is read-only (ie only a setter method is defined) then an IllegalArgumentException is

      * thrown.

      * <li>If the attribute map associated with the component has an entry with the specified key, then that is

      * returned.

      * <li>If this component has a value-binding for the specified key, then the value-binding is evaluated to fetch the

      * value.

      * <li>Otherwise, null is returned.

      * </ul>

      * Note that components commonly define getter methods such that they evaluate a value-binding of the same name if

      * there isn't yet a local property.

      * <p>

      * Assigning values to the map which are not explicit properties on the underlying component can be used to "tunnel"

      * attributes from the JSP tag (or view-specific equivalent) to the associated renderer without modifying the

      * component itself.

      * <p>

      * Any value-bindings and non-property attributes stored in this map are automatically serialized along with the

      * component when the view is serialized.

      */

     @Override

     public Map<String, Object> getAttributes()

     {

         if (_attributesMap == null)

         {

             _attributesMap = new _ComponentAttributesMap(this);

         }

         return _attributesMap;

     }

     @Override

     public Map<String, Object> getPassThroughAttributes(boolean create)

     {

         // Take into account the param "create" in MyFaces case does not have

         // sense at all

         if (_passthroughAttributesMap == null)

         {

             if (!create)

             {

                 if ((_capabilities & FLAG_PASSTHROUGH_ATTRIBUTE_MAP_SET) != 0)

                 {

                     // Was already created, return wrapper

                     _passthroughAttributesMap = new _PassThroughAttributesMap(this);

                 }

             }

             else

             {

                 _passthroughAttributesMap = new _PassThroughAttributesMap(this);

                 _capabilities |= FLAG_PASSTHROUGH_ATTRIBUTE_MAP_SET;

             }

         }

         return _passthroughAttributesMap;

     }

     /**

      * Return the number of direct child components this component has.

      * <p>

      * Identical to getChildren().size() except that when this component has no children this method will not force an

      * empty list to be created.

      */

     @Override

     public int getChildCount()

     {

         return _childrenList == null ? 0 : _childrenList.size();

     }

     /**

      * Return a list of the UIComponent objects which are direct children of this component.

      * <p>

      * The list object returned has some non-standard behaviour:

      * <ul>

      * <li>The list is type-checked; only UIComponent objects can be added.

      * <li>If a component is added to the list with an id which is the same as some other component in the list then an

      * exception is thrown. However multiple components with a null id may be added.

      * <li>The component's parent property is set to this component. If the component already had a parent, then the

      * component is first removed from its original parent's child list.

      * </ul>

      */

     @Override

     public List<UIComponent> getChildren()

     {

         if (_childrenList == null)

         {

             _childrenList = new _ComponentChildrenList(this);

         }

         return _childrenList;

     }

     /**

      * 

      * @return

      * 

      * @since 2.0

      */

     public Map<String,List<ClientBehavior>> getClientBehaviors()

     {

         if(_behaviorsMap == null)

         {

             return Collections.emptyMap();

         }

         return wrapBehaviorsMap();

     }

     /**

      * Get a string which can be output to the response which uniquely identifies this UIComponent within the current

      * view.

      * <p>

      * The component should have an id attribute already assigned to it; however if the id property is currently null

      * then a unique id is generated and set for this component. This only happens when components are programmatically

      * created without ids, as components created by a ViewHandler should be assigned ids when they are created.

      * <p>

      * If this component is a descendant of a NamingContainer then the client id is of form

      * "{namingContainerId}:{componentId}". Note that the naming container's id may itself be of compound form if it has

      * an ancestor naming container. Note also that this only applies to naming containers; other UIComponent types in

      * the component's ancestry do not affect the clientId.

      * <p>

      * Finally the renderer associated with this component is asked to convert the id into a suitable form. This allows

      * escaping of any characters in the clientId which are significant for the markup language generated by that

      * renderer.

      */

     @Override

     public String getClientId(FacesContext context)

     {

         if (context == null)

         {

             throw new NullPointerException("context");

         }

         if (_clientId != null)

         {

             return _clientId;

         }

         //boolean idWasNull = false;

         String id = getId();

         if (id == null)

         {

             // Although this is an error prone side effect, we automatically create a new id

             // just to be compatible to the RI

             // The documentation of UniqueIdVendor says that this interface should be implemented by

             // components that also implements NamingContainer. The only component that does not implement

             // NamingContainer but UniqueIdVendor is UIViewRoot. Anyway we just can't be 100% sure about this

             // fact, so it is better to scan for the closest UniqueIdVendor. If it is not found use 

             // viewRoot.createUniqueId, otherwise use UniqueIdVendor.createUniqueId(context,seed).

             UniqueIdVendor parentUniqueIdVendor = _ComponentUtils.findParentUniqueIdVendor(this);

             if (parentUniqueIdVendor == null)

             {

                 UIViewRoot viewRoot = context.getViewRoot();

                 if (viewRoot != null)

                 {

                     id = viewRoot.createUniqueId();

                 }

                 else

                 {

                     // The RI throws a NPE

                     String location = getComponentLocation(this);

                     throw new FacesException("Cannot create clientId. No id is assigned for component"

                             + " to create an id and UIViewRoot is not defined: "

                             + getPathToComponent(this)

                             + (location != null ? " created from: " + location : ""));

                 }

             }

             else

             {

                 id = parentUniqueIdVendor.createUniqueId(context, null);

             }

             setId(id);

             // We remember that the id was null and log a warning down below

             // idWasNull = true;

         }

         UIComponent namingContainer = _ComponentUtils.findParentNamingContainer(this, false);

         if (namingContainer != null)

         {

             String containerClientId = namingContainer.getContainerClientId(context);

             if (containerClientId != null)

             {

                 StringBuilder bld = _getSharedStringBuilder(context);

                 _clientId = bld.append(containerClientId).append(

                                       context.getNamingContainerSeparatorChar()).append(id).toString();

             }

             else

             {

                 _clientId = id;

             }

         }

         else

         {

             _clientId = id;

         }

         Renderer renderer = getRenderer(context);

         if (renderer != null)

         {

             _clientId = renderer.convertClientId(context, _clientId);

         }

         // -=Leonardo Uribe=- In jsf 1.1 and 1.2 this warning has sense, but in jsf 2.0 it is common to have

         // components without any explicit id (UIViewParameter components and UIOuput resource components) instances.

         // So, this warning is becoming obsolete in this new context and should be removed.

         //if (idWasNull && log.isLoggable(Level.WARNING))

         //{

         //    log.warning("WARNING: Component " + _clientId

         //            + " just got an automatic id, because there was no id assigned yet. "

         //            + "If this component was created dynamically (i.e. not by a JSP tag) you should assign it an "

         //            + "explicit static id or assign it the id you get from "

         //            + "the createUniqueId from the current UIViewRoot "

         //            + "component right after creation! Path to Component: " + getPathToComponent(this));

         //}

         return _clientId;

     }

     /**

      * 

      * @return

      * 

      * @since 2.0

      */

     public String getDefaultEventName()

     {

         // if a default event exists for a component, this method is overriden thus assume null

         return null;

     }

     /**

      * 

      * @return

      * 

      * @since 2.0

      */

     public Collection<String> getEventNames()

     {

         // must be specified by the implementing component.

         // Returning null will force an error message in addClientBehavior.

         return null;

     }

     @Override

     public UIComponent getFacet(String name)

     {

         return _facetMap == null ? null : _facetMap.get(name);

     }

     /**

      * @since 1.2

      */

     @Override

     public int getFacetCount()

     {

         return _facetMap == null ? 0 : _facetMap.size();

     }

     @Override

     public Map<String, UIComponent> getFacets()

     {

         if (_facetMap == null)

         {

             _facetMap = new _ComponentFacetMap<UIComponent>(this);

         }

         return _facetMap;

     }

     @Override

     public Iterator<UIComponent> getFacetsAndChildren()

     {

         // we can't use _facetMap and _childrenList here directly,

         // because some component implementation could keep their 

         // own properties for facets and children and just override

         // getFacets() and getChildren() (e.g. seen in PrimeFaces).

         // See MYFACES-2611 for details.

         if (getFacetCount() == 0)

         {

             if (getChildCount() == 0)

             {

                 return _EMPTY_UICOMPONENT_ITERATOR;

             }

             return getChildren().iterator();

         }

         else

         {

             if (getChildCount() == 0)

             {

                 return getFacets().values().iterator();

             }

             return new _FacetsAndChildrenIterator(getFacets(), getChildren());

         }

     }

     /**

      * Get a string which uniquely identifies this UIComponent within the scope of the nearest ancestor NamingContainer

      * component. The id is not necessarily unique across all components in the current view.

      */

     @JSFProperty(rtexprvalue = true)

     public String getId()

     {

         return _id;

     }

     @Override

     public UIComponent getParent()

     {

         return _parent;

     }

     @Override

     public String getRendererType()

     {

         // rendererType is literal-only, no ValueExpression - MYFACES-3136:

         // Even if this is true, according to JSF spec section 8 Rendering Model,

         // this part is essential to implement "delegated implementation" pattern,

         // so we can't do this optimization here. Instead, JSF developers could prevent

         // this evaluation overriding this method directly.

         if (_rendererType != null)

         {

             return _rendererType;

         }

         ValueExpression expression = getValueExpression("rendererType");

         if (expression != null)

         {

             return (String) expression.getValue(getFacesContext().getELContext());

         }

         return null;

     }

     /**

      * Indicates whether this component or its renderer manages the invocation of the rendering methods of its child

      * components. When this is true:

      * <ul>

      * <li>This component's encodeBegin method will only be called after all the child components have been created and

      * added to this component. <li>This component's encodeChildren method will be called after its encodeBegin method.

      * Components for which this method returns false do not get this method invoked at all. <li>No rendering methods

      * will be called automatically on child components; this component is required to invoke the

      * encodeBegin/encodeEnd/etc on them itself.

      * </ul>

      */

     @Override

     public boolean getRendersChildren()

     {

         Renderer renderer = getRenderer(getFacesContext());

         return renderer != null ? renderer.getRendersChildren() : false;

     }

     /**

      * Get the named value-binding associated with this component.

      * <p>

      * Value-bindings are stored in a map associated with the component, though there is commonly a property

      * (setter/getter methods) of the same name defined on the component itself which evaluates the value-binding when

      * called.

      * 

      * @deprecated Replaced by getValueExpression

      */

     @Override

     public ValueBinding getValueBinding(String name)

     {

         ValueExpression expression = getValueExpression(name);

         if (expression != null)

         {

             if (expression instanceof _ValueBindingToValueExpression)

             {

                 return ((_ValueBindingToValueExpression) expression).getValueBinding();

             }

             return new _ValueExpressionToValueBinding(expression);

         }

         return null;

     }

     /**

      * <code>invokeOnComponent</code> must be implemented in <code>UIComponentBase</code> too...

      */

     @Override

     public boolean invokeOnComponent(FacesContext context, String clientId, ContextCallback callback)

             throws FacesException

     {

         if (isCachedFacesContext())

         {

             return super.invokeOnComponent(context, clientId, callback);

         }

         else

         {

             try

             {

                 setCachedFacesContext(context);

                 return super.invokeOnComponent(context, clientId, callback);

             }

             finally

             {

                 setCachedFacesContext(null);

             }

         }

     }

     @Override

     public boolean visitTree(VisitContext context, VisitCallback callback)

     {

         if (isCachedFacesContext())

         {

             return super.visitTree(context, callback);

         }

         else

         {

             try

             {

                 setCachedFacesContext(context.getFacesContext());

                 return super.visitTree(context, callback);

             }

             finally

             {

                 setCachedFacesContext(null);

             }

         }

     }

     /**

      * A boolean value that indicates whether this component should be rendered. Default value: true.

      **/

     @Override

     @JSFProperty

     public boolean isRendered()

     {

         if (_cachedIsRendered != null)

         {

             return Boolean.TRUE.equals(_cachedIsRendered);

         }

         return (Boolean) getStateHelper().eval(PropertyKeys.rendered, DEFAULT_RENDERED);

     }

     @JSFProperty(literalOnly = true, istransient = true, tagExcluded = true)

     public boolean isTransient()

     {

         return _transient;

     }

     public void markInitialState()

     {

         super.markInitialState();

         // Enable copyFullInitialState behavior when delta is written into this component.

         ((_DeltaStateHelper)getStateHelper()).setCopyFullInitialState(true);

         if (_facesListeners != null)

         {

             _facesListeners.markInitialState();

         }

         if (_behaviorsMap != null)

         {

             for (Map.Entry<String, List<ClientBehavior> > entry : _behaviorsMap.entrySet())

             {

                 ((PartialStateHolder) entry.getValue()).markInitialState();

             }

         }

         if (_systemEventListenerClassMap != null)

         {

             for (Map.Entry<Class<? extends SystemEvent>, List<SystemEventListener>> entry : 

                 _systemEventListenerClassMap.entrySet())

             {

                 ((PartialStateHolder) entry.getValue()).markInitialState();

             }

         }

     }

     @Override

     protected void addFacesListener(FacesListener listener)

     {

         if (listener == null)

         {

             throw new NullPointerException("listener");

         }

         if (_facesListeners == null)

         {

             // How many facesListeners have single component normally? 

             _facesListeners = new _DeltaList<FacesListener>(new ArrayList<FacesListener>(5));

         }

         _facesListeners.add(listener);

     }

     @Override

     protected FacesContext getFacesContext()

     {

         if (_facesContext == null)

         {

             return FacesContext.getCurrentInstance();

         }

         else

         {

             return _facesContext;

         }

     }

     // FIXME: Notify EG for generic usage

     @Override

     protected FacesListener[] getFacesListeners(Class clazz)

     {

         if (clazz == null)

         {

             throw new NullPointerException("Class is null");

         }

         if (!FacesListener.class.isAssignableFrom(clazz))

         {

             throw new IllegalArgumentException("Class " + clazz.getName() + " must implement " + FacesListener.class);

         }

         if (_facesListeners == null)

         {

             return (FacesListener[]) Array.newInstance(clazz, 0);

         }

         List<FacesListener> lst = null;

         // perf: _facesListeners is RandomAccess instance (javax.faces.component._DeltaList)

         for (int i = 0, size = _facesListeners.size(); i < size; i++)

         {

             FacesListener facesListener = _facesListeners.get(i);

             if (facesListener != null && clazz.isAssignableFrom(facesListener.getClass()))

             {

                 if (lst == null)

                 {

                     lst = new ArrayList<FacesListener>();

                 }

                 lst.add(facesListener);

             }

         }

         if (lst == null)

         {

             return (FacesListener[]) Array.newInstance(clazz, 0);

         }

         return lst.toArray((FacesListener[]) Array.newInstance(clazz, lst.size()));

     }

     @Override

     protected Renderer getRenderer(FacesContext context)

     {

         if (context == null)

         {

             throw new NullPointerException("context");

         }

         Renderer renderer = getCachedRenderer();

         if (renderer != null)

         {