View Javadoc
   /*
    * Dispatcher.java
    * Created on August 23, 2003
    *
    * The Blues Framework - A lightweight application framework
    * Copyright (C) 2003  Lonnie Pryor
    * http://blues.lonniepryor.com
    *
    * 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 2.1 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; without 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
   *
   */
  package com.lonniepryor.blues.sys;
  
  import java.lang.reflect.Member;
  import java.lang.reflect.Method;
  
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  
  import com.lonniepryor.blues.Lifecycle;
  import com.lonniepryor.blues.util.Methods;
  import com.lonniepryor.blues.util.Types;
  
  import net.sf.cglib.Enhancer;
  import net.sf.cglib.MethodFilter;
  import net.sf.cglib.MethodInterceptor;
  import net.sf.cglib.MethodProxy;
  
  /***
   * Models the abstract view of a Blues event dispatcher.
   *
   * @author Lonnie Pryor
   * @version $Revision: 1.1 $
   */
  public final class Dispatcher {
    /***
     * A specification satisfied by interfaces that have only void methods, with the
     * exception of {@link com.lonniepryor.blues.Lifecycle} and the interfaces in
     * {@link com.lonniepryor.blues.aop}.
     */
    private static final Types validObserverTypes = Types.interfaces()
                                                         .and(
        Types.equalTo(Lifecycle.class).or(Types.named("com.lonniepryor.blues.aop.*"))
             .not()).and(Types.withAllMethods(Methods.returningVoid()));
    /*** The observer interface that target components implement. */
    private final Class observerType;
    /*** The target observer instances. */
    private final List targetInstances = new LinkedList();
    /*** The instance of the dispatcher object. */
    private Object instance = null;
  
    /***
     * Creates a new Dispatcher object.
     *
     * @param observerInterface The observer interface that target components
     *        implement.
     */
    Dispatcher (Class observerInterface) {
      if (!validObserverTypes.isSatisfiedBy(observerInterface))
        throw new SystemException(
          "Invalid observer interface " + observerInterface.getName());
      this.observerType = observerInterface;
    }
  
    /***
     * Determines all of the valid observer interfaces implemented by the supplied
     * component.
     *
     * @param comp The component to inspect.
     *
     * @return All of the valid observer interfaces implemented by the supplied
     *         component.
     */
    static Class[] observerInterfacesFor (Component comp) {
      Set observerTypes = indexOberverTypes(
          comp.getComponentInstance().getClass(), new HashSet());
      return (Class[])observerTypes.toArray(new Class[observerTypes.size()]);
    }
  
    /***
     * Recusivly determines all of the valid observer interfaces implemented by the
    * supplied class.
    *
    * @param onClass The class to inspect.
    * @param toSet The set to add valid observer interfaces to.
    *
    * @return The supplied set.
    */
   private static Set indexOberverTypes (Class onClass, Set toSet) {
     if (validObserverTypes.isSatisfiedBy(onClass))
       if (!toSet.add(onClass))
         return toSet;
     Class[] interfaces = onClass.getInterfaces();
     for (int i = 0; i < interfaces.length; ++i)
       indexOberverTypes(interfaces[i], toSet);
     if (onClass.getSuperclass() != null)
       indexOberverTypes(onClass.getSuperclass(), toSet);
     return toSet;
   }
 
   /***
    * Adds the target component to this dispatcher.
    *
    * @param target The component to add.
    */
   void addTarget (Component target) {
     if (!observerType.isAssignableFrom(target.getComponentInstance().getClass()))
       throw new SystemException(
         "Invalid Component type "
         + target.getComponentInstance().getClass().getName()
         + " for Dispatcher type " + observerType.getName());
     targetInstances.add(target.getComponentInstance());
   }
 
   /***
    * Creates an instance of the observer interface that dispatches to all
    * registered components.
    *
    * @param classLoader The classLoader to define classes on.
    */
   void createInstance (ClassLoader classLoader) {
     final Set observerMethods = Collections.unmodifiableSet(
         new HashSet(Arrays.asList(observerType.getMethods())));
     try {
       instance = Enhancer.enhance(
           Object.class, new Class[] { observerType },
           new DispatcherMethodInterceptor(targetInstances.toArray()), classLoader,
           null,
           new MethodFilter() {
             public boolean accept (Member member) {
               return observerMethods.contains(member);
             }
           });
     } catch (RuntimeException re) {
       throw new SystemException(
         "Error creating Dispatcher for type " + observerType.getName(), re);
     }
   }
 
   /***
    * Registers the dispatcher instance with the supplied registry.
    *
    * @param reg The registry to register with.
    */
   void registerWith (Registry reg) {
     reg.registerDispatcher(observerType, instance);
   }
 }
 
 
 /***
  * CGLib method interceptor for dispatcher instances.
  *
  * @author Lonnie Pryor
  * @version $Revision: 1.1 $
  */
 final class DispatcherMethodInterceptor implements MethodInterceptor {
   /*** The targets registered to recieve events from this dispatcher. */
   private final Object[] targets;
 
   /***
    * Creates a new DispatcherMethodInterceptor object.
    *
    * @param targets The targets to dispatch events to.
    */
   DispatcherMethodInterceptor (Object[] targets) {
     this.targets = targets;
   }
 
   /* (non-Javadoc)
    * @see net.sf.cglib.MethodInterceptor#intercept(java.lang.Object,
    *   java.lang.reflect.Method, java.lang.Object[], net.sf.cglib.MethodProxy)
    */
   public Object intercept (
     Object target, Method method, Object[] parameters, MethodProxy proxy)
     throws Throwable {
     dispatch(parameters, proxy, 0);
     return null;
   }
 
   /***
    * Recusivly dispatches the specified event to all registered observers.
    *
    * @param parameters The parameters of the invocation.
    * @param proxy The method proxy to use.
    * @param index The index in the list to dispatch to.
    *
    * @throws Throwable If the underlying observer fails.
    */
   private void dispatch (Object[] parameters, MethodProxy proxy, int index)
     throws Throwable {
     if (index >= targets.length)
       return;
     try {
       proxy.invoke(targets[index], parameters);
     } finally {
       dispatch(parameters, proxy, index + 1);
     }
   }
 }