View Javadoc
   /*
    * Engine.java
    * Created on July 19, 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;
  
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  
  import com.lonniepryor.blues.cfg.ApplicationCfg;
  import com.lonniepryor.blues.sys.Application;
  import com.lonniepryor.blues.sys.Registry;
  import com.lonniepryor.blues.xml.XmlParser;
  
  /***
   * Creates, links, and publishes the contents of a single Blues application.
   *
   * @author Lonnie Pryor
   * @version $Revision: 1.1 $
   */
  public final class Engine {
    /*** The singletons registered in this engine's application. */
    private final Map singletons;
    /*** The services registered in this engine's application. */
    private final Map services;
    /*** The dispatchers registered in this engine's application. */
    private final Map dispatchers;
    /*** The instances of Lifecycle registered in this engine's application. */
    private final Lifecycle[] lifecycles;
    /*** True if this engine has been disposed. */
    private boolean disposed = true;
  
    /***
     * Creates a new empty Engine object.
     */
    public Engine () {
      singletons = Collections.EMPTY_MAP;
      services = Collections.EMPTY_MAP;
      dispatchers = Collections.EMPTY_MAP;
      lifecycles = new Lifecycle[] {  };
    }
  
    /***
     * Creates a new Engine object.
     *
     * @param classLoader The class loader to load the application on.
     * @param configPath The path to a XML application config file.
     */
    public Engine (ClassLoader classLoader, String configPath) {
      this(classLoader, new XmlParser(classLoader).parseApplication(configPath));
    }
  
    /***
     * Creates a new Engine object.
     *
     * @param classLoader The class loader to load the application on.
     * @param configuration The application configuration to use.
     */
    public Engine (ClassLoader classLoader, ApplicationCfg configuration) {
      Registry reg = new Application(classLoader, configuration)
        .getAllRegisteredObjects();
      this.singletons = Collections.unmodifiableMap(new HashMap(reg.getSingletons()));
      this.services = Collections.unmodifiableMap(new HashMap(reg.getServices()));
      this.dispatchers = Collections.unmodifiableMap(
          new HashMap(reg.getDispatchers()));
      this.lifecycles = (Lifecycle[])reg.getLifecycles().toArray(
          new Lifecycle[reg.getLifecycles().size()]);
      if (lifecycles.length > 0) {
        Session session = new Session(this);
        try {
          initalize();
        } finally {
          session.dispose();
        }
      }
      disposed = false;
    }
 
   /***
    * Disposes this engine and all of it's contents.
    */
   public void dispose () {
     if (disposed)
       return;
     try {
       if (lifecycles.length > 0) {
         Session session = new Session(this);
         try {
           dispose(lifecycles.length);
         } finally {
           session.dispose();
         }
       }
     } finally {
       disposed = true;
     }
   }
 
   /***
    * Returns the requested singleton instance or null if one is not found.
    *
    * @param singletonType The type of the singleton to return.
    *
    * @return The requested singleton instance or null if one is not found.
    */
   Object getSingletonInstance (Class singletonType) {
     return disposed ? null : singletons.get(singletonType);
   }
 
   /***
    * Returns the requested service instance or null if one is not found.
    *
    * @param serviceName The name of the service to return.
    *
    * @return The requested service instance or null if one is not found.
    */
   Object getServiceInstance (String serviceName) {
     return disposed ? null : services.get(serviceName);
   }
 
   /***
    * Returns the requested dispatcher instance or null if one is not found.
    *
    * @param dispatcherType The type of dispatcher to return.
    *
    * @return The requested dispatcher instance or null if one is not found.
    */
   Object getDispatcherInstance (Class dispatcherType) {
     return disposed ? null : dispatchers.get(dispatcherType);
   }
 
   /***
    * Invokes initalize() on every Lifecycle instance in the application, disposing
    * those it's created if one fails.
    */
   private void initalize () {
     int current = 0;
     try {
       for (; current < lifecycles.length; ++current)
         lifecycles[current].initalize();
     } catch (RuntimeException re) {
       dispose(current);
       throw re;
     } catch (Error e) {
       dispose(current);
       throw e;
     }
   }
 
   /***
    * Invokes dispose() on the Lifecycle instance at the specified index in the
    * application, and every preceeding instance.
    *
    * @param fromIndex One past thes last index of the Lifecycle instance to dispose.
    */
   private void dispose (int fromIndex) {
     if (fromIndex == 0)
       return;
     try {
       lifecycles[fromIndex - 1].dispose();
     } finally {
       dispose(fromIndex - 1);
     }
   }
 }