Coverage Report

Coverage Report - javax.faces.component.behavior.BehaviorBase

Classes in this File

Line Coverage

Branch Coverage

Complexity

BehaviorBase

0/92

0/60

4.571

 /*
  * 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.behavior;
 
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 
 import javax.faces.component.PartialStateHolder;
 import javax.faces.component.StateHolder;
 import javax.faces.context.FacesContext;
 import javax.faces.event.BehaviorEvent;
 import javax.faces.event.BehaviorListener;
 
 /**
  * @since 2.0
  */
 public class BehaviorBase implements Behavior, PartialStateHolder
 {
     private _DeltaList<BehaviorListener> _behaviorListeners;
     
     private boolean _initialState;
     
     private transient boolean _transient;
 
     /**
      * 
      */
     public BehaviorBase()
     {
     }
     
     //public abstract String getRendererType();
     /**
      * {@inheritDoc}
      */
     public void broadcast(BehaviorEvent event)
     {
         if (event == null)
         {
             throw new NullPointerException("event");
         }
         
         if (_behaviorListeners != null)
         {
             // This code prevent listeners from unregistering themselves while processing the event.
             // I believe it should always be alright in this case. However, the need rise, then it 
             // should be possible to remove that limitation by using a clone for the looping
             for (int i = 0; i < _behaviorListeners.size() ; i++)
             {
                 BehaviorListener listener = _behaviorListeners.get(i);
                 if (event.isAppropriateListener(listener))
                 {
                     event.processListener(listener);
                 }
             }
         }
     }
 
     public void clearInitialState()
     {
         _initialState = false;
         if (_behaviorListeners != null)
         {
             _behaviorListeners.clearInitialState();
         }
     }
 
     public boolean initialStateMarked()
     {
         return _initialState;
     }
 
     public boolean isTransient()
     {
         return _transient;
     }
 
     public void markInitialState()
     {
         _initialState = true;
         if (_behaviorListeners != null)
         {
             _behaviorListeners.markInitialState();
         }
     }
 
     public void restoreState(FacesContext context, Object state)
     {
         if (state == null)
         {
             return;
         }
         else if (state instanceof _AttachedDeltaWrapper)
         {
             //Delta: check for null is not necessary since _behaviorListener field
             //is only set once and never reset
             //if (_behaviorListeners != null)
             //{
                 ((StateHolder)_behaviorListeners).restoreState(context,
                         ((_AttachedDeltaWrapper) state).getWrappedStateObject());
             //}
         }
         else
         {
             //Full
             _behaviorListeners = (_DeltaList<BehaviorListener>)
                 restoreAttachedState(context, state);
         }
     }
 
     public Object saveState(FacesContext context)
     {
         return saveBehaviorListenersList(context);
     }
     
     private Object saveBehaviorListenersList(FacesContext facesContext)
     {
         PartialStateHolder holder = (PartialStateHolder) _behaviorListeners;
         if (initialStateMarked() && _behaviorListeners != null && holder.initialStateMarked())
         {                
             Object attachedState = holder.saveState(facesContext);
             if (attachedState != null)
             {
                 return new _AttachedDeltaWrapper(_behaviorListeners.getClass(),
                         attachedState);
             }
             //_behaviorListeners instances once is created never changes, we can return null
             return null;
         }
         else
         {
             return saveAttachedState(facesContext,_behaviorListeners);
         }
     }
 
     private static Object saveAttachedState(FacesContext context, Object attachedObject)
     {
         if (context == null)
         {
             throw new NullPointerException ("context");
         }
         
         if (attachedObject == null)
         {
             return null;
         }
         // StateHolder interface should take precedence over
         // List children
         if (attachedObject instanceof StateHolder)
         {
             StateHolder holder = (StateHolder) attachedObject;
             if (holder.isTransient())
             {
                 return null;
             }
 
             return new _AttachedStateWrapper(attachedObject.getClass(), holder.saveState(context));
         }        
         else if (attachedObject instanceof List)
         {
             List<Object> lst = new ArrayList<Object>(((List<?>) attachedObject).size());
             for (Object item : (List<?>) attachedObject)
             {
                 if (item != null)
                 {
                     lst.add(saveAttachedState(context, item));
                 }
             }
 
             return new _AttachedListStateWrapper(lst);
         }
         else if (attachedObject instanceof Serializable)
         {
             return attachedObject;
         }
         else
         {
             return new _AttachedStateWrapper(attachedObject.getClass(), null);
         }
     }
 
     private static Object restoreAttachedState(FacesContext context, Object stateObj) throws IllegalStateException
     {
         if (context == null)
         {
             throw new NullPointerException("context");
         }
         if (stateObj == null)
         {
             return null;
         }
         if (stateObj instanceof _AttachedListStateWrapper)
         {
             List<Object> lst = ((_AttachedListStateWrapper) stateObj).getWrappedStateList();
             List<Object> restoredList = new ArrayList<Object>(lst.size());
             for (Object item : lst)
             {
                 restoredList.add(restoreAttachedState(context, item));
             }
             return restoredList;
         }
         else if (stateObj instanceof _AttachedStateWrapper)
         {
             Class<?> clazz = ((_AttachedStateWrapper) stateObj).getClazz();
             Object restoredObject;
             try
             {
                 restoredObject = clazz.newInstance();
             }
             catch (InstantiationException e)
             {
                 throw new RuntimeException("Could not restore StateHolder of type " + clazz.getName()
                         + " (missing no-args constructor?)", e);
             }
             catch (IllegalAccessException e)
             {
                 throw new RuntimeException(e);
             }
             if (restoredObject instanceof StateHolder)
             {
                 _AttachedStateWrapper wrapper = (_AttachedStateWrapper) stateObj;
                 Object wrappedState = wrapper.getWrappedStateObject();
 
                 StateHolder holder = (StateHolder) restoredObject;
                 holder.restoreState(context, wrappedState);
             }
             return restoredObject;
         }
         else
         {
             return stateObj;
         }
     }
 
     public void setTransient(boolean newTransientValue)
     {
         _transient = newTransientValue;
     }
     
     protected void addBehaviorListener(BehaviorListener listener)
     {
         if (listener == null)
         {
             throw new NullPointerException("listener");
         }
         
         if (_behaviorListeners == null)
         {
             // Lazy instanciation with size 1:
             // the only posibility how to add listener is <f:ajax listener="" /> - there is no <f:ajaxListener/> tag 
             _behaviorListeners = new _DeltaList<BehaviorListener>(new ArrayList<BehaviorListener>(1));
         }
         
         _behaviorListeners.add(listener);
     }
     
     protected void removeBehaviorListener(BehaviorListener listener)
     {
         if (listener == null)
         {
             throw new NullPointerException("listener");
         }
 
         if (_behaviorListeners != null)
         {
             _behaviorListeners.remove(listener);
         }
     }
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one
3		* or more contributor license agreements. See the NOTICE file
4		* distributed with this work for additional information
5		* regarding copyright ownership. The ASF licenses this file
6		* to you under the Apache License, Version 2.0 (the
7		* "License"); you may not use this file except in compliance
8		* with the License. You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing,
13		* software distributed under the License is distributed on an
14		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15		* KIND, either express or implied. See the License for the
16		* specific language governing permissions and limitations
17		* under the License.
18		*/
19		package javax.faces.component.behavior;
20
21		import java.io.Serializable;
22		import java.util.ArrayList;
23		import java.util.List;
24
25		import javax.faces.component.PartialStateHolder;
26		import javax.faces.component.StateHolder;
27		import javax.faces.context.FacesContext;
28		import javax.faces.event.BehaviorEvent;
29		import javax.faces.event.BehaviorListener;
30
31		/**
32		* @since 2.0
33		*/
34		public class BehaviorBase implements Behavior, PartialStateHolder
35		{
36		private _DeltaList<BehaviorListener> _behaviorListeners;
37
38		private boolean _initialState;
39
40		private transient boolean _transient;
41
42		/**
43		*
44		*/
45		public BehaviorBase()
46	0	{
47	0	}
48
49		//public abstract String getRendererType();
50		/**
51		* {@inheritDoc}
52		*/
53		public void broadcast(BehaviorEvent event)
54		{
55	0	if (event == null)
56		{
57	0	throw new NullPointerException("event");
58		}
59
60	0	if (_behaviorListeners != null)
61		{
62		// This code prevent listeners from unregistering themselves while processing the event.
63		// I believe it should always be alright in this case. However, the need rise, then it
64		// should be possible to remove that limitation by using a clone for the looping
65	0	for (int i = 0; i < _behaviorListeners.size() ; i++)
66		{
67	0	BehaviorListener listener = _behaviorListeners.get(i);
68	0	if (event.isAppropriateListener(listener))
69		{
70	0	event.processListener(listener);
71		}
72		}
73		}
74	0	}
75
76		public void clearInitialState()
77		{
78	0	_initialState = false;
79	0	if (_behaviorListeners != null)
80		{
81	0	_behaviorListeners.clearInitialState();
82		}
83	0	}
84
85		public boolean initialStateMarked()
86		{
87	0	return _initialState;
88		}
89
90		public boolean isTransient()
91		{
92	0	return _transient;
93		}
94
95		public void markInitialState()
96		{
97	0	_initialState = true;
98	0	if (_behaviorListeners != null)
99		{
100	0	_behaviorListeners.markInitialState();
101		}
102	0	}
103
104		public void restoreState(FacesContext context, Object state)
105		{
106	0	if (state == null)
107		{
108	0	return;
109		}
110	0	else if (state instanceof _AttachedDeltaWrapper)
111		{
112		//Delta: check for null is not necessary since _behaviorListener field
113		//is only set once and never reset
114		//if (_behaviorListeners != null)
115		//{
116	0	((StateHolder)_behaviorListeners).restoreState(context,
117		((_AttachedDeltaWrapper) state).getWrappedStateObject());
118		//}
119		}
120		else
121		{
122		//Full
123	0	_behaviorListeners = (_DeltaList<BehaviorListener>)
124		restoreAttachedState(context, state);
125		}
126	0	}
127
128		public Object saveState(FacesContext context)
129		{
130	0	return saveBehaviorListenersList(context);
131		}
132
133		private Object saveBehaviorListenersList(FacesContext facesContext)
134		{
135	0	PartialStateHolder holder = (PartialStateHolder) _behaviorListeners;
136	0	if (initialStateMarked() && _behaviorListeners != null && holder.initialStateMarked())
137		{
138	0	Object attachedState = holder.saveState(facesContext);
139	0	if (attachedState != null)
140		{
141	0	return new _AttachedDeltaWrapper(_behaviorListeners.getClass(),
142		attachedState);
143		}
144		//_behaviorListeners instances once is created never changes, we can return null
145	0	return null;
146		}
147		else
148		{
149	0	return saveAttachedState(facesContext,_behaviorListeners);
150		}
151		}
152
153		private static Object saveAttachedState(FacesContext context, Object attachedObject)
154		{
155	0	if (context == null)
156		{
157	0	throw new NullPointerException ("context");
158		}
159
160	0	if (attachedObject == null)
161		{
162	0	return null;
163		}
164		// StateHolder interface should take precedence over
165		// List children
166	0	if (attachedObject instanceof StateHolder)
167		{
168	0	StateHolder holder = (StateHolder) attachedObject;
169	0	if (holder.isTransient())
170		{
171	0	return null;
172		}
173
174	0	return new _AttachedStateWrapper(attachedObject.getClass(), holder.saveState(context));
175		}
176	0	else if (attachedObject instanceof List)
177		{
178	0	List<Object> lst = new ArrayList<Object>(((List<?>) attachedObject).size());
179	0	for (Object item : (List<?>) attachedObject)
180		{
181	0	if (item != null)
182		{
183	0	lst.add(saveAttachedState(context, item));
184		}
185	0	}
186
187	0	return new _AttachedListStateWrapper(lst);
188		}
189	0	else if (attachedObject instanceof Serializable)
190		{
191	0	return attachedObject;
192		}
193		else
194		{
195	0	return new _AttachedStateWrapper(attachedObject.getClass(), null);
196		}
197		}
198
199		private static Object restoreAttachedState(FacesContext context, Object stateObj) throws IllegalStateException
200		{
201	0	if (context == null)
202		{
203	0	throw new NullPointerException("context");
204		}
205	0	if (stateObj == null)
206		{
207	0	return null;
208		}
209	0	if (stateObj instanceof _AttachedListStateWrapper)
210		{
211	0	List<Object> lst = ((_AttachedListStateWrapper) stateObj).getWrappedStateList();
212	0	List<Object> restoredList = new ArrayList<Object>(lst.size());
213	0	for (Object item : lst)
214		{
215	0	restoredList.add(restoreAttachedState(context, item));
216	0	}
217	0	return restoredList;
218		}
219	0	else if (stateObj instanceof _AttachedStateWrapper)
220		{
221	0	Class<?> clazz = ((_AttachedStateWrapper) stateObj).getClazz();
222		Object restoredObject;
223		try
224		{
225	0	restoredObject = clazz.newInstance();
226		}
227	0	catch (InstantiationException e)
228		{
229	0	throw new RuntimeException("Could not restore StateHolder of type " + clazz.getName()
230		+ " (missing no-args constructor?)", e);
231		}
232	0	catch (IllegalAccessException e)
233		{
234	0	throw new RuntimeException(e);
235	0	}
236	0	if (restoredObject instanceof StateHolder)
237		{
238	0	_AttachedStateWrapper wrapper = (_AttachedStateWrapper) stateObj;
239	0	Object wrappedState = wrapper.getWrappedStateObject();
240
241	0	StateHolder holder = (StateHolder) restoredObject;
242	0	holder.restoreState(context, wrappedState);
243		}
244	0	return restoredObject;
245		}
246		else
247		{
248	0	return stateObj;
249		}
250		}
251
252		public void setTransient(boolean newTransientValue)
253		{
254	0	_transient = newTransientValue;
255	0	}
256
257		protected void addBehaviorListener(BehaviorListener listener)
258		{
259	0	if (listener == null)
260		{
261	0	throw new NullPointerException("listener");
262		}
263
264	0	if (_behaviorListeners == null)
265		{
266		// Lazy instanciation with size 1:
267		// the only posibility how to add listener is <f:ajax listener="" /> - there is no <f:ajaxListener/> tag
268	0	_behaviorListeners = new _DeltaList<BehaviorListener>(new ArrayList<BehaviorListener>(1));
269		}
270
271	0	_behaviorListeners.add(listener);
272	0	}
273
274		protected void removeBehaviorListener(BehaviorListener listener)
275		{
276	0	if (listener == null)
277		{
278	0	throw new NullPointerException("listener");
279		}
280
281	0	if (_behaviorListeners != null)
282		{
283	0	_behaviorListeners.remove(listener);
284		}
285	0	}
286		}