Coverage Report

Coverage Report - org.apache.myfaces.context.servlet.FacesContextImpl

Classes in this File

0/147

0/86

 /*
  * 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 org.apache.myfaces.context.servlet;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
 import javax.el.ELContext;
 import javax.el.ELContextEvent;
 import javax.el.ELContextListener;
 import javax.faces.FactoryFinder;
 import javax.faces.application.Application;
 import javax.faces.application.ApplicationFactory;
 import javax.faces.application.FacesMessage;
 import javax.faces.component.UIViewRoot;
 import javax.faces.context.ExternalContext;
 import javax.faces.context.FacesContext;
 import javax.faces.context.ResponseStream;
 import javax.faces.context.ResponseWriter;
 import javax.faces.render.RenderKit;
 import javax.faces.render.RenderKitFactory;
 import javax.portlet.PortletContext;
 import javax.portlet.PortletRequest;
 import javax.portlet.PortletResponse;
 import javax.servlet.ServletContext;
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 
 import org.apache.myfaces.context.ReleaseableExternalContext;
 import org.apache.myfaces.context.ReleaseableFacesContextFactory;
 import org.apache.myfaces.context.portlet.PortletExternalContextImpl;
 import org.apache.myfaces.el.unified.FacesELContext;
 import org.apache.myfaces.shared_impl.util.NullIterator;
 
 
 /**
  * @author Manfred Geiler (latest modification by $Author: lu4242 $)
  * @author Anton Koinov
  * @version $Revision: 938287 $ $Date: 2010-04-26 20:34:31 -0500 (Mon, 26 Apr 2010) $
  */
 public class FacesContextImpl
         extends FacesContext
 {
     //~ Instance fields ----------------------------------------------------------------------------
 
     private List                        _messageClientIds = null;
     private List                        _messages         = null;
     private Application                 _application;
     private ReleaseableExternalContext  _externalContext;
     private ResponseStream              _responseStream   = null;
     private ResponseWriter              _responseWriter   = null;
     private FacesMessage.Severity       _maximumSeverity  = null;
     private UIViewRoot                  _viewRoot;
     private boolean                     _renderResponse   = false;
     private boolean                     _responseComplete = false;
     private RenderKitFactory            _renderKitFactory;
     private boolean                     _released = false;
     private ELContext                   _elContext;
     private ReleaseableFacesContextFactory _facesContextFactory = null;
     
     // Variables used to cache values
     private RenderKit _cachedRenderKit = null;
     private String _cachedRenderKitId = null;
 
     //~ Constructors -------------------------------------------------------------------------------
 
     @Deprecated
     public FacesContextImpl(final PortletContext portletContext,
             final PortletRequest portletRequest,
             final PortletResponse portletResponse)
     {
         this(new PortletExternalContextImpl(portletContext,
                                     portletRequest,
                                     portletResponse));
     }
     
     @Deprecated
     public FacesContextImpl(final ServletContext servletContext,
                 final ServletRequest servletRequest,
                 final ServletResponse servletResponse)
     {
         this(new ServletExternalContextImpl(servletContext,
                                     servletRequest,
                                     servletResponse));
     }    
     
     public FacesContextImpl(final ReleaseableExternalContext externalContext,
                             final ReleaseableFacesContextFactory facesContextFactory)
     {
         this(externalContext);
         _facesContextFactory = facesContextFactory;
     }
 
     private FacesContextImpl(final ReleaseableExternalContext externalContext)
     {
         _externalContext = externalContext;
         FacesContext.setCurrentInstance(this);  //protected method, therefore must be called from here
         _application = ((ApplicationFactory)FactoryFinder.getFactory(FactoryFinder.APPLICATION_FACTORY))
                 .getApplication();
         _renderKitFactory = (RenderKitFactory) FactoryFinder.getFactory(FactoryFinder.RENDER_KIT_FACTORY);
     }
 
     //~ Methods ------------------------------------------------------------------------------------
 
     public final ExternalContext getExternalContext()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         return (ExternalContext)_externalContext;
     }
 
     public final FacesMessage.Severity getMaximumSeverity()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         return _maximumSeverity;
     }
 
     public final Iterator getMessages()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         return (_messages != null) ? _messages.iterator() : Collections.EMPTY_LIST.iterator();
     }
 
     public final Application getApplication()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
 
         return _application;
     }
 
     public final Iterator getClientIdsWithMessages()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         if (_messages == null || _messages.isEmpty())
         {
             return NullIterator.instance();
         }
 
         final Set uniqueClientIds = new LinkedHashSet(_messageClientIds);
         return uniqueClientIds.iterator();
     }
 
     public final Iterator getMessages(final String clientId)
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         if (_messages == null)
         {
             return NullIterator.instance();
         }
 
         List lst = new ArrayList();
         for (int i = 0; i < _messages.size(); i++)
         {
             Object savedClientId = _messageClientIds.get(i);
             if (clientId == null)
             {
                 if (savedClientId == null) lst.add(_messages.get(i));
             }
             else
             {
                 if (clientId.equals(savedClientId)) lst.add(_messages.get(i));
             }
         }
         return lst.iterator();
     }
 
     public final RenderKit getRenderKit()
     {
         if (getViewRoot() == null)
         {
             return null;
         }
 
         String renderKitId = getViewRoot().getRenderKitId();
 
         if (renderKitId == null)
         {
             return null;
         }
         
         if (_cachedRenderKitId == null || !renderKitId.equals(_cachedRenderKitId))
         {
             _cachedRenderKitId = renderKitId;
             _cachedRenderKit = _renderKitFactory.getRenderKit(this, renderKitId);
         }
         
         return _cachedRenderKit;
     }
 
     public final boolean getRenderResponse()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         return _renderResponse;
     }
 
     public final boolean getResponseComplete()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         return _responseComplete;
     }
 
     public final void setResponseStream(final ResponseStream responseStream)
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         if (responseStream == null)
         {
             throw new NullPointerException("responseStream");
         }
         _responseStream = responseStream;
     }
 
     public final ResponseStream getResponseStream()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         return _responseStream;
     }
 
     public final void setResponseWriter(final ResponseWriter responseWriter)
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         if (responseWriter == null)
         {
             throw new NullPointerException("responseWriter");
         }
         _responseWriter = responseWriter;
     }
 
     public final ResponseWriter getResponseWriter()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         return _responseWriter;
     }
 
     public final void setViewRoot(final UIViewRoot viewRoot)
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         if (viewRoot == null)
         {
             throw new NullPointerException("viewRoot");
         }
         _viewRoot = viewRoot;
     }
 
     public final UIViewRoot getViewRoot()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         return _viewRoot;
     }
 
     public final void addMessage(final String clientId, final FacesMessage message)
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         if (message == null)
         {
             throw new NullPointerException("message");
         }
 
         if (_messages == null)
         {
             _messages             = new ArrayList();
             _messageClientIds     = new ArrayList();
         }
         _messages.add(message);
         _messageClientIds.add((clientId != null) ? clientId : null);
         FacesMessage.Severity serSeverity =  message.getSeverity();
         if (serSeverity != null) {
             if (_maximumSeverity == null)
             {
                 _maximumSeverity = serSeverity;
             }
             else if (serSeverity.compareTo(_maximumSeverity) > 0)
             {
                 _maximumSeverity = serSeverity;
             }
         }
     }
 
     public final void release()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         if (_facesContextFactory != null)
         {
             _facesContextFactory.release();
             _facesContextFactory = null;
         }
         if (_externalContext != null)
         {
             _externalContext.release();
             _externalContext = null;
         }
 
         _messageClientIds     = null;
         _messages             = null;
         _application          = null;
         _responseStream       = null;
         _responseWriter       = null;
         _viewRoot             = null;
         _cachedRenderKit = null;
         _cachedRenderKitId = null;
 
         _released             = true;
         FacesContext.setCurrentInstance(null);
     }
 
     public final void renderResponse()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         _renderResponse = true;
     }
 
     public final void responseComplete()
     {
         if (_released) {
             throw new IllegalStateException("FacesContext already released");
         }
         _responseComplete = true;
     }
 
     // Portlet need to do this to change from ActionRequest/Response to
     // RenderRequest/Response
     public final void setExternalContext(ReleaseableExternalContext extContext)
     {
         _externalContext = extContext;
         FacesContext.setCurrentInstance(this); //TODO: figure out if I really need to do this
     }
 
     public final ELContext getELContext() {
         if (_elContext != null) return _elContext;
         
         
         _elContext = new FacesELContext(getApplication().getELResolver(), this);
         
         ELContextEvent event = new ELContextEvent(_elContext);
         for (ELContextListener listener : getApplication().getELContextListeners()) {
             listener.contextCreated(event);
         }
         
         return _elContext;
     }
     
 }

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 org.apache.myfaces.context.servlet;
20
21		import java.util.ArrayList;
22		import java.util.Collections;
23		import java.util.Iterator;
24		import java.util.LinkedHashSet;
25		import java.util.List;
26		import java.util.Set;
27
28		import javax.el.ELContext;
29		import javax.el.ELContextEvent;
30		import javax.el.ELContextListener;
31		import javax.faces.FactoryFinder;
32		import javax.faces.application.Application;
33		import javax.faces.application.ApplicationFactory;
34		import javax.faces.application.FacesMessage;
35		import javax.faces.component.UIViewRoot;
36		import javax.faces.context.ExternalContext;
37		import javax.faces.context.FacesContext;
38		import javax.faces.context.ResponseStream;
39		import javax.faces.context.ResponseWriter;
40		import javax.faces.render.RenderKit;
41		import javax.faces.render.RenderKitFactory;
42		import javax.portlet.PortletContext;
43		import javax.portlet.PortletRequest;
44		import javax.portlet.PortletResponse;
45		import javax.servlet.ServletContext;
46		import javax.servlet.ServletRequest;
47		import javax.servlet.ServletResponse;
48
49		import org.apache.myfaces.context.ReleaseableExternalContext;
50		import org.apache.myfaces.context.ReleaseableFacesContextFactory;
51		import org.apache.myfaces.context.portlet.PortletExternalContextImpl;
52		import org.apache.myfaces.el.unified.FacesELContext;
53		import org.apache.myfaces.shared_impl.util.NullIterator;
54
55
56		/**
57		* @author Manfred Geiler (latest modification by $Author: lu4242 $)
58		* @author Anton Koinov
59		* @version $Revision: 938287 $ $Date: 2010-04-26 20:34:31 -0500 (Mon, 26 Apr 2010) $
60		*/
61		public class FacesContextImpl
62		extends FacesContext
63		{
64		//~ Instance fields ----------------------------------------------------------------------------
65
66	0	private List _messageClientIds = null;
67	0	private List _messages = null;
68		private Application _application;
69		private ReleaseableExternalContext _externalContext;
70	0	private ResponseStream _responseStream = null;
71	0	private ResponseWriter _responseWriter = null;
72	0	private FacesMessage.Severity _maximumSeverity = null;
73		private UIViewRoot _viewRoot;
74	0	private boolean _renderResponse = false;
75	0	private boolean _responseComplete = false;
76		private RenderKitFactory _renderKitFactory;
77	0	private boolean _released = false;
78		private ELContext _elContext;
79	0	private ReleaseableFacesContextFactory _facesContextFactory = null;
80
81		// Variables used to cache values
82	0	private RenderKit _cachedRenderKit = null;
83	0	private String _cachedRenderKitId = null;
84
85		//~ Constructors -------------------------------------------------------------------------------
86
87		@Deprecated
88		public FacesContextImpl(final PortletContext portletContext,
89		final PortletRequest portletRequest,
90		final PortletResponse portletResponse)
91		{
92	0	this(new PortletExternalContextImpl(portletContext,
93		portletRequest,
94		portletResponse));
95	0	}
96
97		@Deprecated
98		public FacesContextImpl(final ServletContext servletContext,
99		final ServletRequest servletRequest,
100		final ServletResponse servletResponse)
101		{
102	0	this(new ServletExternalContextImpl(servletContext,
103		servletRequest,
104		servletResponse));
105	0	}
106
107		public FacesContextImpl(final ReleaseableExternalContext externalContext,
108		final ReleaseableFacesContextFactory facesContextFactory)
109		{
110	0	this(externalContext);
111	0	_facesContextFactory = facesContextFactory;
112	0	}
113
114		private FacesContextImpl(final ReleaseableExternalContext externalContext)
115	0	{
116	0	_externalContext = externalContext;
117	0	FacesContext.setCurrentInstance(this); //protected method, therefore must be called from here
118	0	_application = ((ApplicationFactory)FactoryFinder.getFactory(FactoryFinder.APPLICATION_FACTORY))
119		.getApplication();
120	0	_renderKitFactory = (RenderKitFactory) FactoryFinder.getFactory(FactoryFinder.RENDER_KIT_FACTORY);
121	0	}
122
123		//~ Methods ------------------------------------------------------------------------------------
124
125		public final ExternalContext getExternalContext()
126		{
127	0	if (_released) {
128	0	throw new IllegalStateException("FacesContext already released");
129		}
130	0	return (ExternalContext)_externalContext;
131		}
132
133		public final FacesMessage.Severity getMaximumSeverity()
134		{
135	0	if (_released) {
136	0	throw new IllegalStateException("FacesContext already released");
137		}
138	0	return _maximumSeverity;
139		}
140
141		public final Iterator getMessages()
142		{
143	0	if (_released) {
144	0	throw new IllegalStateException("FacesContext already released");
145		}
146	0	return (_messages != null) ? _messages.iterator() : Collections.EMPTY_LIST.iterator();
147		}
148
149		public final Application getApplication()
150		{
151	0	if (_released) {
152	0	throw new IllegalStateException("FacesContext already released");
153		}
154
155	0	return _application;
156		}
157
158		public final Iterator getClientIdsWithMessages()
159		{
160	0	if (_released) {
161	0	throw new IllegalStateException("FacesContext already released");
162		}
163	0	if (_messages == null \|\| _messages.isEmpty())
164		{
165	0	return NullIterator.instance();
166		}
167
168	0	final Set uniqueClientIds = new LinkedHashSet(_messageClientIds);
169	0	return uniqueClientIds.iterator();
170		}
171
172		public final Iterator getMessages(final String clientId)
173		{
174	0	if (_released) {
175	0	throw new IllegalStateException("FacesContext already released");
176		}
177	0	if (_messages == null)
178		{
179	0	return NullIterator.instance();
180		}
181
182	0	List lst = new ArrayList();
183	0	for (int i = 0; i < _messages.size(); i++)
184		{
185	0	Object savedClientId = _messageClientIds.get(i);
186	0	if (clientId == null)
187		{
188	0	if (savedClientId == null) lst.add(_messages.get(i));
189		}
190		else
191		{
192	0	if (clientId.equals(savedClientId)) lst.add(_messages.get(i));
193		}
194		}
195	0	return lst.iterator();
196		}
197
198		public final RenderKit getRenderKit()
199		{
200	0	if (getViewRoot() == null)
201		{
202	0	return null;
203		}
204
205	0	String renderKitId = getViewRoot().getRenderKitId();
206
207	0	if (renderKitId == null)
208		{
209	0	return null;
210		}
211
212	0	if (_cachedRenderKitId == null \|\| !renderKitId.equals(_cachedRenderKitId))
213		{
214	0	_cachedRenderKitId = renderKitId;
215	0	_cachedRenderKit = _renderKitFactory.getRenderKit(this, renderKitId);
216		}
217
218	0	return _cachedRenderKit;
219		}
220
221		public final boolean getRenderResponse()
222		{
223	0	if (_released) {
224	0	throw new IllegalStateException("FacesContext already released");
225		}
226	0	return _renderResponse;
227		}
228
229		public final boolean getResponseComplete()
230		{
231	0	if (_released) {
232	0	throw new IllegalStateException("FacesContext already released");
233		}
234	0	return _responseComplete;
235		}
236
237		public final void setResponseStream(final ResponseStream responseStream)
238		{
239	0	if (_released) {
240	0	throw new IllegalStateException("FacesContext already released");
241		}
242	0	if (responseStream == null)
243		{
244	0	throw new NullPointerException("responseStream");
245		}
246	0	_responseStream = responseStream;
247	0	}
248
249		public final ResponseStream getResponseStream()
250		{
251	0	if (_released) {
252	0	throw new IllegalStateException("FacesContext already released");
253		}
254	0	return _responseStream;
255		}
256
257		public final void setResponseWriter(final ResponseWriter responseWriter)
258		{
259	0	if (_released) {
260	0	throw new IllegalStateException("FacesContext already released");
261		}
262	0	if (responseWriter == null)
263		{
264	0	throw new NullPointerException("responseWriter");
265		}
266	0	_responseWriter = responseWriter;
267	0	}
268
269		public final ResponseWriter getResponseWriter()
270		{
271	0	if (_released) {
272	0	throw new IllegalStateException("FacesContext already released");
273		}
274	0	return _responseWriter;
275		}
276
277		public final void setViewRoot(final UIViewRoot viewRoot)
278		{
279	0	if (_released) {
280	0	throw new IllegalStateException("FacesContext already released");
281		}
282	0	if (viewRoot == null)
283		{
284	0	throw new NullPointerException("viewRoot");
285		}
286	0	_viewRoot = viewRoot;
287	0	}
288
289		public final UIViewRoot getViewRoot()
290		{
291	0	if (_released) {
292	0	throw new IllegalStateException("FacesContext already released");
293		}
294	0	return _viewRoot;
295		}
296
297		public final void addMessage(final String clientId, final FacesMessage message)
298		{
299	0	if (_released) {
300	0	throw new IllegalStateException("FacesContext already released");
301		}
302	0	if (message == null)
303		{
304	0	throw new NullPointerException("message");
305		}
306
307	0	if (_messages == null)
308		{
309	0	_messages = new ArrayList();
310	0	_messageClientIds = new ArrayList();
311		}
312	0	_messages.add(message);
313	0	_messageClientIds.add((clientId != null) ? clientId : null);
314	0	FacesMessage.Severity serSeverity = message.getSeverity();
315	0	if (serSeverity != null) {
316	0	if (_maximumSeverity == null)
317		{
318	0	_maximumSeverity = serSeverity;
319		}
320	0	else if (serSeverity.compareTo(_maximumSeverity) > 0)
321		{
322	0	_maximumSeverity = serSeverity;
323		}
324		}
325	0	}
326
327		public final void release()
328		{
329	0	if (_released) {
330	0	throw new IllegalStateException("FacesContext already released");
331		}
332	0	if (_facesContextFactory != null)
333		{
334	0	_facesContextFactory.release();
335	0	_facesContextFactory = null;
336		}
337	0	if (_externalContext != null)
338		{
339	0	_externalContext.release();
340	0	_externalContext = null;
341		}
342
343	0	_messageClientIds = null;
344	0	_messages = null;
345	0	_application = null;
346	0	_responseStream = null;
347	0	_responseWriter = null;
348	0	_viewRoot = null;
349	0	_cachedRenderKit = null;
350	0	_cachedRenderKitId = null;
351
352	0	_released = true;
353	0	FacesContext.setCurrentInstance(null);
354	0	}
355
356		public final void renderResponse()
357		{
358	0	if (_released) {
359	0	throw new IllegalStateException("FacesContext already released");
360		}
361	0	_renderResponse = true;
362	0	}
363
364		public final void responseComplete()
365		{
366	0	if (_released) {
367	0	throw new IllegalStateException("FacesContext already released");
368		}
369	0	_responseComplete = true;
370	0	}
371
372		// Portlet need to do this to change from ActionRequest/Response to
373		// RenderRequest/Response
374		public final void setExternalContext(ReleaseableExternalContext extContext)
375		{
376	0	_externalContext = extContext;
377	0	FacesContext.setCurrentInstance(this); //TODO: figure out if I really need to do this
378	0	}
379
380		public final ELContext getELContext() {
381	0	if (_elContext != null) return _elContext;
382
383
384	0	_elContext = new FacesELContext(getApplication().getELResolver(), this);
385
386	0	ELContextEvent event = new ELContextEvent(_elContext);
387	0	for (ELContextListener listener : getApplication().getELContextListeners()) {
388	0	listener.contextCreated(event);
389		}
390
391	0	return _elContext;
392		}
393
394		}