You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jspwiki.apache.org by ju...@apache.org on 2020/01/28 20:34:29 UTC
[jspwiki] 28/32: apply formatting and fixes suggested by intellij
This is an automated email from the ASF dual-hosted git repository.
juanpablo pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/jspwiki.git
commit 2642c4bb55e557b8e4d828560c625722f60cc83c
Author: juanpablo <ju...@apache.org>
AuthorDate: Mon Jan 27 23:43:41 2020 +0100
apply formatting and fixes suggested by intellij
---
.../org/apache/wiki/event/WikiEventManager.java | 483 ++++++++-------------
1 file changed, 171 insertions(+), 312 deletions(-)
diff --git a/jspwiki-main/src/main/java/org/apache/wiki/event/WikiEventManager.java b/jspwiki-main/src/main/java/org/apache/wiki/event/WikiEventManager.java
index 555f405..9709004 100644
--- a/jspwiki-main/src/main/java/org/apache/wiki/event/WikiEventManager.java
+++ b/jspwiki-main/src/main/java/org/apache/wiki/event/WikiEventManager.java
@@ -19,6 +19,8 @@
package org.apache.wiki.event;
+import org.apache.log4j.Logger;
+
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
@@ -31,31 +33,21 @@ import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;
-import org.apache.log4j.Logger;
-
/**
- * A singleton class that manages the addition and removal of WikiEvent
- * listeners to a event source, as well as the firing of events to those
- * listeners. An "event source" is the object delegating its event
- * handling to an inner delegating class supplied by this manager. The
- * class being serviced is considered a "client" of the delegate. The
- * WikiEventManager operates across any number of simultaneously-existing
- * WikiEngines since it manages all delegation on a per-object basis.
- * Anything that might fire a WikiEvent (or any of its subclasses) can be
- * a client.
+ * A singleton class that manages the addition and removal of WikiEvent listeners to a event source, as well as the firing of events
+ * to those listeners. An "event source" is the object delegating its event handling to an inner delegating class supplied by this
+ * manager. The class being serviced is considered a "client" of the delegate. The WikiEventManager operates across any number of
+ * simultaneously-existing WikiEngines since it manages all delegation on a per-object basis. Anything that might fire a WikiEvent
+ * (or any of its subclasses) can be a client.
* </p>
*
* <h3>Using a Delegate for Event Listener Management</h3>
* <p>
- * Basically, rather than have all manner of client classes maintain their
- * own listener lists, add and remove listener methods, any class wanting
- * to attach listeners can simply request a delegate object to provide that
- * service. The delegate handles the listener list, the add and remove
- * listener methods. Firing events is then a matter of calling the
- * WikiEventManager's {@link #fireEvent(Object,WikiEvent)} method, where
- * the Object is the client. Prior to instantiating the event object, the
- * client can call {@link #isListening(Object)} to see there are any
- * listeners attached to its delegate.
+ * Basically, rather than have all manner of client classes maintain their own listener lists, add and remove listener methods, any
+ * class wanting to attach listeners can simply request a delegate object to provide that service. The delegate handles the listener
+ * list, the add and remove listener methods. Firing events is then a matter of calling the WikiEventManager's
+ * {@link #fireEvent(Object,WikiEvent)} method, where the Object is the client. Prior to instantiating the event object, the
+ * client can call {@link #isListening(Object)} to see there are any listeners attached to its delegate.
* </p>
*
* <h3>Adding Listeners</h3>
@@ -63,7 +55,7 @@ import org.apache.log4j.Logger;
* Adding a WikiEventListener to an object is very simple:
* </p>
* <pre>
- * WikiEventManager.addWikiEventListener(object,listener);
+ * WikiEventManager.addWikiEventListener( object, listener );
* </pre>
*
* <h3>Removing Listeners</h3>
@@ -71,86 +63,66 @@ import org.apache.log4j.Logger;
* Removing a WikiEventListener from an object is very simple:
* </p>
* <pre>
- * WikiEventManager.removeWikiEventListener(object,listener);
+ * WikiEventManager.removeWikiEventListener( object, listener );
* </pre>
- * If you only have a reference to the listener, the following method
- * will remove it from any clients managed by the WikiEventManager:
+ * If you only have a reference to the listener, the following method will remove it from any clients managed by the WikiEventManager:
* <pre>
- * WikiEventManager.removeWikiEventListener(listener);
+ * WikiEventManager.removeWikiEventListener( listener );
* </pre>
*
* <h3>Backward Compatibility: Replacing Existing <tt>fireEvent()</tt> Methods</h3>
* <p>
- * Using one manager for all events processing permits consolidation of all event
- * listeners and their associated methods in one place rather than having them
- * attached to specific subcomponents of an application, and avoids a great deal
- * of event-related cut-and-paste code. Convenience methods that call the
- * WikiEventManager for event delegation can be written to maintain existing APIs.
+ * Using one manager for all events processing permits consolidation of all event listeners and their associated methods in one place
+ * rather than having them attached to specific subcomponents of an application, and avoids a great deal of event-related cut-and-paste
+ * code. Convenience methods that call the WikiEventManager for event delegation can be written to maintain existing APIs.
* </p>
* <p>
- * For example, an existing <tt>fireEvent()</tt> method might look something like
- * this:
+ * For example, an existing <tt>fireEvent()</tt> method might look something like this:
* </p>
* <pre>
- * protected final void fireEvent( WikiEvent event )
- * {
- * for ( Iterator it = m_listeners.iterator(); it.hasNext(); )
- * {
- * WikiEventListener listener = (WikiEventListener)it.next();
- * listener.actionPerformed(event);
+ * protected final void fireEvent( WikiEvent event ) {
+ * for( WikiEventListener listener : m_listeners ) {
+ * listener.actionPerformed( event );
* }
* }
* </pre>
* <p>
- * One disadvantage is that the above method is supplied with event objects,
- * which are created even when no listener exists for them. In a busy wiki
- * with many users unused/unnecessary event creation could be considerable.
- * Another advantage is that in addition to the iterator, there must be code
- * to support the addition and remove of listeners. The above could be
- * replaced with the below code (and with no necessary local support for
- * adding and removing listeners):
+ * One disadvantage is that the above method is supplied with event objects, which are created even when no listener exists for them.
+ * In a busy wiki with many users unused/unnecessary event creation could be considerable. Another advantage is that in addition to
+ * the iterator, there must be code to support the addition and remove of listeners. The above could be replaced with the below code
+ * (and with no necessary local support for adding and removing listeners):
* </p>
* <pre>
- * protected final void fireEvent( int type )
- * {
- * if ( WikiEventManager.isListening(this) )
- * {
- * WikiEventManager.fireEvent(this,new WikiEngineEvent(this,type));
+ * protected final void fireEvent( int type ) {
+ * if( WikiEventManager.isListening( this ) ) {
+ * WikiEventManager.fireEvent( this, new WikiEngineEvent( this, type ) );
* }
* }
* </pre>
* <p>
- * This only needs to be customized to supply the specific parameters for
- * whatever WikiEvent you want to create.
+ * This only needs to be customized to supply the specific parameters for whatever WikiEvent you want to create.
* </p>
*
* <h3 id="preloading">Preloading Listeners</h3>
* <p>
- * This may be used to create listeners for objects that don't yet exist,
- * particularly designed for embedded applications that need to be able
- * to listen for the instantiation of an Object, by maintaining a cache
- * of client-less WikiEvent sources that set their client upon being
- * popped from the cache. Each time any of the methods expecting a client
- * parameter is called with a null parameter it will preload an internal
- * cache with a client-less delegate object that will be popped and
- * returned in preference to creating a new object. This can have unwanted
- * side effects if there are multiple clients populating the cache with
- * listeners. The only check is for a Class match, so be aware if others
- * might be populating the client-less cache with listeners.
+ * This may be used to create listeners for objects that don't yet exist, particularly designed for embedded applications that need
+ * to be able to listen for the instantiation of an Object, by maintaining a cache of client-less WikiEvent sources that set their
+ * client upon being popped from the cache. Each time any of the methods expecting a client parameter is called with a null parameter
+ * it will preload an internal cache with a client-less delegate object that will be popped and returned in preference to creating a
+ * new object. This can have unwanted side effects if there are multiple clients populating the cache with listeners. The only check
+ * is for a Class match, so be aware if others might be populating the client-less cache with listeners.
* </p>
* <h3>Listener lifecycle</h3>
* <p>
- * Note that in most cases it is not necessary to remove a listener.
- * As of 2.4.97, the listeners are stored as WeakReferences, and will be
- * automatically cleaned at the next garbage collection, if you no longer
- * hold a reference to them. Of course, until the garbage is collected,
- * your object might still be getting events, so if you wish to avoid that,
- * please remove it explicitly as described above.
+ * Note that in most cases it is not necessary to remove a listener. As of 2.4.97, the listeners are stored as WeakReferences, and
+ * will be automatically cleaned at the next garbage collection, if you no longer hold a reference to them. Of course, until the
+ * garbage is collected, your object might still be getting events, so if you wish to avoid that, please remove it explicitly as
+ * described above.
* </p>
* @since 2.4.20
*/
-public final class WikiEventManager
-{
+public final class WikiEventManager {
+
private static final Logger log = Logger.getLogger(WikiEventManager.class);
/* If true, permits a WikiEventMonitor to be set. */
@@ -160,163 +132,124 @@ public final class WikiEventManager
private static WikiEventListener c_monitor = null;
/* The Map of client object to WikiEventDelegate. */
- private final Map<Object, WikiEventDelegate> m_delegates = new HashMap<>();
+ private final Map< Object, WikiEventDelegate > m_delegates = new HashMap<>();
/* The Vector containing any preloaded WikiEventDelegates. */
- private final Vector<WikiEventDelegate> m_preloadCache = new Vector<>();
+ private final Vector< WikiEventDelegate > m_preloadCache = new Vector<>();
/* Singleton instance of the WikiEventManager. */
private static WikiEventManager c_instance = null;
- // ............
-
- /**
- * Constructor for a WikiEventManager.
- */
- private WikiEventManager()
- {
+ /** Constructor for a WikiEventManager. */
+ private WikiEventManager() {
c_instance = this;
- log.debug("instantiated WikiEventManager");
+ log.debug( "instantiated WikiEventManager" );
}
/**
- * As this is a singleton class, this returns the single
- * instance of this class provided with the property file
+ * As this is a singleton class, this returns the single instance of this class provided with the property file
* filename and bit-wise application settings.
*
* @return A shared instance of the WikiEventManager
*/
- public static WikiEventManager getInstance()
- {
- if( c_instance == null )
- {
- synchronized( WikiEventManager.class )
- {
- WikiEventManager mgr = new WikiEventManager();
+ public static WikiEventManager getInstance() {
+ if( c_instance == null ) {
+ synchronized( WikiEventManager.class ) {
+ return new WikiEventManager();
// start up any post-instantiation services here
- return mgr;
}
}
return c_instance;
}
-
// public/API methods ......................................................
-
/**
- * Registers a WikiEventListener with a WikiEventDelegate for
- * the provided client object.
+ * Registers a WikiEventListener with a WikiEventDelegate for the provided client object.
*
* <h3>Monitor Listener</h3>
*
- * If <tt>client</tt> is a reference to the WikiEventManager class
- * itself and the compile-time flag {@link #c_permitMonitor} is true,
- * this attaches the listener as an all-event monitor, overwriting
- * any previous listener (hence returning true).
+ * If <tt>client</tt> is a reference to the WikiEventManager class itself and the compile-time flag {@link #c_permitMonitor} is true,
+ * this attaches the listener as an all-event monitor, overwriting any previous listener (hence returning true).
* <p>
- * You can remove any existing monitor by either calling this method
- * with <tt>client</tt> as a reference to this class and the
- * <tt>listener</tt> parameter as null, or
- * {@link #removeWikiEventListener(Object,WikiEventListener)} with a
- * <tt>client</tt> as a reference to this class. The <tt>listener</tt>
- * parameter in this case is ignored.
+ * You can remove any existing monitor by either calling this method with <tt>client</tt> as a reference to this class and the
+ * <tt>listener</tt> parameter as null, or {@link #removeWikiEventListener(Object,WikiEventListener)} with a <tt>client</tt>
+ * as a reference to this class. The <tt>listener</tt> parameter in this case is ignored.
*
* @param client the client of the event source
* @param listener the event listener
* @return true if the listener was added (i.e., it was not already in the list and was added)
*/
- public static boolean addWikiEventListener(
- Object client, WikiEventListener listener )
- {
- if ( client == WikiEventManager.class )
- {
- if ( c_permitMonitor ) c_monitor = listener;
+ public static boolean addWikiEventListener( final Object client, final WikiEventListener listener ) {
+ if( client == WikiEventManager.class ) {
+ if ( c_permitMonitor ) {
+ c_monitor = listener;
+ }
return c_permitMonitor;
}
- WikiEventDelegate delegate = getInstance().getDelegateFor(client);
+ final WikiEventDelegate delegate = getInstance().getDelegateFor(client);
return delegate.addWikiEventListener(listener);
}
-
/**
- * Un-registers a WikiEventListener with the WikiEventDelegate for
- * the provided client object.
+ * Un-registers a WikiEventListener with the WikiEventDelegate for the provided client object.
*
* @param client the client of the event source
* @param listener the event listener
* @return true if the listener was found and removed.
*/
- public static boolean removeWikiEventListener(
- Object client, WikiEventListener listener )
- {
- if ( client == WikiEventManager.class )
- {
+ public static boolean removeWikiEventListener( final Object client, final WikiEventListener listener ) {
+ if ( client == WikiEventManager.class ) {
c_monitor = null;
return true;
}
- WikiEventDelegate delegate = getInstance().getDelegateFor(client);
+ final WikiEventDelegate delegate = getInstance().getDelegateFor(client);
return delegate.removeWikiEventListener(listener);
}
-
/**
- * Return the Set containing the WikiEventListeners attached to the
- * delegate for the supplied client. If there are no attached listeners,
- * returns an empty Iterator rather than null. Note that this will
- * create a delegate for the client if it did not exist prior to the call.
+ * Return the Set containing the WikiEventListeners attached to the delegate for the supplied client. If there are no
+ * attached listeners, returns an empty Iterator rather than null. Note that this will create a delegate for the client
+ * if it did not exist prior to the call.
*
* <h3>NOTE</h3>
* <p>
- * This method returns a Set rather than an Iterator because of the high
- * likelihood of the Set being modified while an Iterator might be active.
- * This returns an unmodifiable reference to the actual Set containing
- * the delegate's listeners. Any attempt to modify the Set will throw an
- * {@link java.lang.UnsupportedOperationException}. This method is not
- * synchronized and it should be understood that the composition of the
- * backing Set may change at any time.
+ * This method returns a Set rather than an Iterator because of the high likelihood of the Set being modified while an
+ * Iterator might be active. This returns an unmodifiable reference to the actual Set containing the delegate's listeners.
+ * Any attempt to modify the Set will throw an {@link java.lang.UnsupportedOperationException}. This method is not
+ * synchronized and it should be understood that the composition of the backing Set may change at any time.
* </p>
*
* @param client the client of the event source
* @return an unmodifiable Set containing the WikiEventListeners attached to the client
* @throws java.lang.UnsupportedOperationException if any attempt is made to modify the Set
*/
- public static Set<WikiEventListener> getWikiEventListeners( Object client )
- throws UnsupportedOperationException
- {
- WikiEventDelegate delegate = getInstance().getDelegateFor(client);
+ public static Set<WikiEventListener> getWikiEventListeners( final Object client ) throws UnsupportedOperationException {
+ final WikiEventDelegate delegate = getInstance().getDelegateFor(client);
return delegate.getWikiEventListeners();
}
-
/**
- * Un-registers a WikiEventListener from any WikiEventDelegate client managed by this
- * WikiEventManager. Since this is a one-to-one relation, the first match will be
- * returned upon removal; a true return value indicates the WikiEventListener was
- * found and removed.
+ * Un-registers a WikiEventListener from any WikiEventDelegate client managed by this WikiEventManager. Since this is a one-to-one
+ * relation, the first match will be returned upon removal; a true return value indicates the WikiEventListener was found and removed.
*
* @param listener the event listener
* @return true if the listener was found and removed.
*/
- public static boolean removeWikiEventListener( WikiEventListener listener )
- {
+ public static boolean removeWikiEventListener( final WikiEventListener listener ) {
// get the Map.entry object for the entire Map, then check match on entry (listener)
- WikiEventManager mgr = getInstance();
- Map< Object, WikiEventDelegate > sources = mgr.getDelegates();
- synchronized( sources )
- {
+ final WikiEventManager mgr = getInstance();
+ final Map< Object, WikiEventDelegate > sources = mgr.getDelegates();
+ synchronized( sources ) {
// get an iterator over the Map.Enty objects in the map
- Iterator< Map.Entry< Object, WikiEventDelegate > > it = sources.entrySet().iterator();
- while( it.hasNext() )
- {
- Map.Entry< Object, WikiEventDelegate > entry = it.next();
+ final Iterator< Map.Entry< Object, WikiEventDelegate > > it = sources.entrySet().iterator();
+ while( it.hasNext() ) {
+ final Map.Entry< Object, WikiEventDelegate > entry = it.next();
// the entry value is the delegate
- WikiEventDelegate delegate = (WikiEventDelegate)entry.getValue();
+ final WikiEventDelegate delegate = entry.getValue();
- // now see if we can remove the listener from the delegate
- // (delegate may be null because this is a weak reference)
- if( delegate != null && delegate.removeWikiEventListener(listener) )
- {
+ // now see if we can remove the listener from the delegate (delegate may be null because this is a weak reference)
+ if( delegate != null && delegate.removeWikiEventListener(listener) ) {
return true; // was removed
}
}
@@ -324,87 +257,65 @@ public final class WikiEventManager
return false;
}
-
/**
- * Returns true if there are one or more listeners registered with
- * the provided client Object (undelegated event source). This locates
+ * Returns true if there are one or more listeners registered with the provided client Object (undelegated event source). This locates
* any delegate and checks to see if it has any listeners attached.
*
* @param client the client Object
* @return True, if there is a listener for this client object.
*/
- public static boolean isListening( Object client )
- {
- WikiEventDelegate source = getInstance().getDelegateFor(client);
- return source != null ? source.isListening() : false ;
+ public static boolean isListening( final Object client ) {
+ return getInstance().getDelegateFor( client ).isListening();
}
-
/**
- * Notify all listeners of the WikiEventDelegate having a registered
- * interest in change events of the supplied WikiEvent.
+ * Notify all listeners of the WikiEventDelegate having a registered interest in change events of the supplied WikiEvent.
*
* @param client the client initiating the event.
* @param event the WikiEvent to fire.
*/
- public static void fireEvent( Object client, WikiEvent event )
- {
- WikiEventDelegate source = getInstance().getDelegateFor(client);
- if ( source != null ) source.fireEvent(event);
- if ( c_monitor != null ) c_monitor.actionPerformed(event);
+ public static void fireEvent( final Object client, final WikiEvent event ) {
+ final WikiEventDelegate source = getInstance().getDelegateFor( client );
+ source.fireEvent( event );
+ if( c_monitor != null ) {
+ c_monitor.actionPerformed( event );
+ }
}
-
// private and utility methods .............................................
-
/**
* Return the client-to-delegate Map.
*/
- private Map< Object, WikiEventDelegate > getDelegates()
- {
+ private Map< Object, WikiEventDelegate > getDelegates() {
return m_delegates;
}
-
/**
- * Returns a WikiEventDelegate for the provided client Object.
- * If the parameter is a class reference, will generate and return a
- * client-less WikiEventDelegate. If the parameter is not a Class and
- * the delegate cache contains any objects matching the Class of any
- * delegates in the cache, the first Class-matching delegate will be
- * used in preference to creating a new delegate.
- * If a null parameter is supplied, this will create a client-less
- * delegate that will attach to the first incoming client (i.e.,
+ * Returns a WikiEventDelegate for the provided client Object. If the parameter is a class reference, will generate and return a
+ * client-less WikiEventDelegate. If the parameter is not a Class and the delegate cache contains any objects matching the Class
+ * of any delegates in the cache, the first Class-matching delegate will be used in preference to creating a new delegate.
+ * If a null parameter is supplied, this will create a client-less delegate that will attach to the first incoming client (i.e.,
* there will be no Class-matching requirement).
*
* @param client the client Object, or alternately a Class reference
* @return the WikiEventDelegate.
*/
- private WikiEventDelegate getDelegateFor( Object client )
- {
- synchronized( m_delegates )
- {
- if( client == null || client instanceof Class ) // then preload the cache
- {
- WikiEventDelegate delegate = new WikiEventDelegate(client);
- m_preloadCache.add(delegate);
+ private WikiEventDelegate getDelegateFor( final Object client ) {
+ synchronized( m_delegates ) {
+ if( client == null || client instanceof Class ) { // then preload the cache
+ final WikiEventDelegate delegate = new WikiEventDelegate( client );
+ m_preloadCache.add( delegate );
m_delegates.put( client, delegate );
return delegate;
- }
- else if( !m_preloadCache.isEmpty() )
- {
+ } else if( !m_preloadCache.isEmpty() ) {
// then see if any of the cached delegates match the class of the incoming client
- for( int i = m_preloadCache.size()-1 ; i >= 0 ; i-- ) // start with most-recently added
- {
- WikiEventDelegate delegate = m_preloadCache.elementAt(i);
- if( delegate.getClientClass() == null
- || delegate.getClientClass().equals(client.getClass()) )
- {
+ for( int i = m_preloadCache.size()-1 ; i >= 0 ; i-- ) { // start with most-recently added
+ final WikiEventDelegate delegate = m_preloadCache.elementAt( i );
+ if( delegate.getClientClass() == null || delegate.getClientClass().equals( client.getClass() ) ) {
// we have a hit, so use it, but only on a client we haven't seen before
- if( !m_delegates.keySet().contains(client) )
- {
- m_preloadCache.remove(delegate);
+ if( !m_delegates.containsKey( client ) ) {
+ m_preloadCache.remove( delegate );
m_delegates.put( client, delegate );
return delegate;
}
@@ -413,8 +324,7 @@ public final class WikiEventManager
}
// otherwise treat normally...
WikiEventDelegate delegate = m_delegates.get( client );
- if( delegate == null )
- {
+ if( delegate == null ) {
delegate = new WikiEventDelegate( client );
m_delegates.put( client, delegate );
}
@@ -425,108 +335,80 @@ public final class WikiEventManager
// .........................................................................
-
/**
- * Inner delegating class that manages event listener addition and
- * removal. Classes that generate events can obtain an instance of
- * this class from the WikiEventManager and delegate responsibility
- * to it. Interaction with this delegating class is done via the
+ * Inner delegating class that manages event listener addition and removal. Classes that generate events can obtain an instance of
+ * this class from the WikiEventManager and delegate responsibility to it. Interaction with this delegating class is done via the
* methods of the {@link WikiEventDelegate} API.
*
* @since 2.4.20
*/
- private static final class WikiEventDelegate
- {
- /* A list of event listeners for this instance. */
-
- private ArrayList<WeakReference<WikiEventListener>> m_listenerList = new ArrayList<>();
+ private static final class WikiEventDelegate {
+ /* A list of event listeners for this instance. */
+ private final ArrayList< WeakReference< WikiEventListener > > m_listenerList = new ArrayList<>();
private Class< ? > m_class = null;
/**
- * Constructor for an WikiEventDelegateImpl, provided
- * with the client Object it will service, or the Class
- * of client, the latter when used to preload a future
- * incoming delegate.
+ * Constructor for an WikiEventDelegateImpl, provided with the client Object it will service, or the Class
+ * of client, the latter when used to preload a future incoming delegate.
*/
- protected WikiEventDelegate( Object client )
- {
- if( client instanceof Class )
- {
- m_class = (Class< ? >)client;
+ protected WikiEventDelegate( final Object client ) {
+ if( client instanceof Class ) {
+ m_class = ( Class< ? > )client;
}
}
/**
- * Returns the class of the client-less delegate, null if
- * this delegate is attached to a client Object.
+ * Returns the class of the client-less delegate, null if this delegate is attached to a client Object.
*/
- protected Class< ? > getClientClass()
- {
+ protected Class< ? > getClientClass() {
return m_class;
}
-
/**
- * Return an unmodifiable Set containing the WikiEventListeners of
- * this WikiEventDelegateImpl. If there are no attached listeners,
+ * Return an unmodifiable Set containing the WikiEventListeners of this WikiEventDelegateImpl. If there are no attached listeners,
* returns an empty Set rather than null.
*
* @return an unmodifiable Set containing this delegate's WikiEventListeners
* @throws java.lang.UnsupportedOperationException if any attempt is made to modify the Set
*/
- public Set<WikiEventListener> getWikiEventListeners()
- {
- synchronized( m_listenerList )
- {
- TreeSet<WikiEventListener> set = new TreeSet<>( new WikiEventListenerComparator() );
-
- for( Iterator< WeakReference< WikiEventListener > > i = m_listenerList.iterator(); i.hasNext(); )
- {
- WikiEventListener l = i.next().get();
-
- if( l != null )
- {
+ public Set< WikiEventListener > getWikiEventListeners() {
+ synchronized( m_listenerList ) {
+ final TreeSet< WikiEventListener > set = new TreeSet<>( new WikiEventListenerComparator() );
+ for( final Iterator< WeakReference< WikiEventListener > > i = m_listenerList.iterator(); i.hasNext(); ) {
+ final WikiEventListener l = i.next().get();
+ if( l != null ) {
set.add( l );
}
}
- return Collections.unmodifiableSet(set);
+ return Collections.unmodifiableSet( set );
}
}
-
/**
* Adds <tt>listener</tt> as a listener for events fired by the WikiEventDelegate.
*
* @param listener the WikiEventListener to be added
* @return true if the listener was added (i.e., it was not already in the list and was added)
*/
- public boolean addWikiEventListener( WikiEventListener listener )
- {
- synchronized( m_listenerList )
- {
+ public boolean addWikiEventListener( final WikiEventListener listener ) {
+ synchronized( m_listenerList ) {
return m_listenerList.add( new WeakReference<>(listener) );
}
}
-
/**
* Removes <tt>listener</tt> from the WikiEventDelegate.
*
* @param listener the WikiEventListener to be removed
* @return true if the listener was removed (i.e., it was actually in the list and was removed)
*/
- public boolean removeWikiEventListener( WikiEventListener listener )
- {
- synchronized( m_listenerList )
- {
- for( Iterator< WeakReference< WikiEventListener > > i = m_listenerList.iterator(); i.hasNext(); )
- {
- WikiEventListener l = i.next().get();
-
- if( l == listener )
- {
+ public boolean removeWikiEventListener( final WikiEventListener listener ) {
+ synchronized( m_listenerList ) {
+ for( final Iterator< WeakReference< WikiEventListener > > i = m_listenerList.iterator(); i.hasNext(); ) {
+ final WikiEventListener l = i.next().get();
+ if( l == listener ) {
i.remove();
return true;
}
@@ -536,82 +418,59 @@ public final class WikiEventManager
return false;
}
-
/**
- * Returns true if there are one or more listeners registered
- * with this instance.
+ * Returns true if there are one or more listeners registered with this instance.
*/
- public boolean isListening()
- {
- synchronized( m_listenerList )
- {
+ public boolean isListening() {
+ synchronized( m_listenerList ) {
return !m_listenerList.isEmpty();
}
}
-
/**
- * Notify all listeners having a registered interest
- * in change events of the supplied WikiEvent.
+ * Notify all listeners having a registered interest in change events of the supplied WikiEvent.
*/
- public void fireEvent( WikiEvent event )
- {
+ public void fireEvent( final WikiEvent event ) {
boolean needsCleanup = false;
-
- try
- {
- synchronized( m_listenerList )
- {
- for( int i = 0; i < m_listenerList.size(); i++ )
- {
- WikiEventListener listener = m_listenerList.get( i ).get();
-
- if( listener != null )
- {
+ try {
+ synchronized( m_listenerList ) {
+ for( int i = 0; i < m_listenerList.size(); i++ ) {
+ final WikiEventListener listener = m_listenerList.get( i ).get();
+ if( listener != null ) {
listener.actionPerformed( event );
- }
- else
- {
+ } else {
needsCleanup = true;
}
}
- //
// Remove all such listeners which have expired
- //
- if( needsCleanup )
- {
- for( int i = 0; i < m_listenerList.size(); i++ )
- {
- WeakReference< WikiEventListener > w = m_listenerList.get( i );
-
- if( w.get() == null ) m_listenerList.remove(i--);
+ if( needsCleanup ) {
+ for( int i = 0; i < m_listenerList.size(); i++ ) {
+ final WeakReference< WikiEventListener > w = m_listenerList.get( i );
+ if( w.get() == null ) {
+ m_listenerList.remove(i--);
+ }
}
}
}
- }
- catch( ConcurrentModificationException e )
- {
- //
+ } catch( final ConcurrentModificationException e ) {
// We don't die, we just don't do notifications in that case.
- //
- log.info("Concurrent modification of event list; please report this.",e);
+ log.info( "Concurrent modification of event list; please report this.", e );
}
-
}
+ }
- } // end inner class WikiEventDelegate
-
- private static class WikiEventListenerComparator implements Comparator<WikiEventListener>
- {
+ private static class WikiEventListenerComparator implements Comparator< WikiEventListener > {
// TODO: This method is a critical performance bottleneck
@Override
- public int compare(WikiEventListener w0, WikiEventListener w1)
- {
- if( w1 == w0 || w0.equals(w1) ) return 0;
+ public int compare( final WikiEventListener w0, final WikiEventListener w1 ) {
+ if( w1 == w0 || w0.equals( w1 ) ) {
+ return 0;
+ }
return w1.hashCode() - w0.hashCode();
}
}
-} // end org.apache.wiki.event.WikiEventManager
+
+}