Coverage Report

Coverage Report - javax.faces.component.UIComponentBase

Classes in this File

Line Coverage

Branch Coverage

Complexity

UIComponentBase

100%

337/337

92%

170/184

2.964

UIComponentBase$NullRenderer

100%

2/2

N/A

2.964

 /*
  * Copyright 2004-2011 the Seasar Foundation and the Others.
  *
  * Licensed 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 java.io.IOException;
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
 import javax.faces.context.FacesContext;
 import javax.faces.el.ValueBinding;
 import javax.faces.event.AbortProcessingException;
 import javax.faces.event.FacesEvent;
 import javax.faces.event.FacesListener;
 import javax.faces.internal.AttachedObjectStateWrapper;
 import javax.faces.internal.ComponentAttributesMap;
 import javax.faces.internal.ComponentChildrenListWrapper;
 import javax.faces.internal.ComponentFacetAndChildrenIterator;
 import javax.faces.internal.ComponentFacetMapWrapper;
 import javax.faces.internal.SerializableStateHolder;
 import javax.faces.internal.UIComponentUtil;
 import javax.faces.render.Renderer;
 
 import org.seasar.framework.util.AssertionUtil;
 
 /**
  * @author shot
  * @author manhole
  */
 public abstract class UIComponentBase extends UIComponent {
 
     private String id;
 
     private ComponentAttributesMap attributesMap = null;
 
     private Map bindingMap = new HashMap();
 
     private UIComponent parent;
 
     private String clientId = null;
 
     private Boolean isRendered;
 
     private String renderType = null;
 
     private List childrenList = null;
 
     private Map facetMap = null;
 
     private List listeners = null;
 
     private boolean isTransient = false;
 
     private String uniqueId;
 
     private static final String RENDERED = "rendered";
 
     private static final String RENDERER_TYPE = "rendererType";
 
     private static final int LIST_NULL_SIZE = 0;
 
     public Map getAttributes() {
         if (attributesMap == null) {
             attributesMap = new ComponentAttributesMap(this);
         }
         return attributesMap;
     }
 
     public ValueBinding getValueBinding(String name) {
         AssertionUtil.assertNotNull("name", name);
         return (ValueBinding) bindingMap.get(name);
     }
 
     public void setValueBinding(String name, ValueBinding binding) {
         AssertionUtil.assertNotNull("name", name);
         if (name.equals("id") || name.equals("parent")) {
             throw new IllegalArgumentException("invalid name is specified");
         }
         if (binding != null) {
             bindingMap.put(name, binding);
         } else {
             bindingMap.remove(name);
         }
     }
 
     public String getClientId(FacesContext context) {
         AssertionUtil.assertNotNull("context", context);
         if (clientId == null) {
             clientId = createClientId(context);
         }
         return clientId;
     }
 
     private String createClientId(FacesContext context) {
         StringBuffer buf = new StringBuffer(32);
         for (UIComponent component = getParent(); component != null; component = component
                 .getParent()) {
             if (component instanceof NamingContainer) {
                 buf.append(component.getClientId(context)).append(
                         NamingContainer.SEPARATOR_CHAR);
                 break;
             }
         }
         buf.append(context.getExternalContext().encodeNamespace(
                 (id != null) ? id : getUniqueId(context)));
         String clientId = buf.toString();
         Renderer renderer = getRenderer(context);
         if (renderer != null) {
             clientId = renderer.convertClientId(context, clientId);
         }
         return clientId;
     }
 
     private String getUniqueId(FacesContext context) {
         if (uniqueId == null) {
             uniqueId = context.getViewRoot().createUniqueId();
         }
         return uniqueId;
     }
 
     public String getId() {
         return id;
     }
 
     public void setId(String id) {
         validateId(id);
         this.id = id;
         clientId = null;
     }
 
     public UIComponent getParent() {
         return parent;
     }
 
     public void setParent(UIComponent parent) {
         this.parent = parent;
     }
 
     public boolean isRendered() {
         if (isRendered != null) {
             return isRendered.booleanValue();
         }
         Boolean v = null;
         ValueBinding vb = getValueBinding(RENDERED);
         if (vb != null) {
             v = ((Boolean) this.getValueFromBinding(vb));
         }
         if (v != null) {
             return v.booleanValue();
         } else {
             return true;
         }
     }
 
     public void setRendered(boolean isRendered) {
         this.isRendered = Boolean.valueOf(isRendered);
     }
 
     public String getRendererType() {
         if (renderType != null) {
             return renderType;
         }
         ValueBinding vb = getValueBinding(RENDERER_TYPE);
         String result = null;
         if (vb != null) {
             result = (String) this.getValueFromBinding(vb);
         }
         return result;
     }
 
     public void setRendererType(String renderType) {
         this.renderType = renderType;
     }
 
     private Object getValueFromBinding(ValueBinding vb) {
         return vb.getValue(getFacesContext());
     }
 
     public boolean getRendersChildren() {
         boolean result = false;
         Renderer renderer = getRenderer(getFacesContext());
         if (getRendererType() != null && renderer != null) {
             result = renderer.getRendersChildren();
         }
         return result;
     }
 
     public List getChildren() {
         if (childrenList == null) {
             childrenList = new ComponentChildrenListWrapper(this);
         }
         return childrenList;
     }
 
     public int getChildCount() {
         return (childrenList != null) ? childrenList.size() : LIST_NULL_SIZE;
     }
 
     public UIComponent findComponent(String expr) {
         AssertionUtil.assertNotNull("expr", expr);
         UIComponent base = this;
         if (expr.charAt(0) == NamingContainer.SEPARATOR_CHAR) {
             getComponentRoot(base);
             expr = expr.substring(1);
         } else {
             for (; base.getParent() != null; base = base.getParent()) {
                 if (base instanceof NamingContainer) {
                     break;
                 }
             }
         }
 
         UIComponent result = null;
         while (expr.length() > 0) {
             String id = null;
             int separator = expr.indexOf(NamingContainer.SEPARATOR_CHAR);
             if (separator >= 0) {
                 id = expr.substring(0, separator);
                 expr = expr.substring(separator + 1);
             } else {
                 id = expr;
                 expr = null;
             }
 
             result = findComponent(base, id);
             if (result == null || expr == null) {
                 break;
             }
             if (result instanceof NamingContainer) {
                 result = result.findComponent(expr);
                 break;
             } else {
                 throw new IllegalArgumentException(id);
             }
         }
         return result;
     }
 
     private UIComponent findComponent(UIComponent base, String id) {
         if (containsSameId(base, id)) {
             return base;
         }
 
         UIComponent child = null;
         UIComponent result = null;
         for (Iterator itr = base.getFacetsAndChildren(); itr.hasNext();) {
             child = (UIComponent) itr.next();
             if (!(child instanceof NamingContainer)) {
                 result = findComponent(child, id);
                 if (result != null) {
                     break;
                 }
             } else if (containsSameId(child, id)) {
                 result = child;
                 break;
             }
         }
         return result;
     }
 
     protected boolean containsSameId(UIComponent base, String id) {
         return id.equals(base.getId());
     }
 
     protected UIComponent getComponentRoot(UIComponent base) {
         UIComponent parent;
         for (parent = base; parent.getParent() != null; parent = parent
                 .getParent()) {
             ;
         }
         return parent;
     }
 
     public Map getFacets() {
         if (facetMap == null) {
             facetMap = new ComponentFacetMapWrapper(this);
         }
         return facetMap;
     }
 
     public UIComponent getFacet(String name) {
         return (facetMap != null) ? (UIComponent) facetMap.get(name) : null;
     }
 
     public Iterator getFacetsAndChildren() {
         return new ComponentFacetAndChildrenIterator(facetMap, childrenList);
     }
 
     public void broadcast(FacesEvent event) throws AbortProcessingException {
         AssertionUtil.assertNotNull("event", event);
         if (listeners != null) {
             for (Iterator itr = listeners.iterator(); itr.hasNext();) {
                 FacesListener listener = (FacesListener) itr.next();
                 if (event.isAppropriateListener(listener)) {
                     event.processListener(listener);
                 }
             }
         }
     }
 
     public void decode(FacesContext context) {
         AssertionUtil.assertNotNull("context", context);
         Renderer renderer = getRendererForEncodeOrDecode(context);
         renderer.decode(context, this);
     }
 
     public void encodeBegin(FacesContext context) throws IOException {
         AssertionUtil.assertNotNull("context", context);
         if (!isRendered()) {
             return;
         }
 
         Renderer renderer = getRendererForEncodeOrDecode(context);
         renderer.encodeBegin(context, this);
     }
 
     public void encodeChildren(FacesContext context) throws IOException {
         AssertionUtil.assertNotNull("context", context);
         if (!isRendered()) {
             return;
         }
         Renderer renderer = getRendererForEncodeOrDecode(context);
         renderer.encodeChildren(context, this);
     }
 
     public void encodeEnd(FacesContext context) throws IOException {
         AssertionUtil.assertNotNull("context", context);
         if (!isRendered()) {
             return;
         }
         Renderer renderer = getRendererForEncodeOrDecode(context);
         renderer.encodeEnd(context, this);
     }
 
     private Renderer getRendererForEncodeOrDecode(FacesContext context) {
         Renderer renderer = getRenderer(context);
         if (renderer == null) {
             renderer = new NullRenderer();
         }
         return renderer;
     }
 
     protected void addFacesListener(FacesListener listener) {
         AssertionUtil.assertNotNull("listener", listener);
         if (listeners == null) {
             listeners = new ArrayList();
         }
         listeners.add(listener);
     }
 
     protected FacesListener[] getFacesListeners(Class clazz) {
         AssertionUtil.assertNotNull("class", clazz);
         if (!FacesListener.class.isAssignableFrom(clazz)) {
             throw new IllegalArgumentException(clazz.getName()
                     + " is not FacesListener");
         }
 
         if (listeners == null) {
             return (FacesListener[]) Array.newInstance(clazz, 0);
         }
 
         List result = new ArrayList();
         FacesListener listener = null;
         for (Iterator itr = listeners.iterator(); itr.hasNext();) {
             listener = (FacesListener) itr.next();
             if (clazz.isAssignableFrom(listener.getClass())) {
                 result.add(listener);
             }
         }
 
         Object[] args = (Object[]) Array.newInstance(clazz, result.size());
         return (FacesListener[]) result.toArray(args);
     }
 
     protected void removeFacesListener(FacesListener listener) {
         AssertionUtil.assertNotNull("listener", listener);
 
         if (listeners != null) {
             listeners.remove(listener);
         }
     }
 
     public void queueEvent(FacesEvent event) {
         AssertionUtil.assertNotNull("event", event);
         UIComponent parent = getParent();
         if (parent == null) {
             throw new IllegalStateException("parent not found");
         }
         parent.queueEvent(event);
     }
 
     public void processDecodes(FacesContext context) {
         AssertionUtil.assertNotNull("context", context);
         if (!isRendered()) {
             return;
         }
         UIComponent component = null;
         for (Iterator itr = getFacetsAndChildren(); itr.hasNext();) {
             component = (UIComponent) itr.next();
             component.processDecodes(context);
         }
         try {
             decode(context);
         } catch (RuntimeException e) {
             context.renderResponse();
             throw e;
         }
     }
 
     public void processValidators(FacesContext context) {
         AssertionUtil.assertNotNull("context", context);
         if (!isRendered()) {
             return;
         }
         UIComponent component = null;
         for (Iterator itr = getFacetsAndChildren(); itr.hasNext();) {
             component = (UIComponent) itr.next();
             component.processValidators(context);
         }
     }
 
     public void processUpdates(FacesContext context) {
         AssertionUtil.assertNotNull("context", context);
         if (!isRendered()) {
             return;
         }
         UIComponent component = null;
         for (Iterator itr = getFacetsAndChildren(); itr.hasNext();) {
             component = (UIComponent) itr.next();
             component.processUpdates(context);
         }
     }
 
     public Object processSaveState(FacesContext context) {
         AssertionUtil.assertNotNull("context", context);
 
         if (isTransient()) {
             return null;
         }
 
         Map facetMap = new HashMap();
         for (Iterator itr = getFacets().entrySet().iterator(); itr.hasNext();) {
             Map.Entry entry = (Map.Entry) itr.next();
             String key = (String) entry.getKey();
             UIComponent component = (UIComponent) entry.getValue();
             if (!component.isTransient()) {
                 facetMap.put(key, component.processSaveState(context));
             }
         }
 
         List children = new ArrayList();
         for (Iterator itr = getChildren().iterator(); itr.hasNext();) {
             UIComponent component = (UIComponent) itr.next();
             if (!component.isTransient()) {
                 children.add(component.processSaveState(context));
             }
         }
 
         return new SerializableStateHolder(saveState(context), facetMap,
                 children);
     }
 
     public void processRestoreState(FacesContext context, Object state) {
         AssertionUtil.assertNotNull("context", context);
         if (!(state instanceof SerializableStateHolder)) {
             throw new IllegalArgumentException();
         }
 
         SerializableStateHolder holder = (SerializableStateHolder) state;
 
         Object thisState = holder.getState();
         Map facetMap = holder.getFacetMap();
         List children = holder.getChildren();
 
         for (Iterator itr = getFacets().entrySet().iterator(); itr.hasNext();) {
             Map.Entry entry = (Map.Entry) itr.next();
             UIComponent component = (UIComponent) entry.getValue();
             if (!component.isTransient()) {
                 Object facetState = facetMap.get(entry.getKey());
                 if (facetState != null) {
                     component.processRestoreState(context, facetState);
                 }
             }
         }
 
         int index = 0;
         for (Iterator itr = getChildren().iterator(); itr.hasNext();) {
             UIComponent component = (UIComponent) itr.next();
             if (!component.isTransient()) {
                 Object childrenState = children.get(index++);
                 if (childrenState != null) {
                     component.processRestoreState(context, childrenState);
                 }
             }
         }
 
         restoreState(context, thisState);
     }
 
     protected FacesContext getFacesContext() {
         return FacesContext.getCurrentInstance();
     }
 
     protected Renderer getRenderer(FacesContext context) {
         return UIComponentUtil.getRenderer(context, this);
     }
 
     public boolean isTransient() {
         return isTransient;
     }
 
     public void setTransient(boolean transientFlag) {
         isTransient = transientFlag;
     }
 
     public Object saveState(FacesContext context) {
         Object[] values = new Object[7];
         values[0] = id;
         values[1] = isRendered;
         values[2] = renderType;
         values[3] = clientId;
         values[4] = saveAttributesMap();
         values[5] = saveAttachedState(context, listeners);
         values[6] = saveValueBindingMap(context);
 
         return (Object) values;
     }
 
     public void restoreState(FacesContext context, Object state) {
         Object[] values = (Object[]) state;
         id = (String) values[0];
         isRendered = (Boolean) values[1];
         renderType = (String) values[2];
         clientId = (String) values[3];
         restoreAttributeMap(values[4]);
         listeners = (List) restoreAttachedState(context, values[5]);
         restoreValueBindingMap(context, values[6]);
     }
 
     public static Object saveAttachedState(FacesContext context,
             Object attachedObject) {
         AssertionUtil.assertNotNull("context", context);
 
         if (attachedObject == null) {
             return null;
         }
 
         if (attachedObject instanceof List) {
             List attachedList = (List) attachedObject;
             List resultList = new ArrayList(attachedList.size());
             for (Iterator itr = attachedList.iterator(); itr.hasNext();) {
                 Object obj = itr.next();
                 resultList.add(new AttachedObjectStateWrapper(context, obj));
             }
             return resultList;
         } else {
             return new AttachedObjectStateWrapper(context, attachedObject);
         }
     }
 
     public static Object restoreAttachedState(FacesContext context,
             Object stateObject) {
         AssertionUtil.assertNotNull("context", context);
 
         if (stateObject == null) {
             return null;
         }
 
         if (stateObject instanceof List) {
             List list = (List) stateObject;
             List restoredList = new ArrayList(list.size());
             for (Iterator itr = list.iterator(); itr.hasNext();) {
                 AttachedObjectStateWrapper wrapper = (AttachedObjectStateWrapper) itr
                         .next();
                 Object restoredObject = wrapper.restore(context);
                 if (restoredObject != null) {
                     restoredList.add(restoredObject);
                 }
             }
             return restoredList;
         } else if (stateObject instanceof AttachedObjectStateWrapper) {
             AttachedObjectStateWrapper wrapper = (AttachedObjectStateWrapper) stateObject;
             return wrapper.restore(context);
         } else {
             throw new IllegalStateException("Unsupported:" + stateObject);
         }
     }
 
     private Object saveAttributesMap() {
         return (attributesMap != null) ? attributesMap.getAttributesActual()
                 : null;
     }
 
     private void restoreAttributeMap(Object state) {
         if (state != null) {
             attributesMap = new ComponentAttributesMap(this, (Map) state);
         } else {
             clearAttributeMap();
         }
     }
 
     private Object saveValueBindingMap(FacesContext context) {
         Map states = null;
         if (bindingMap != null) {
             states = new HashMap();
             for (Iterator itr = bindingMap.entrySet().iterator(); itr.hasNext();) {
                 Map.Entry entry = (Map.Entry) itr.next();
                 states.put(entry.getKey(), saveAttachedState(context, entry
                         .getValue()));
             }
         }
         return states;
     }
 
     private void restoreValueBindingMap(FacesContext context, Object state) {
         bindingMap = null;
         if (state != null) {
             Map stateMap = (Map) state;
             bindingMap = new HashMap();
             for (Iterator itr = stateMap.entrySet().iterator(); itr.hasNext();) {
                 Map.Entry entry = (Map.Entry) itr.next();
                 bindingMap.put(entry.getKey(), restoreAttachedState(context,
                         entry.getValue()));
             }
         }
     }
 
     private void clearAttributeMap() {
         attributesMap = null;
     }
 
     private void validateId(String id) {
         if (id == null) {
             return;
         }
         if (id.length() < 1) {
             throw new IllegalArgumentException("UIComponentBase");
         }
         char ch;
         for (int i = 0; i < id.length(); i++) {
             ch = id.charAt(i);
             if (i == 0 && !Character.isLetter(ch) && ch != '_') {
                 throw new IllegalArgumentException(
                         "The first character is invalid(id = " + id + ")");
             } else if (!Character.isDigit(ch) && !Character.isLetter(ch)
                     && ch != '-' && ch != '_') {
                 throw new IllegalArgumentException(
                         "Subsequent character is invalid(id = " + id + ")");
             }
         }
     }
 
     private static class NullRenderer extends Renderer {
         public NullRenderer() {
         }
     }
 
 }

