KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > quartz > listeners > FilterAndBroadcastTriggerListener


1 /*
2  * Copyright 2004-2006 OpenSymphony
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5  * use this file except in compliance with the License. You may obtain a copy
6  * 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, WITHOUT
12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13  * License for the specific language governing permissions and limitations
14  * under the License.
15  */
16 package org.quartz.listeners;
17
18 import java.util.Iterator JavaDoc;
19 import java.util.LinkedList JavaDoc;
20 import java.util.List JavaDoc;
21
22 import org.quartz.JobExecutionContext;
23 import org.quartz.Trigger;
24 import org.quartz.TriggerListener;
25
26 /**
27  * Holds a List of references to TriggerListener instances and broadcasts all
28  * events to them (in order) - if the event is not excluded via filtering
29  * (read on).
30  *
31  * <p>The broadcasting behavior of this listener to delegate listeners may be
32  * more convenient than registering all of the listeners directly with the
33  * Trigger, and provides the flexibility of easily changing which listeners
34  * get notified.</p>
35  *
36  * <p>You may also register a number of Regular Expression patterns to match
37  * the events against. If one or more patterns are registered, the broadcast
38  * will only take place if the event applies to a trigger who's name/group
39  * matches one or more of the patterns.</p>
40  *
41  * @see #addListener(org.quartz.TriggerListener)
42  * @see #removeListener(org.quartz.TriggerListener)
43  * @see #removeListener(String)
44  * @see #addTriggerNamePattern(String)
45  * @see #addTriggerGroupPattern(String)
46  *
47  * @author James House (jhouse AT revolition DOT net)
48  */
49 public class FilterAndBroadcastTriggerListener implements TriggerListener {
50
51     private String JavaDoc name;
52     private List JavaDoc listeners;
53     private List JavaDoc namePatterns = new LinkedList JavaDoc();
54     private List JavaDoc groupPatterns = new LinkedList JavaDoc();
55
56     /**
57      * Construct an instance with the given name.
58      *
59      * (Remember to add some delegate listeners!)
60      *
61      * @param name the name of this instance
62      */
63     public FilterAndBroadcastTriggerListener(String JavaDoc name) {
64         if(name == null)
65             throw new IllegalArgumentException JavaDoc("Listener name cannot be null!");
66         this.name = name;
67         listeners = new LinkedList JavaDoc();
68     }
69
70     /**
71      * Construct an instance with the given name, and List of listeners.
72      *
73      * @param name the name of this instance
74      * @param listeners the initial List of TriggerListeners to broadcast to.
75      */
76     public FilterAndBroadcastTriggerListener(String JavaDoc name, List JavaDoc listeners) {
77         this(name);
78         this.listeners.addAll(listeners);
79     }
80
81     public String JavaDoc getName() {
82         return name;
83     }
84
85     public void addListener(TriggerListener listener) {
86         listeners.add(listener);
87     }
88
89     public boolean removeListener(TriggerListener listener) {
90         return listeners.remove(listener);
91     }
92
93     public boolean removeListener(String JavaDoc listenerName) {
94         Iterator JavaDoc itr = listeners.iterator();
95         while(itr.hasNext()) {
96             TriggerListener l = (TriggerListener) itr.next();
97             if(l.getName().equals(listenerName)) {
98                 itr.remove();
99                 return true;
100             }
101         }
102         return false;
103     }
104
105     public List JavaDoc getListeners() {
106         return java.util.Collections.unmodifiableList(listeners);
107     }
108
109     /**
110      * If one or more name patterns are specified, only events relating to
111      * triggers who's name matches the given regular expression pattern
112      * will be dispatched to the delegate listeners.
113      *
114      * @param regularExpression
115      */
116     public void addTriggerNamePattern(String JavaDoc regularExpression) {
117         if(regularExpression == null)
118             throw new IllegalArgumentException JavaDoc("Expression cannot be null!");
119
120         namePatterns.add(regularExpression);
121     }
122
123     public List JavaDoc getTriggerNamePatterns() {
124         return namePatterns;
125     }
126
127     /**
128      * If one or more group patterns are specified, only events relating to
129      * triggers who's group matches the given regular expression pattern
130      * will be dispatched to the delegate listeners.
131      *
132      * @param regularExpression
133      */
134     public void addTriggerGroupPattern(String JavaDoc regularExpression) {
135         if(regularExpression == null)
136             throw new IllegalArgumentException JavaDoc("Expression cannot be null!");
137
138         groupPatterns.add(regularExpression);
139     }
140
141     public List JavaDoc getTriggerGroupPatterns() {
142         return namePatterns;
143     }
144
145     protected boolean shouldDispatch(Trigger trigger) {
146
147         if(namePatterns.size() == 0 && groupPatterns.size() == 0)
148             return true;
149
150         Iterator JavaDoc itr = groupPatterns.iterator();
151         while(itr.hasNext()) {
152             String JavaDoc pat = (String JavaDoc) itr.next();
153             if(trigger.getGroup().matches(pat))
154                 return true;
155         }
156
157         itr = namePatterns.iterator();
158         while(itr.hasNext()) {
159             String JavaDoc pat = (String JavaDoc) itr.next();
160             if(trigger.getName().matches(pat))
161                 return true;
162         }
163
164         return false;
165     }
166
167     public void triggerFired(Trigger trigger, JobExecutionContext context) {
168
169         if(!shouldDispatch(trigger))
170             return;
171
172         Iterator JavaDoc itr = listeners.iterator();
173         while(itr.hasNext()) {
174             TriggerListener l = (TriggerListener) itr.next();
175             l.triggerFired(trigger, context);
176         }
177     }
178
179     public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
180
181         if(!shouldDispatch(trigger))
182             return false;
183
184         Iterator JavaDoc itr = listeners.iterator();
185         while(itr.hasNext()) {
186             TriggerListener l = (TriggerListener) itr.next();
187             if(l.vetoJobExecution(trigger, context))
188                 return true;
189         }
190         return false;
191     }
192
193     public void triggerMisfired(Trigger trigger) {
194
195         if(!shouldDispatch(trigger))
196             return;
197
198         Iterator JavaDoc itr = listeners.iterator();
199         while(itr.hasNext()) {
200             TriggerListener l = (TriggerListener) itr.next();
201             l.triggerMisfired(trigger);
202         }
203     }
204
205     public void triggerComplete(Trigger trigger, JobExecutionContext context, int triggerInstructionCode) {
206
207         if(!shouldDispatch(trigger))
208             return;
209
210         Iterator JavaDoc itr = listeners.iterator();
211         while(itr.hasNext()) {
212             TriggerListener l = (TriggerListener) itr.next();
213             l.triggerComplete(trigger, context, triggerInstructionCode);
214         }
215     }
216
217 }
218
Popular Tags