Coverage Report

Coverage Report - org.dishevelled.observable.graph.event.ObservableGraphChangeSupport

Classes in this File

Line Coverage

Branch Coverage

Complexity

ObservableGraphChangeSupport

99%

100/101

83%

50/60

2.364

 /*
 
     dsh-observable-graph  Observable decorators for graph interfaces.
     Copyright (c) 2008-2013 held jointly by the individual authors.
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Lesser General Public License as published
     by the Free Software Foundation; either version 3 of the License, or (at
     your option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
     License for more details.
 
     You should have received a copy of the GNU Lesser General Public License
     along with this library;  if not, write to the Free Software Foundation,
     Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA.
 
     > http://www.fsf.org/licensing/licenses/lgpl.html
     > http://www.opensource.org/licenses/lgpl-license.php
 
 */
 package org.dishevelled.observable.graph.event;
 
 import java.io.Serializable;
 
 import javax.swing.event.EventListenerList;
 
 import org.dishevelled.graph.Edge;
 import org.dishevelled.graph.Node;
 import org.dishevelled.observable.graph.ObservableGraph;
 
 /**
  * A support class that can be used via delegation to provide <code>GraphChangeListener</code>
  * and <code>VetoableGraphChangeListener</code> management.
  *
  * @param <N> node value type
  * @param <E> edge value type
  * @author  Michael Heuer
  * @version $Revision$ $Date$
  */
 public class ObservableGraphChangeSupport<N, E>
     implements Serializable
 {
     /** Event source. */
     private ObservableGraph<N, E> source;
 
     /** Listener list. */
     private final EventListenerList listenerList;
 
 
     /**
      * Create a new support class meant to be subclassed.
      */
     protected ObservableGraphChangeSupport()
     {
         listenerList = new EventListenerList();
     }
 
     /**
      * Create a new support class that fires graph change and
      * vetoable graph change events with the specified source as the
      * source of the events.
      *
      * @param source the event source
      */
     public ObservableGraphChangeSupport(final ObservableGraph<N, E> source)
     {
         this();
         setSource(source);
     }
 
 
     /**
      * Set the source of graph change and vetoable graph change events
      * to <code>source</code>.  Subclasses should call this method before
      * any of the <code>fireX</code> methods.
      *
      * @param source the event source
      */
     protected void setSource(final ObservableGraph<N, E> source)
     {
         this.source = source;
     }
 
     /**
      * Return the <code>EventListenerList</code> backing this
      * observable graph support class.
      *
      * @return the <code>EventListenerList</code> backing this
      *    observable graph support class.
      */
     protected final EventListenerList getEventListenerList()
     {
         return listenerList;
     }
 
     /**
      * Add the specified graph change listener.
      *
      * @param l graph change listener to add
      */
     public final void addGraphChangeListener(final GraphChangeListener<N, E> l)
     {
         listenerList.add(GraphChangeListener.class, l);
     }
 
     /**
      * Remove the specified graph change listener.
      *
      * @param l graph change listener to remove
      */
     public final void removeGraphChangeListener(final GraphChangeListener<N, E> l)
     {
         listenerList.remove(GraphChangeListener.class, l);
     }
 
     /**
      * Add the specified vetoable graph change listener.
      *
      * @param l vetoable graph change listener to add
      */
     public final void addVetoableGraphChangeListener(final VetoableGraphChangeListener<N, E> l)
     {
         listenerList.add(VetoableGraphChangeListener.class, l);
     }
 
     /**
      * Remove the specified vetoable graph change listener.
      *
      * @param l vetoable graph change listener to remove
      */
     public final void removeVetoableGraphChangeListener(final VetoableGraphChangeListener<N, E> l)
     {
         listenerList.remove(VetoableGraphChangeListener.class, l);
     }
 
     /**
      * Return an array of all <code>GraphChangeListener</code>s, or
      * an empty array if none are registered.
      *
      * @return an array of all <code>GraphChangeListener</code>s, or
      *    an empty array if none are registered
      */
     public final GraphChangeListener<N, E>[] getGraphChangeListeners()
     {
         return (GraphChangeListener<N, E>[]) listenerList.getListeners(GraphChangeListener.class);
     }
 
     /**
      * Return the number of <code>GraphChangeListener</code>s registered
      * to this observable graph support class.
      *
      * @return the number of <code>GraphChangeListener</code>s registered
      *    to this observable graph support class
      */
     public final int getGraphChangeListenerCount()
     {
         return listenerList.getListenerCount(GraphChangeListener.class);
     }
 
     /**
      * Return an array of all <code>VetoableGraphChangeListener</code>s,
      * or an empty array if none are registered.
      *
      * @return an array of all <code>VetoableGraphChangeListener</code>s,
      *    or an empty array if none are registered
      */
     public final VetoableGraphChangeListener<N, E>[] getVetoableGraphChangeListeners()
     {
         return (VetoableGraphChangeListener<N, E>[])
             listenerList.getListeners(VetoableGraphChangeListener.class);
     }
 
     /**
      * Return the number of <code>VetoableGraphChangeListener</code>s
      * registered to this observable graph support class.
      *
      * @return the number of <code>VetoableGraphChangeListener</code>s
      *    registered to this observable graph support class
      */
     public final int getVetoableGraphChangeListenerCount()
     {
         return listenerList.getListenerCount(VetoableGraphChangeListener.class);
     }
 
     /**
      * Fire a will clear change event to all registered
      * <code>VetoableGraphChangeListener</code>s.
      *
      * @throws GraphChangeVetoException if any of the listeners veto the change
      */
     public void fireWillClear()
         throws GraphChangeVetoException
     {
         Object[] listeners = listenerList.getListenerList();
         VetoableGraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == VetoableGraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new VetoableGraphChangeEvent<N, E>(source);
                 }
                 ((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willClear(e);
             }
         }
     }
 
     /**
      * Fire a cleared change event to all registered <code>GraphChangeListener</code>s.
      */
     public void fireCleared()
     {
         Object[] listeners = listenerList.getListenerList();
         GraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == GraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new GraphChangeEvent<N, E>(source);
                 }
                 ((GraphChangeListener<N, E>) listeners[i + 1]).cleared(e);
             }
         }
     }
 
     /**
      * Fire a node created change event to all registered <code>GraphChangeListener</code>s.
      *
      * @param node newly created node
      */
     public void fireNodeCreated(final Node<N, E> node)
     {
         Object[] listeners = listenerList.getListenerList();
         GraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == GraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new GraphChangeEvent<N, E>(source, node);
                 }
                 ((GraphChangeListener<N, E>) listeners[i + 1]).nodeCreated(e);
             }
         }
     }
 
     /**
      * Fire a node removed change event to all registered <code>GraphChangeListener</code>s.
      *
      * @param node removed node
      */
     public void fireNodeRemoved(final Node<N, E> node)
     {
         Object[] listeners = listenerList.getListenerList();
         GraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == GraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new GraphChangeEvent<N, E>(source, node);
                 }
                 ((GraphChangeListener<N, E>) listeners[i + 1]).nodeRemoved(e);
             }
         }
     }
 
     /**
      * Fire an edge created change event to all registered <code>GraphChangeListener</code>s.
      *
      * @param edge newly created edge
      */
     public void fireEdgeCreated(final Edge<N, E> edge)
     {
         Object[] listeners = listenerList.getListenerList();
         GraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == GraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new GraphChangeEvent<N, E>(source, edge);
                 }
                 ((GraphChangeListener<N, E>) listeners[i + 1]).edgeCreated(e);
             }
         }
     }
 
     /**
      * Fire an edge removed change event to all registered <code>GraphChangeListener</code>s.
      *
      * @param edge removed edge
      */
     public void fireEdgeRemoved(final Edge<N, E> edge)
     {
         Object[] listeners = listenerList.getListenerList();
         GraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == GraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new GraphChangeEvent<N, E>(source, edge);
                 }
                 ((GraphChangeListener<N, E>) listeners[i + 1]).edgeRemoved(e);
             }
         }
     }
 
     /**
      * Fire a will create node create event to all registered
      * <code>VetoableGraphChangeListener</code>s.
      *
      * @param nodeValue node value for an about to be created node
      * @throws GraphChangeVetoException if any of the listeners veto the change
      */
     public void fireWillCreateNode(final N nodeValue)
         throws GraphChangeVetoException
     {
         Object[] listeners = listenerList.getListenerList();
         VetoableGraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == VetoableGraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new VetoableGraphChangeEvent<N, E>(source, nodeValue);
                 }
                 ((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willCreateNode(e);
             }
         }
     }
 
     /**
      * Fire a will create edge change event to all registered
      * <code>VetoableGraphChangeListener</code>s.
      *
      * @param sourceNode source node for an about to be created edge
      * @param targetNode target node for an about to be created edge
      * @param edgeValue edge value for an about to be created edge
      * @throws GraphChangeVetoException if any of the listeners veto the change
      */
     public void fireWillCreateEdge(final Node<N, E> sourceNode,
             final Node<N, E> targetNode,
             final E edgeValue)
         throws GraphChangeVetoException
     {
         Object[] listeners = listenerList.getListenerList();
         VetoableGraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == VetoableGraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new VetoableGraphChangeEvent<N, E>(source, sourceNode, targetNode, edgeValue);
                 }
                 ((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willCreateEdge(e);
             }
         }
     }
 
     /**
      * Fire a will remove node change event to all registered
      * <code>VetoableGraphChangeListener</code>s.
      *
      * @param node node about to be removed
      * @throws GraphChangeVetoException if any of the listeners veto the change
      */
     public void fireWillRemoveNode(final Node<N, E> node)
         throws GraphChangeVetoException
     {
         Object[] listeners = listenerList.getListenerList();
         VetoableGraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == VetoableGraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new VetoableGraphChangeEvent<N, E>(source, node);
                 }
                 ((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willRemoveNode(e);
             }
         }
     }
 
     /**
      * Fire a will remove edge change event to all registered
      * <code>VetoableGraphChangeListener</code>s.
      *
      * @param edge edge about to be removed
      * @throws GraphChangeVetoException if any of the listeners veto the change
      */
     public void fireWillRemoveEdge(final Edge<N, E> edge)
         throws GraphChangeVetoException
     {
         Object[] listeners = listenerList.getListenerList();
         VetoableGraphChangeEvent<N, E> e = null;
 
         for (int i = listeners.length - 2; i >= 0; i -= 2)
         {
             if (listeners[i] == VetoableGraphChangeListener.class)
             {
                 // lazily create the event
                 if (e == null)
                 {
                     e = new VetoableGraphChangeEvent<N, E>(source, edge);
                 }
                 ((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willRemoveEdge(e);
             }
         }
     }
 }

1		/*
2
3		dsh-observable-graph Observable decorators for graph interfaces.
4		Copyright (c) 2008-2013 held jointly by the individual authors.
5
6		This library is free software; you can redistribute it and/or modify it
7		under the terms of the GNU Lesser General Public License as published
8		by the Free Software Foundation; either version 3 of the License, or (at
9		your option) any later version.
10
11		This library is distributed in the hope that it will be useful, but WITHOUT
12		ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or
13		FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14		License for more details.
15
16		You should have received a copy of the GNU Lesser General Public License
17		along with this library; if not, write to the Free Software Foundation,
18		Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
19
20		> http://www.fsf.org/licensing/licenses/lgpl.html
21		> http://www.opensource.org/licenses/lgpl-license.php
22
23		*/
24		package org.dishevelled.observable.graph.event;
25
26		import java.io.Serializable;
27
28		import javax.swing.event.EventListenerList;
29
30		import org.dishevelled.graph.Edge;
31		import org.dishevelled.graph.Node;
32		import org.dishevelled.observable.graph.ObservableGraph;
33
34		/**
35		* A support class that can be used via delegation to provide <code>GraphChangeListener</code>
36		* and <code>VetoableGraphChangeListener</code> management.
37		*
38		* @param <N> node value type
39		* @param <E> edge value type
40		* @author Michael Heuer
41		* @version $Revision$ $Date$
42		*/
43		public class ObservableGraphChangeSupport<N, E>
44		implements Serializable
45		{
46		/** Event source. */
47		private ObservableGraph<N, E> source;
48
49		/** Listener list. */
50		private final EventListenerList listenerList;
51
52
53		/**
54		* Create a new support class meant to be subclassed.
55		*/
56		protected ObservableGraphChangeSupport()
57	133	{
58	133	listenerList = new EventListenerList();
59	133	}
60
61		/**
62		* Create a new support class that fires graph change and
63		* vetoable graph change events with the specified source as the
64		* source of the events.
65		*
66		* @param source the event source
67		*/
68		public ObservableGraphChangeSupport(final ObservableGraph<N, E> source)
69		{
70	133	this();
71	133	setSource(source);
72	133	}
73
74
75		/**
76		* Set the source of graph change and vetoable graph change events
77		* to <code>source</code>. Subclasses should call this method before
78		* any of the <code>fireX</code> methods.
79		*
80		* @param source the event source
81		*/
82		protected void setSource(final ObservableGraph<N, E> source)
83		{
84	133	this.source = source;
85	133	}
86
87		/**
88		* Return the <code>EventListenerList</code> backing this
89		* observable graph support class.
90		*
91		* @return the <code>EventListenerList</code> backing this
92		* observable graph support class.
93		*/
94		protected final EventListenerList getEventListenerList()
95		{
96	0	return listenerList;
97		}
98
99		/**
100		* Add the specified graph change listener.
101		*
102		* @param l graph change listener to add
103		*/
104		public final void addGraphChangeListener(final GraphChangeListener<N, E> l)
105		{
106	12	listenerList.add(GraphChangeListener.class, l);
107	12	}
108
109		/**
110		* Remove the specified graph change listener.
111		*
112		* @param l graph change listener to remove
113		*/
114		public final void removeGraphChangeListener(final GraphChangeListener<N, E> l)
115		{
116	12	listenerList.remove(GraphChangeListener.class, l);
117	12	}
118
119		/**
120		* Add the specified vetoable graph change listener.
121		*
122		* @param l vetoable graph change listener to add
123		*/
124		public final void addVetoableGraphChangeListener(final VetoableGraphChangeListener<N, E> l)
125		{
126	22	listenerList.add(VetoableGraphChangeListener.class, l);
127	22	}
128
129		/**
130		* Remove the specified vetoable graph change listener.
131		*
132		* @param l vetoable graph change listener to remove
133		*/
134		public final void removeVetoableGraphChangeListener(final VetoableGraphChangeListener<N, E> l)
135		{
136	22	listenerList.remove(VetoableGraphChangeListener.class, l);
137	22	}
138
139		/**
140		* Return an array of all <code>GraphChangeListener</code>s, or
141		* an empty array if none are registered.
142		*
143		* @return an array of all <code>GraphChangeListener</code>s, or
144		* an empty array if none are registered
145		*/
146		public final GraphChangeListener<N, E>[] getGraphChangeListeners()
147		{
148	10	return (GraphChangeListener<N, E>[]) listenerList.getListeners(GraphChangeListener.class);
149		}
150
151		/**
152		* Return the number of <code>GraphChangeListener</code>s registered
153		* to this observable graph support class.
154		*
155		* @return the number of <code>GraphChangeListener</code>s registered
156		* to this observable graph support class
157		*/
158		public final int getGraphChangeListenerCount()
159		{
160	4	return listenerList.getListenerCount(GraphChangeListener.class);
161		}
162
163		/**
164		* Return an array of all <code>VetoableGraphChangeListener</code>s,
165		* or an empty array if none are registered.
166		*
167		* @return an array of all <code>VetoableGraphChangeListener</code>s,
168		* or an empty array if none are registered
169		*/
170		public final VetoableGraphChangeListener<N, E>[] getVetoableGraphChangeListeners()
171		{
172	10	return (VetoableGraphChangeListener<N, E>[])
173		listenerList.getListeners(VetoableGraphChangeListener.class);
174		}
175
176		/**
177		* Return the number of <code>VetoableGraphChangeListener</code>s
178		* registered to this observable graph support class.
179		*
180		* @return the number of <code>VetoableGraphChangeListener</code>s
181		* registered to this observable graph support class
182		*/
183		public final int getVetoableGraphChangeListenerCount()
184		{
185	4	return listenerList.getListenerCount(VetoableGraphChangeListener.class);
186		}
187
188		/**
189		* Fire a will clear change event to all registered
190		* <code>VetoableGraphChangeListener</code>s.
191		*
192		* @throws GraphChangeVetoException if any of the listeners veto the change
193		*/
194		public void fireWillClear()
195		throws GraphChangeVetoException
196		{
197	4	Object[] listeners = listenerList.getListenerList();
198	4	VetoableGraphChangeEvent<N, E> e = null;
199
200	8	for (int i = listeners.length - 2; i >= 0; i -= 2)
201		{
202	6	if (listeners[i] == VetoableGraphChangeListener.class)
203		{
204		// lazily create the event
205	4	if (e == null)
206		{
207	4	e = new VetoableGraphChangeEvent<N, E>(source);
208		}
209	4	((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willClear(e);
210		}
211		}
212	2	}
213
214		/**
215		* Fire a cleared change event to all registered <code>GraphChangeListener</code>s.
216		*/
217		public void fireCleared()
218		{
219	1	Object[] listeners = listenerList.getListenerList();
220	1	GraphChangeEvent<N, E> e = null;
221
222	3	for (int i = listeners.length - 2; i >= 0; i -= 2)
223		{
224	2	if (listeners[i] == GraphChangeListener.class)
225		{
226		// lazily create the event
227	1	if (e == null)
228		{
229	1	e = new GraphChangeEvent<N, E>(source);
230		}
231	1	((GraphChangeListener<N, E>) listeners[i + 1]).cleared(e);
232		}
233		}
234	1	}
235
236		/**
237		* Fire a node created change event to all registered <code>GraphChangeListener</code>s.
238		*
239		* @param node newly created node
240		*/
241		public void fireNodeCreated(final Node<N, E> node)
242		{
243	15	Object[] listeners = listenerList.getListenerList();
244	15	GraphChangeEvent<N, E> e = null;
245
246	21	for (int i = listeners.length - 2; i >= 0; i -= 2)
247		{
248	6	if (listeners[i] == GraphChangeListener.class)
249		{
250		// lazily create the event
251	3	if (e == null)
252		{
253	3	e = new GraphChangeEvent<N, E>(source, node);
254		}
255	3	((GraphChangeListener<N, E>) listeners[i + 1]).nodeCreated(e);
256		}
257		}
258	15	}
259
260		/**
261		* Fire a node removed change event to all registered <code>GraphChangeListener</code>s.
262		*
263		* @param node removed node
264		*/
265		public void fireNodeRemoved(final Node<N, E> node)
266		{
267	1	Object[] listeners = listenerList.getListenerList();
268	1	GraphChangeEvent<N, E> e = null;
269
270	3	for (int i = listeners.length - 2; i >= 0; i -= 2)
271		{
272	2	if (listeners[i] == GraphChangeListener.class)
273		{
274		// lazily create the event
275	1	if (e == null)
276		{
277	1	e = new GraphChangeEvent<N, E>(source, node);
278		}
279	1	((GraphChangeListener<N, E>) listeners[i + 1]).nodeRemoved(e);
280		}
281		}
282	1	}
283
284		/**
285		* Fire an edge created change event to all registered <code>GraphChangeListener</code>s.
286		*
287		* @param edge newly created edge
288		*/
289		public void fireEdgeCreated(final Edge<N, E> edge)
290		{
291	3	Object[] listeners = listenerList.getListenerList();
292	3	GraphChangeEvent<N, E> e = null;
293
294	5	for (int i = listeners.length - 2; i >= 0; i -= 2)
295		{
296	2	if (listeners[i] == GraphChangeListener.class)
297		{
298		// lazily create the event
299	1	if (e == null)
300		{
301	1	e = new GraphChangeEvent<N, E>(source, edge);
302		}
303	1	((GraphChangeListener<N, E>) listeners[i + 1]).edgeCreated(e);
304		}
305		}
306	3	}
307
308		/**
309		* Fire an edge removed change event to all registered <code>GraphChangeListener</code>s.
310		*
311		* @param edge removed edge
312		*/
313		public void fireEdgeRemoved(final Edge<N, E> edge)
314		{
315	1	Object[] listeners = listenerList.getListenerList();
316	1	GraphChangeEvent<N, E> e = null;
317
318	3	for (int i = listeners.length - 2; i >= 0; i -= 2)
319		{
320	2	if (listeners[i] == GraphChangeListener.class)
321		{
322		// lazily create the event
323	1	if (e == null)
324		{
325	1	e = new GraphChangeEvent<N, E>(source, edge);
326		}
327	1	((GraphChangeListener<N, E>) listeners[i + 1]).edgeRemoved(e);
328		}
329		}
330	1	}
331
332		/**
333		* Fire a will create node create event to all registered
334		* <code>VetoableGraphChangeListener</code>s.
335		*
336		* @param nodeValue node value for an about to be created node
337		* @throws GraphChangeVetoException if any of the listeners veto the change
338		*/
339		public void fireWillCreateNode(final N nodeValue)
340		throws GraphChangeVetoException
341		{
342	23	Object[] listeners = listenerList.getListenerList();
343	23	VetoableGraphChangeEvent<N, E> e = null;
344
345	33	for (int i = listeners.length - 2; i >= 0; i -= 2)
346		{
347	16	if (listeners[i] == VetoableGraphChangeListener.class)
348		{
349		// lazily create the event
350	11	if (e == null)
351		{
352	11	e = new VetoableGraphChangeEvent<N, E>(source, nodeValue);
353		}
354	11	((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willCreateNode(e);
355		}
356		}
357	17	}
358
359		/**
360		* Fire a will create edge change event to all registered
361		* <code>VetoableGraphChangeListener</code>s.
362		*
363		* @param sourceNode source node for an about to be created edge
364		* @param targetNode target node for an about to be created edge
365		* @param edgeValue edge value for an about to be created edge
366		* @throws GraphChangeVetoException if any of the listeners veto the change
367		*/
368		public void fireWillCreateEdge(final Node<N, E> sourceNode,
369		final Node<N, E> targetNode,
370		final E edgeValue)
371		throws GraphChangeVetoException
372		{
373	5	Object[] listeners = listenerList.getListenerList();
374	5	VetoableGraphChangeEvent<N, E> e = null;
375
376	7	for (int i = listeners.length - 2; i >= 0; i -= 2)
377		{
378	4	if (listeners[i] == VetoableGraphChangeListener.class)
379		{
380		// lazily create the event
381	3	if (e == null)
382		{
383	3	e = new VetoableGraphChangeEvent<N, E>(source, sourceNode, targetNode, edgeValue);
384		}
385	3	((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willCreateEdge(e);
386		}
387		}
388	3	}
389
390		/**
391		* Fire a will remove node change event to all registered
392		* <code>VetoableGraphChangeListener</code>s.
393		*
394		* @param node node about to be removed
395		* @throws GraphChangeVetoException if any of the listeners veto the change
396		*/
397		public void fireWillRemoveNode(final Node<N, E> node)
398		throws GraphChangeVetoException
399		{
400	4	Object[] listeners = listenerList.getListenerList();
401	4	VetoableGraphChangeEvent<N, E> e = null;
402
403	8	for (int i = listeners.length - 2; i >= 0; i -= 2)
404		{
405	6	if (listeners[i] == VetoableGraphChangeListener.class)
406		{
407		// lazily create the event
408	4	if (e == null)
409		{
410	4	e = new VetoableGraphChangeEvent<N, E>(source, node);
411		}
412	4	((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willRemoveNode(e);
413		}
414		}
415	2	}
416
417		/**
418		* Fire a will remove edge change event to all registered
419		* <code>VetoableGraphChangeListener</code>s.
420		*
421		* @param edge edge about to be removed
422		* @throws GraphChangeVetoException if any of the listeners veto the change
423		*/
424		public void fireWillRemoveEdge(final Edge<N, E> edge)
425		throws GraphChangeVetoException
426		{
427	4	Object[] listeners = listenerList.getListenerList();
428	4	VetoableGraphChangeEvent<N, E> e = null;
429
430	8	for (int i = listeners.length - 2; i >= 0; i -= 2)
431		{
432	6	if (listeners[i] == VetoableGraphChangeListener.class)
433		{
434		// lazily create the event
435	4	if (e == null)
436		{
437	4	e = new VetoableGraphChangeEvent<N, E>(source, edge);
438		}
439	4	((VetoableGraphChangeListener<N, E>) listeners[i + 1]).willRemoveEdge(e);
440		}
441		}
442	2	}
443		}