1		/*
2		* Copyright 2004-2011 the Seasar Foundation and the Others.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
13		* either express or implied. See the License for the specific language
14		* governing permissions and limitations under the License.
15		*/
16		package javax.faces.component;
17
18		import java.io.IOException;
19		import java.lang.reflect.Array;
20		import java.util.ArrayList;
21		import java.util.HashMap;
22		import java.util.Iterator;
23		import java.util.List;
24		import java.util.Map;
25
26		import javax.faces.context.FacesContext;
27		import javax.faces.el.ValueBinding;
28		import javax.faces.event.AbortProcessingException;
29		import javax.faces.event.FacesEvent;
30		import javax.faces.event.FacesListener;
31		import javax.faces.internal.AttachedObjectStateWrapper;
32		import javax.faces.internal.ComponentAttributesMap;
33		import javax.faces.internal.ComponentChildrenListWrapper;
34		import javax.faces.internal.ComponentFacetAndChildrenIterator;
35		import javax.faces.internal.ComponentFacetMapWrapper;
36		import javax.faces.internal.SerializableStateHolder;
37		import javax.faces.internal.UIComponentUtil;
38		import javax.faces.render.Renderer;
39
40		import org.seasar.framework.util.AssertionUtil;
41
42		/**
43		* @author shot
44		* @author manhole
45		*/
46	8970	public abstract class UIComponentBase extends UIComponent {
47
48		private String id;
49
50	8970	private ComponentAttributesMap attributesMap = null;
51
52	8970	private Map bindingMap = new HashMap();
53
54		private UIComponent parent;
55
56	8970	private String clientId = null;
57
58		private Boolean isRendered;
59
60	8970	private String renderType = null;
61
62	8970	private List childrenList = null;
63
64	8970	private Map facetMap = null;
65
66	8970	private List listeners = null;
67
68	8970	private boolean isTransient = false;
69
70		private String uniqueId;
71
72		private static final String RENDERED = "rendered";
73
74		private static final String RENDERER_TYPE = "rendererType";
75
76		private static final int LIST_NULL_SIZE = 0;
77
78		public Map getAttributes() {
79	2305	if (attributesMap == null) {
80	650	attributesMap = new ComponentAttributesMap(this);
81		}
82	2305	return attributesMap;
83		}
84
85		public ValueBinding getValueBinding(String name) {
86	12846	AssertionUtil.assertNotNull("name", name);
87	12802	return (ValueBinding) bindingMap.get(name);
88		}
89
90		public void setValueBinding(String name, ValueBinding binding) {
91	1112	AssertionUtil.assertNotNull("name", name);
92	1071	if (name.equals("id") \|\| name.equals("parent")) {
93	91	throw new IllegalArgumentException("invalid name is specified");
94		}
95	980	if (binding != null) {
96	976	bindingMap.put(name, binding);
97		} else {
98	4	bindingMap.remove(name);
99		}
100	980	}
101
102		public String getClientId(FacesContext context) {
103	1252	AssertionUtil.assertNotNull("context", context);
104	1211	if (clientId == null) {
105	825	clientId = createClientId(context);
106		}
107	1211	return clientId;
108		}
109
110		private String createClientId(FacesContext context) {
111	825	StringBuffer buf = new StringBuffer(32);
112	954	for (UIComponent component = getParent(); component != null; component = component
113		.getParent()) {
114	228	if (component instanceof NamingContainer) {
115	99	buf.append(component.getClientId(context)).append(
116		NamingContainer.SEPARATOR_CHAR);
117	99	break;
118		}
119		}
120	825	buf.append(context.getExternalContext().encodeNamespace(
121		(id != null) ? id : getUniqueId(context)));
122	825	String clientId = buf.toString();
123	825	Renderer renderer = getRenderer(context);
124	825	if (renderer != null) {
125	267	clientId = renderer.convertClientId(context, clientId);
126		}
127	825	return clientId;
128		}
129
130		private String getUniqueId(FacesContext context) {
131	375	if (uniqueId == null) {
132	350	uniqueId = context.getViewRoot().createUniqueId();
133		}
134	375	return uniqueId;
135		}
136
137		public String getId() {
138	2431	return id;
139		}
140
141		public void setId(String id) {
142	2006	validateId(id);
143	1830	this.id = id;
144	1830	clientId = null;
145	1830	}
146
147		public UIComponent getParent() {
148	2476	return parent;
149		}
150
151		public void setParent(UIComponent parent) {
152	1245	this.parent = parent;
153	1245	}
154
155		public boolean isRendered() {
156	1301	if (isRendered != null) {
157	117	return isRendered.booleanValue();
158		}
159	1184	Boolean v = null;
160	1184	ValueBinding vb = getValueBinding(RENDERED);
161	1184	if (vb != null) {
162	44	v = ((Boolean) this.getValueFromBinding(vb));
163		}
164	1184	if (v != null) {
165	44	return v.booleanValue();
166		} else {
167	1140	return true;
168		}
169		}
170
171		public void setRendered(boolean isRendered) {
172	144	this.isRendered = Boolean.valueOf(isRendered);
173	144	}
174
175		public String getRendererType() {
176	1187	if (renderType != null) {
177	897	return renderType;
178		}
179	290	ValueBinding vb = getValueBinding(RENDERER_TYPE);
180	290	String result = null;
181	290	if (vb != null) {
182	44	result = (String) this.getValueFromBinding(vb);
183		}
184	290	return result;
185		}
186
187		public void setRendererType(String renderType) {
188	14300	this.renderType = renderType;
189	14300	}
190
191		private Object getValueFromBinding(ValueBinding vb) {
192	88	return vb.getValue(getFacesContext());
193		}
194
195		public boolean getRendersChildren() {
196	252	boolean result = false;
197	252	Renderer renderer = getRenderer(getFacesContext());
198	252	if (getRendererType() != null && renderer != null) {
199	140	result = renderer.getRendersChildren();
200		}
201	252	return result;
202		}
203
204		public List getChildren() {
205	3228	if (childrenList == null) {
206	1524	childrenList = new ComponentChildrenListWrapper(this);
207		}
208	3228	return childrenList;
209		}
210
211		public int getChildCount() {
212	442	return (childrenList != null) ? childrenList.size() : LIST_NULL_SIZE;
213		}
214
215		public UIComponent findComponent(String expr) {
216	707	AssertionUtil.assertNotNull("expr", expr);
217	663	UIComponent base = this;
218	663	if (expr.charAt(0) == NamingContainer.SEPARATOR_CHAR) {
219	44	getComponentRoot(base);
220	44	expr = expr.substring(1);
221		} else {
222	1077	for (; base.getParent() != null; base = base.getParent()) {
223	347	if (base instanceof NamingContainer) {
224	118	break;
225		}
226		}
227		}
228
229	663	UIComponent result = null;
230	663	while (expr.length() > 0) {
231	663	String id = null;
232	663	int separator = expr.indexOf(NamingContainer.SEPARATOR_CHAR);
233	663	if (separator >= 0) {
234	252	id = expr.substring(0, separator);
235	252	expr = expr.substring(separator + 1);
236		} else {
237	411	id = expr;
238	411	expr = null;
239		}
240
241	663	result = findComponent(base, id);
242	663	if (result == null \|\| expr == null) {
243	353	break;
244		}
245	234	if (result instanceof NamingContainer) {
246	196	result = result.findComponent(expr);
247	158	break;
248		} else {
249	38	throw new IllegalArgumentException(id);
250		}
251		}
252	587	return result;
253		}
254
255		private UIComponent findComponent(UIComponent base, String id) {
256	1000	if (containsSameId(base, id)) {
257	505	return base;
258		}
259
260	495	UIComponent child = null;
261	495	UIComponent result = null;
262	495	for (Iterator itr = base.getFacetsAndChildren(); itr.hasNext();) {
263	463	child = (UIComponent) itr.next();
264	463	if (!(child instanceof NamingContainer)) {
265	337	result = findComponent(child, id);
266	337	if (result != null) {
267	259	break;
268		}
269	126	} else if (containsSameId(child, id)) {
270	82	result = child;
271	82	break;
272		}
273		}
274	495	return result;
275		}
276
277		protected boolean containsSameId(UIComponent base, String id) {
278	1126	return id.equals(base.getId());
279		}
280
281		protected UIComponent getComponentRoot(UIComponent base) {
282		UIComponent parent;
283	44	for (parent = base; parent.getParent() != null; parent = parent
284		.getParent()) {
285		;
286		}
287	44	return parent;
288		}
289
290		public Map getFacets() {
291	734	if (facetMap == null) {
292	422	facetMap = new ComponentFacetMapWrapper(this);
293		}
294	734	return facetMap;
295		}
296
297		public UIComponent getFacet(String name) {
298	270	return (facetMap != null) ? (UIComponent) facetMap.get(name) : null;
299		}
300
301		public Iterator getFacetsAndChildren() {
302	1140	return new ComponentFacetAndChildrenIterator(facetMap, childrenList);
303		}
304
305		public void broadcast(FacesEvent event) throws AbortProcessingException {
306	109	AssertionUtil.assertNotNull("event", event);
307	68	if (listeners != null) {
308	44	for (Iterator itr = listeners.iterator(); itr.hasNext();) {
309	88	FacesListener listener = (FacesListener) itr.next();
310	88	if (event.isAppropriateListener(listener)) {
311	88	event.processListener(listener);
312		}
313		}
314		}
315	68	}
316
317		public void decode(FacesContext context) {
318	56	AssertionUtil.assertNotNull("context", context);
319	12	Renderer renderer = getRendererForEncodeOrDecode(context);
320	12	renderer.decode(context, this);
321	12	}
322
323		public void encodeBegin(FacesContext context) throws IOException {
324	209	AssertionUtil.assertNotNull("context", context);
325	168	if (!isRendered()) {
326	3	return;
327		}
328
329	165	Renderer renderer = getRendererForEncodeOrDecode(context);
330	165	renderer.encodeBegin(context, this);
331	165	}
332
333		public void encodeChildren(FacesContext context) throws IOException {
334	53	AssertionUtil.assertNotNull("context", context);
335	9	if (!isRendered()) {
336	1	return;
337		}
338	8	Renderer renderer = getRendererForEncodeOrDecode(context);
339	8	renderer.encodeChildren(context, this);
340	8	}
341
342		public void encodeEnd(FacesContext context) throws IOException {
343	205	AssertionUtil.assertNotNull("context", context);
344	161	if (!isRendered()) {
345	3	return;
346		}
347	158	Renderer renderer = getRendererForEncodeOrDecode(context);
348	158	renderer.encodeEnd(context, this);
349	158	}
350
351		private Renderer getRendererForEncodeOrDecode(FacesContext context) {
352	343	Renderer renderer = getRenderer(context);
353	343	if (renderer == null) {
354	54	renderer = new NullRenderer();
355		}
356	343	return renderer;
357		}
358
359		protected void addFacesListener(FacesListener listener) {
360	409	AssertionUtil.assertNotNull("listener", listener);
361	321	if (listeners == null) {
362	153	listeners = new ArrayList();
363		}
364	321	listeners.add(listener);
365	321	}
366
367		protected FacesListener[] getFacesListeners(Class clazz) {
368	384	AssertionUtil.assertNotNull("class", clazz);
369	341	if (!FacesListener.class.isAssignableFrom(clazz)) {
370	44	throw new IllegalArgumentException(clazz.getName()
371		+ " is not FacesListener");
372		}
373
374	296	if (listeners == null) {
375	18	return (FacesListener[]) Array.newInstance(clazz, 0);
376		}
377
378	278	List result = new ArrayList();
379	278	FacesListener listener = null;
380	278	for (Iterator itr = listeners.iterator(); itr.hasNext();) {
381	500	listener = (FacesListener) itr.next();
382	500	if (clazz.isAssignableFrom(listener.getClass())) {
383	412	result.add(listener);
384		}
385		}
386
387	278	Object[] args = (Object[]) Array.newInstance(clazz, result.size());
388	278	return (FacesListener[]) result.toArray(args);
389		}
390
391		protected void removeFacesListener(FacesListener listener) {
392	139	AssertionUtil.assertNotNull("listener", listener);
393
394	80	if (listeners != null) {
395	80	listeners.remove(listener);
396		}
397	80	}
398
399		public void queueEvent(FacesEvent event) {
400	140	AssertionUtil.assertNotNull("event", event);
401	100	UIComponent parent = getParent();
402	100	if (parent == null) {
403	43	throw new IllegalStateException("parent not found");
404		}
405	57	parent.queueEvent(event);
406	57	}
407
408		public void processDecodes(FacesContext context) {
409	35	AssertionUtil.assertNotNull("context", context);
410	11	if (!isRendered()) {
411	1	return;
412		}
413	10	UIComponent component = null;
414	10	for (Iterator itr = getFacetsAndChildren(); itr.hasNext();) {
415	5	component = (UIComponent) itr.next();
416	5	component.processDecodes(context);
417		}
418		try {
419	10	decode(context);
420	1	} catch (RuntimeException e) {
421	1	context.renderResponse();
422	1	throw e;
423	9	}
424	9	}
425
426		public void processValidators(FacesContext context) {
427	35	AssertionUtil.assertNotNull("context", context);
428	11	if (!isRendered()) {
429	1	return;
430		}
431	10	UIComponent component = null;
432	10	for (Iterator itr = getFacetsAndChildren(); itr.hasNext();) {
433	4	component = (UIComponent) itr.next();
434	4	component.processValidators(context);
435		}
436	10	}
437
438		public void processUpdates(FacesContext context) {
439	32	AssertionUtil.assertNotNull("context", context);
440	8	if (!isRendered()) {
441	1	return;
442		}
443	7	UIComponent component = null;
444	7	for (Iterator itr = getFacetsAndChildren(); itr.hasNext();) {
445	4	component = (UIComponent) itr.next();
446	4	component.processUpdates(context);
447		}
448	7	}
449
450		public Object processSaveState(FacesContext context) {
451	138	AssertionUtil.assertNotNull("context", context);
452
453	94	if (isTransient()) {
454	44	return null;
455		}
456
457	50	Map facetMap = new HashMap();
458	50	for (Iterator itr = getFacets().entrySet().iterator(); itr.hasNext();) {
459	88	Map.Entry entry = (Map.Entry) itr.next();
460	88	String key = (String) entry.getKey();
461	88	UIComponent component = (UIComponent) entry.getValue();
462	88	if (!component.isTransient()) {
463	88	facetMap.put(key, component.processSaveState(context));
464		}
465		}
466
467	50	List children = new ArrayList();
468	50	for (Iterator itr = getChildren().iterator(); itr.hasNext();) {
469	89	UIComponent component = (UIComponent) itr.next();
470	89	if (!component.isTransient()) {
471	89	children.add(component.processSaveState(context));
472		}
473		}
474
475	50	return new SerializableStateHolder(saveState(context), facetMap,
476		children);
477		}
478
479		public void processRestoreState(FacesContext context, Object state) {
480	91	AssertionUtil.assertNotNull("context", context);
481	47	if (!(state instanceof SerializableStateHolder)) {
482	44	throw new IllegalArgumentException();
483		}
484
485	3	SerializableStateHolder holder = (SerializableStateHolder) state;
486
487	3	Object thisState = holder.getState();
488	3	Map facetMap = holder.getFacetMap();
489	3	List children = holder.getChildren();
490
491	3	for (Iterator itr = getFacets().entrySet().iterator(); itr.hasNext();) {
492	2	Map.Entry entry = (Map.Entry) itr.next();
493	2	UIComponent component = (UIComponent) entry.getValue();
494	2	if (!component.isTransient()) {
495	2	Object facetState = facetMap.get(entry.getKey());
496	2	if (facetState != null) {
497	2	component.processRestoreState(context, facetState);
498		}
499		}
500		}
501
502	3	int index = 0;
503	3	for (Iterator itr = getChildren().iterator(); itr.hasNext();) {
504	2	UIComponent component = (UIComponent) itr.next();
505	2	if (!component.isTransient()) {
506	2	Object childrenState = children.get(index++);
507	2	if (childrenState != null) {
508	2	component.processRestoreState(context, childrenState);
509		}
510		}
511		}
512
513	3	restoreState(context, thisState);
514	3	}
515
516		protected FacesContext getFacesContext() {
517	1347	return FacesContext.getCurrentInstance();
518		}
519
520		protected Renderer getRenderer(FacesContext context) {
521	716	return UIComponentUtil.getRenderer(context, this);
522		}
523
524		public boolean isTransient() {
525	280	return isTransient;
526		}
527
528		public void setTransient(boolean transientFlag) {
529	133	isTransient = transientFlag;
530	133	}
531
532		public Object saveState(FacesContext context) {
533	180	Object[] values = new Object[7];
534	180	values[0] = id;
535	180	values[1] = isRendered;
536	180	values[2] = renderType;
537	180	values[3] = clientId;
538	180	values[4] = saveAttributesMap();
539	180	values[5] = saveAttachedState(context, listeners);
540	180	values[6] = saveValueBindingMap(context);
541
542	180	return (Object) values;
543		}
544
545		public void restoreState(FacesContext context, Object state) {
546	133	Object[] values = (Object[]) state;
547	133	id = (String) values[0];
548	133	isRendered = (Boolean) values[1];
549	133	renderType = (String) values[2];
550	133	clientId = (String) values[3];
551	133	restoreAttributeMap(values[4]);
552	133	listeners = (List) restoreAttachedState(context, values[5]);
553	133	restoreValueBindingMap(context, values[6]);
554	133	}
555
556		public static Object saveAttachedState(FacesContext context,
557		Object attachedObject) {
558	620	AssertionUtil.assertNotNull("context", context);
559
560	619	if (attachedObject == null) {
561	529	return null;
562		}
563
564	90	if (attachedObject instanceof List) {
565	19	List attachedList = (List) attachedObject;
566	19	List resultList = new ArrayList(attachedList.size());
567	19	for (Iterator itr = attachedList.iterator(); itr.hasNext();) {
568	35	Object obj = itr.next();
569	35	resultList.add(new AttachedObjectStateWrapper(context, obj));
570		}
571	19	return resultList;
572		} else {
573	71	return new AttachedObjectStateWrapper(context, attachedObject);
574		}
575		}
576
577		public static Object restoreAttachedState(FacesContext context,
578		Object stateObject) {
579	546	AssertionUtil.assertNotNull("context", context);
580
581	546	if (stateObject == null) {
582	411	return null;
583		}
584
585	135	if (stateObject instanceof List) {
586	63	List list = (List) stateObject;
587	63	List restoredList = new ArrayList(list.size());
588	63	for (Iterator itr = list.iterator(); itr.hasNext();) {
589	79	AttachedObjectStateWrapper wrapper = (AttachedObjectStateWrapper) itr
590		.next();
591	79	Object restoredObject = wrapper.restore(context);
592	79	if (restoredObject != null) {
593	79	restoredList.add(restoredObject);
594		}
595		}
596	63	return restoredList;
597	72	} else if (stateObject instanceof AttachedObjectStateWrapper) {
598	71	AttachedObjectStateWrapper wrapper = (AttachedObjectStateWrapper) stateObject;
599	71	return wrapper.restore(context);
600		} else {
601	1	throw new IllegalStateException("Unsupported:" + stateObject);
602		}
603		}
604
605		private Object saveAttributesMap() {
606	180	return (attributesMap != null) ? attributesMap.getAttributesActual()
607		: null;
608		}
609
610		private void restoreAttributeMap(Object state) {
611	133	if (state != null) {
612	43	attributesMap = new ComponentAttributesMap(this, (Map) state);
613		} else {
614	90	clearAttributeMap();
615		}
616	133	}
617
618		private Object saveValueBindingMap(FacesContext context) {
619	180	Map states = null;
620	180	if (bindingMap != null) {
621	180	states = new HashMap();
622	180	for (Iterator itr = bindingMap.entrySet().iterator(); itr.hasNext();) {
623	43	Map.Entry entry = (Map.Entry) itr.next();
624	43	states.put(entry.getKey(), saveAttachedState(context, entry
625		.getValue()));
626		}
627		}
628	180	return states;
629		}
630
631		private void restoreValueBindingMap(FacesContext context, Object state) {
632	133	bindingMap = null;
633	133	if (state != null) {
634	133	Map stateMap = (Map) state;
635	133	bindingMap = new HashMap();
636	133	for (Iterator itr = stateMap.entrySet().iterator(); itr.hasNext();) {
637	43	Map.Entry entry = (Map.Entry) itr.next();
638	43	bindingMap.put(entry.getKey(), restoreAttachedState(context,
639		entry.getValue()));
640		}
641		}
642	133	}
643
644		private void clearAttributeMap() {
645	90	attributesMap = null;
646	90	}
647
648		private void validateId(String id) {
649	2006	if (id == null) {
650	197	return;
651		}
652	1809	if (id.length() < 1) {
653	44	throw new IllegalArgumentException("UIComponentBase");
654		}
655		char ch;
656	5431	for (int i = 0; i < id.length(); i++) {
657	3798	ch = id.charAt(i);
658	3798	if (i == 0 && !Character.isLetter(ch) && ch != '_') {
659	88	throw new IllegalArgumentException(
660		"The first character is invalid(id = " + id + ")");
661	3710	} else if (!Character.isDigit(ch) && !Character.isLetter(ch)
662		&& ch != '-' && ch != '_') {
663	44	throw new IllegalArgumentException(
664		"Subsequent character is invalid(id = " + id + ")");
665		}
666		}
667	1633	}
668
669	8970	private static class NullRenderer extends Renderer {
670	54	public NullRenderer() {
671	54	}
672		}
673
674		}