KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > icesoft > faces > async > render > GroupAsyncRenderer


1 /*
2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
3  *
4  * "The contents of this file are subject to the Mozilla Public License
5  * Version 1.1 (the "License"); you may not use this file except in
6  * compliance with the License. You may obtain a copy of the License at
7  * http://www.mozilla.org/MPL/
8  *
9  * Software distributed under the License is distributed on an "AS IS"
10  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
11  * License for the specific language governing rights and limitations under
12  * the License.
13  *
14  * The Original Code is ICEfaces 1.5 open source software code, released
15  * November 5, 2006. The Initial Developer of the Original Code is ICEsoft
16  * Technologies Canada, Corp. Portions created by ICEsoft are Copyright (C)
17  * 2004-2006 ICEsoft Technologies Canada, Corp. All Rights Reserved.
18  *
19  * Contributor(s): _____________________.
20  *
21  * Alternatively, the contents of this file may be used under the terms of
22  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"
23  * License), in which case the provisions of the LGPL License are
24  * applicable instead of those above. If you wish to allow use of your
25  * version of this file only under the terms of the LGPL License and not to
26  * allow others to use your version of this file under the MPL, indicate
27  * your decision by deleting the provisions above and replace them with
28  * the notice and other provisions required by the LGPL License. If you do
29  * not delete the provisions above, a recipient may use your version of
30  * this file under either the MPL or the LGPL License."
31  *
32  */
33
34 package com.icesoft.faces.async.render;
35
36 import edu.emory.mathcs.backport.java.util.concurrent.CopyOnWriteArraySet;
37 import org.apache.commons.logging.Log;
38 import org.apache.commons.logging.LogFactory;
39
40 import java.lang.ref.WeakReference JavaDoc;
41 import java.util.Iterator JavaDoc;
42 import java.util.Set JavaDoc;
43
44 /**
45  * The GroupAsyncRenderer is the foundation class for other types of renderers
46  * that are designed to operate on a group of {@link Renderable}s. It
47  * implements the {@link AsyncRenderer} interface and is mainly responsible for
48  * smartly managing a group of Renderable instances.
49  * <p/>
50  * Groups of Renderables are stored as WeakReferences in special sets that are
51  * copied before each render pass so that Renderables can be safely added and
52  * removed from the group while a render pass is in progress.
53  * <p/>
54  * Although it is possible to create and use GroupRenderers directly, developers
55  * are advised to use the {@link RenderManager} to create and use named render
56  * groups.
57  *
58  * @author ICEsoft Technologies, Inc.
59  * @see RenderManager, OnDemandRenderer, IntervalRenderer, DelayRenderer
60  */
61 public class GroupAsyncRenderer implements AsyncRenderer {
62
63     private static Log log = LogFactory.getLog(GroupAsyncRenderer.class);
64
65     protected String JavaDoc name;
66     protected Set group;
67     protected RenderManager renderManager;
68
69     protected boolean stopRequested = false;
70
71     public GroupAsyncRenderer() {
72         group = new CopyOnWriteArraySet();
73     }
74
75     public String JavaDoc getName() {
76         return name;
77     }
78
79     public void setName(String JavaDoc name) {
80         this.name = name;
81     }
82
83     public void setRenderManager(RenderManager renderManager) {
84         this.renderManager = renderManager;
85     }
86
87     /**
88      * Adds a Renderable, via a WeakReference, to the set of Renderables of this
89      * group. If the Renderable is already in this set, it is not added again.
90      *
91      * @param renderable the Renderable instance to add to the group.
92      */
93     public void add(Renderable renderable) {
94         synchronized (group) {
95             if (!contains(renderable)) {
96                 if (group.add(new WeakReference JavaDoc(renderable))) {
97                     if (log.isTraceEnabled()) {
98                         log.trace(name + " added " + renderable);
99                     }
100                 } else {
101                     if (log.isWarnEnabled()) {
102                         log.warn(name + " already contains " + renderable);
103                     }
104                 }
105             }
106         }
107     }
108
109     public boolean contains(Renderable renderable) {
110         Iterator JavaDoc iter = group.iterator();
111         while (iter.hasNext()) {
112             if (renderable ==
113                 (Renderable) ((WeakReference JavaDoc) iter.next()).get()) {
114                 return true;
115             }
116         }
117         return false;
118     }
119
120     /**
121      * Removes a Renderable, via a WeakReference, from the set of Renderables of
122      * this group.
123      *
124      * @param renderable the Renderable instance to remove
125      */
126     public void remove(Renderable renderable) {
127         synchronized (group) {
128             Iterator JavaDoc iter = group.iterator();
129             while (iter.hasNext()) {
130                 WeakReference JavaDoc ref = (WeakReference JavaDoc) iter.next();
131                 if (renderable == (Renderable) ref.get()) {
132                     group.remove(ref);
133                     if (log.isTraceEnabled()) {
134                         log.trace(name + " removing " + renderable);
135                     }
136                     return;
137                 }
138             }
139             if (log.isWarnEnabled()) {
140                 log.warn(name + " does not contain " + renderable);
141             }
142         }
143     }
144
145     /**
146      * Removes all Renderables from the group.
147      */
148     public void clear() {
149         synchronized (group) {
150             group.clear();
151         }
152     }
153
154     /**
155      * Used to determine if the Renderer has any Renderables left in its
156      * collection.
157      *
158      * @return false if there are 1 or more Renderables left in the Renderer's
159      * collection, true otherwise
160      */
161     public boolean isEmpty() {
162         return group.isEmpty();
163     }
164
165     /**
166      * Request a render pass on all the Renderables in the group. Render calls
167      * that generate exceptions are passed back to the Renderable.renderException
168      *
169      * @throws IllegalStateException If a reference to a {@link RenderHub} has
170      * not yet been set.
171      */
172     public void requestRender() {
173         if (renderManager == null) {
174             String JavaDoc message = "RenderManager has not been set";
175             if (log.isErrorEnabled()) {
176                 log.error(message);
177             }
178             throw new IllegalStateException JavaDoc(message);
179
180         }
181
182         Iterator JavaDoc iter = group.iterator();
183         if (log.isTraceEnabled()) {
184             log.trace(name + " preparing to render " + group.size());
185         }
186
187         stopRequested = false;
188         while (iter.hasNext() && !stopRequested) {
189             Renderable renderable =
190                     (Renderable) ((WeakReference JavaDoc) iter.next()).get();
191             renderManager.requestRender(renderable);
192         }
193     }
194
195     /**
196      * The method called by dispose to halt a render pass at the current {@link
197      * Renderable}s.
198      */
199     public void requestStop() {
200         stopRequested = true;
201     }
202
203     /**
204      * Remove all Renderables from the group and removes the reference to the
205      * RenderHub. Once disposed, a GroupAsyncRenderer cannot be re-used. This
206      * method is typically used by the RenderManager to cleanly dispose of all
207      * managed Renderers when the application is shutting down.
208      */
209     public void dispose() {
210         requestStop();
211         group.clear();
212         group = null;
213         renderManager.removeRenderer(this);
214         name = null;
215         renderManager = null;
216     }
217 }
218
Popular Tags