Coverage Report

Coverage Report - org.apache.myfaces.view.facelets.AbstractFaceletContext

Classes in this File

0/11

 /*
  * 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.view.facelets;
 
 import java.io.IOException;
 import java.util.Iterator;
 
 import javax.el.ELException;
 import javax.faces.FacesException;
 import javax.faces.application.Resource;
 import javax.faces.component.UIComponent;
 import javax.faces.view.facelets.FaceletContext;
 import javax.faces.view.facelets.FaceletException;
 
 import org.apache.myfaces.view.facelets.tag.jsf.core.AjaxHandler;
 
 
 /**
  * This class contains methods that belongs to original FaceletContext shipped in
  * facelets code before 2.0, but does not take part from api, so are considered 
  * implementation details. This includes methods related to template handling
  * feature of facelets (called by ui:composition, ui:define and ui:insert).
  * 
  * The methods here are only used by the current implementation and the intention
  * is not expose it as public api.
  * 
  * Aditionally, it also contains methods used by the current implementation for
  * implement new features, like composite components and UniqueIdVendor support.
  * 
  * @author Leonardo Uribe (latest modification by $Author$)
  * @version $Revision$ $Date$
  * 
  * @since 2.0
  */
 public abstract class AbstractFaceletContext extends FaceletContext
 {    
     /**
      * Return the current FaceletCompositionContext instance from this
      * build.
      * 
      * @return the current FaceletCompositionContext instance
      */
     public abstract FaceletCompositionContext getFaceletCompositionContext();
     
     /**
      * Push the passed TemplateClient onto the stack for Definition Resolution
      * @param client
      * @see TemplateClient
      */
     public abstract void pushClient(TemplateClient client);
 
     /**
      * Pop the last added pushed TemplateClient
      * @see TemplateClient
      */
     public abstract TemplateManager popClient(TemplateClient client);
     
     /**
      * Pop the last added extended TemplateClient
      * @param client
      */
     public abstract TemplateManager popExtendedClient(TemplateClient client);
 
     public abstract void extendClient(TemplateClient client);
 
     /**
      * This method will walk through the TemplateClient stack to resolve and
      * apply the definition for the passed name.
      * If it's been resolved and applied, this method will return true.
      * 
      * @param parent the UIComponent to apply to
      * @param name name or null of the definition you want to apply
      * @return true if successfully applied, otherwise false
      * @throws IOException
      * @throws FaceletException
      * @throws FacesException
      * @throws ELException
      */
     public abstract boolean includeDefinition(UIComponent parent, String name)
             throws IOException, FaceletException, FacesException, ELException;
     
     /**
      * Apply the facelet referenced by a url containing a composite component
      * definition to the current UIComponent. In other words, apply the section
      * composite:implementation in the facelet to the current component.
      * 
      * We need to do this here because DefaultFacelet is the one who has and
      * handle the current FaceletFactory instance.
      * 
      * @param parent
      * @param url
      * @throws IOException
      * @throws FaceletException
      * @throws FacesException
      * @throws ELException
      */
     public abstract void applyCompositeComponent(UIComponent parent, Resource resource)
             throws IOException, FaceletException, FacesException, ELException;
 
     /**
      * Return a descending iterator containing the ajax handlers to be applied
      * to an specific component that implements ClientBehaviorHolder interface,
      * according to the conditions specified on jsf 2.0 spec section 10.4.1.1.
      * 
      * @since 2.0
      */
     public abstract Iterator<AjaxHandler> getAjaxHandlers();
     
     /**
      * @since 2.0
      */
     public abstract void popAjaxHandlerToStack();
     
     /**
      * @since 2.0
      */
     public abstract void pushAjaxHandlerToStack(AjaxHandler parent);
     
     /**
      * Check if this build is for build composite component metadata
      * 
      * @return
      * @since 2.0
      */
     public abstract boolean isBuildingCompositeComponentMetadata();
 
     /**
      * Pop the current composite component template client, removing the
      * current template context from stack.
      * 
      * @since 2.0.1
      */
     public abstract void popCompositeComponentClient();
 
     /**
      * Push the composite component tag handler identified by client on 
      * template context stack, triggering the creation of a new empty 
      * TemplateContext, that will be used to resolve templates used 
      * on that component later.
      * 
      * @since 2.0.1
      */
     public abstract void pushCompositeComponentClient(final TemplateClient client);
 
     /**
      * Push the passed template context instance onto the stack, so all
      * slots to be resolved (using includeDefinition() call) will take
      * into account the information there.
      * 
      * @since 2.0.1
      */
     public abstract void pushTemplateContext(TemplateContext templateContext);
 
     /**
      * Pop the passed template context instance from stack. This method is
      * used by CompositeComponentResourceTagHandler to resolve templates
      * according to the composite component level it is necessary.
      * 
      * @since 2.0.1
      */
     public abstract TemplateContext popTemplateContext();
 
     /**
      * This method resolve the current definition to be added by cc:insertChildren
      * or cc:insertFacet.
      *  
      * @since 2.0.1
      */
     public abstract boolean includeCompositeComponentDefinition(UIComponent parent, String name)
         throws IOException, FaceletException, FacesException, ELException;
     
     /**
      * Return the current template context
      * 
      * @since 2.0.8
      * @return
      */
     public TemplateContext getTemplateContext()
     {
         return null;
     }
 
     /**
      * Push the passed page context instance onto the stack.
      * 
      * @since 2.0.8
      * @param client
      */
     public void pushPageContext(PageContext client)
     {
     }
     
     /**
      * Pop the passed page context instance onto the stack.
      * 
      * @since 2.0.8
      * @param client
      */
     public PageContext popPageContext()
     {
         return null;
     }
     
     /**
      * Return the current page context
      * 
      * @since 2.0.8
      * @return
      */
     public PageContext getPageContext()
     {
         return null;
     }
     
     /**
      * Check if a variable has been resolved by this variable mapper
      * or any parent "facelets contextual" variable mapper.
      * 
      * @return
      * @since 2.0.8
      */
     public boolean isAnyFaceletsVariableResolved()
     {
         return true;
     }
     
     public boolean isAllowCacheELExpressions()
     {
         return false;
     }
     
     /**
      * Indicates an expression will be resolved, so preparations
      * should be done to detect if a contextual variable has been resolved.
      * 
      * @since 2.0.8
      */
     public void beforeConstructELExpression()
     {
     }
     
     /**
      * Cleanup all initialization done for construct an EL Expression.
      * 
      * @since 2.0.8
      */
     public void afterConstructELExpression()
     {
     }
 
     /**
      * Return the mode used to decide whether to cache or not EL expressions
      * 
      * @since 2.0.8
      */
     public ELExpressionCacheMode getELExpressionCacheMode()
     {
         return ELExpressionCacheMode.noCache;
     }
     
     public String generateUniqueFaceletTagId(String count, String base)
     {
         return count;
     }
 }

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.view.facelets;
20
21		import java.io.IOException;
22		import java.util.Iterator;
23
24		import javax.el.ELException;
25		import javax.faces.FacesException;
26		import javax.faces.application.Resource;
27		import javax.faces.component.UIComponent;
28		import javax.faces.view.facelets.FaceletContext;
29		import javax.faces.view.facelets.FaceletException;
30
31		import org.apache.myfaces.view.facelets.tag.jsf.core.AjaxHandler;
32
33
34		/**
35		* This class contains methods that belongs to original FaceletContext shipped in
36		* facelets code before 2.0, but does not take part from api, so are considered
37		* implementation details. This includes methods related to template handling
38		* feature of facelets (called by ui:composition, ui:define and ui:insert).
39		*
40		* The methods here are only used by the current implementation and the intention
41		* is not expose it as public api.
42		*
43		* Aditionally, it also contains methods used by the current implementation for
44		* implement new features, like composite components and UniqueIdVendor support.
45		*
46		* @author Leonardo Uribe (latest modification by $Author$)
47		* @version $Revision$ $Date$
48		*
49		* @since 2.0
50		*/
51	0	public abstract class AbstractFaceletContext extends FaceletContext
52		{
53		/**
54		* Return the current FaceletCompositionContext instance from this
55		* build.
56		*
57		* @return the current FaceletCompositionContext instance
58		*/
59		public abstract FaceletCompositionContext getFaceletCompositionContext();
60
61		/**
62		* Push the passed TemplateClient onto the stack for Definition Resolution
63		* @param client
64		* @see TemplateClient
65		*/
66		public abstract void pushClient(TemplateClient client);
67
68		/**
69		* Pop the last added pushed TemplateClient
70		* @see TemplateClient
71		*/
72		public abstract TemplateManager popClient(TemplateClient client);
73
74		/**
75		* Pop the last added extended TemplateClient
76		* @param client
77		*/
78		public abstract TemplateManager popExtendedClient(TemplateClient client);
79
80		public abstract void extendClient(TemplateClient client);
81
82		/**
83		* This method will walk through the TemplateClient stack to resolve and
84		* apply the definition for the passed name.
85		* If it's been resolved and applied, this method will return true.
86		*
87		* @param parent the UIComponent to apply to
88		* @param name name or null of the definition you want to apply
89		* @return true if successfully applied, otherwise false
90		* @throws IOException
91		* @throws FaceletException
92		* @throws FacesException
93		* @throws ELException
94		*/
95		public abstract boolean includeDefinition(UIComponent parent, String name)
96		throws IOException, FaceletException, FacesException, ELException;
97
98		/**
99		* Apply the facelet referenced by a url containing a composite component
100		* definition to the current UIComponent. In other words, apply the section
101		* composite:implementation in the facelet to the current component.
102		*
103		* We need to do this here because DefaultFacelet is the one who has and
104		* handle the current FaceletFactory instance.
105		*
106		* @param parent
107		* @param url
108		* @throws IOException
109		* @throws FaceletException
110		* @throws FacesException
111		* @throws ELException
112		*/
113		public abstract void applyCompositeComponent(UIComponent parent, Resource resource)
114		throws IOException, FaceletException, FacesException, ELException;
115
116		/**
117		* Return a descending iterator containing the ajax handlers to be applied
118		* to an specific component that implements ClientBehaviorHolder interface,
119		* according to the conditions specified on jsf 2.0 spec section 10.4.1.1.
120		*
121		* @since 2.0
122		*/
123		public abstract Iterator<AjaxHandler> getAjaxHandlers();
124
125		/**
126		* @since 2.0
127		*/
128		public abstract void popAjaxHandlerToStack();
129
130		/**
131		* @since 2.0
132		*/
133		public abstract void pushAjaxHandlerToStack(AjaxHandler parent);
134
135		/**
136		* Check if this build is for build composite component metadata
137		*
138		* @return
139		* @since 2.0
140		*/
141		public abstract boolean isBuildingCompositeComponentMetadata();
142
143		/**
144		* Pop the current composite component template client, removing the
145		* current template context from stack.
146		*
147		* @since 2.0.1
148		*/
149		public abstract void popCompositeComponentClient();
150
151		/**
152		* Push the composite component tag handler identified by client on
153		* template context stack, triggering the creation of a new empty
154		* TemplateContext, that will be used to resolve templates used
155		* on that component later.
156		*
157		* @since 2.0.1
158		*/
159		public abstract void pushCompositeComponentClient(final TemplateClient client);
160
161		/**
162		* Push the passed template context instance onto the stack, so all
163		* slots to be resolved (using includeDefinition() call) will take
164		* into account the information there.
165		*
166		* @since 2.0.1
167		*/
168		public abstract void pushTemplateContext(TemplateContext templateContext);
169
170		/**
171		* Pop the passed template context instance from stack. This method is
172		* used by CompositeComponentResourceTagHandler to resolve templates
173		* according to the composite component level it is necessary.
174		*
175		* @since 2.0.1
176		*/
177		public abstract TemplateContext popTemplateContext();
178
179		/**
180		* This method resolve the current definition to be added by cc:insertChildren
181		* or cc:insertFacet.
182		*
183		* @since 2.0.1
184		*/
185		public abstract boolean includeCompositeComponentDefinition(UIComponent parent, String name)
186		throws IOException, FaceletException, FacesException, ELException;
187
188		/**
189		* Return the current template context
190		*
191		* @since 2.0.8
192		* @return
193		*/
194		public TemplateContext getTemplateContext()
195		{
196	0	return null;
197		}
198
199		/**
200		* Push the passed page context instance onto the stack.
201		*
202		* @since 2.0.8
203		* @param client
204		*/
205		public void pushPageContext(PageContext client)
206		{
207	0	}
208
209		/**
210		* Pop the passed page context instance onto the stack.
211		*
212		* @since 2.0.8
213		* @param client
214		*/
215		public PageContext popPageContext()
216		{
217	0	return null;
218		}
219
220		/**
221		* Return the current page context
222		*
223		* @since 2.0.8
224		* @return
225		*/
226		public PageContext getPageContext()
227		{
228	0	return null;
229		}
230
231		/**
232		* Check if a variable has been resolved by this variable mapper
233		* or any parent "facelets contextual" variable mapper.
234		*
235		* @return
236		* @since 2.0.8
237		*/
238		public boolean isAnyFaceletsVariableResolved()
239		{
240	0	return true;
241		}
242
243		public boolean isAllowCacheELExpressions()
244		{
245	0	return false;
246		}
247
248		/**
249		* Indicates an expression will be resolved, so preparations
250		* should be done to detect if a contextual variable has been resolved.
251		*
252		* @since 2.0.8
253		*/
254		public void beforeConstructELExpression()
255		{
256	0	}
257
258		/**
259		* Cleanup all initialization done for construct an EL Expression.
260		*
261		* @since 2.0.8
262		*/
263		public void afterConstructELExpression()
264		{
265	0	}
266
267		/**
268		* Return the mode used to decide whether to cache or not EL expressions
269		*
270		* @since 2.0.8
271		*/
272		public ELExpressionCacheMode getELExpressionCacheMode()
273		{
274	0	return ELExpressionCacheMode.noCache;
275		}
276
277		public String generateUniqueFaceletTagId(String count, String base)
278		{
279	0	return count;
280		}
281		}