jgapfactory.java

jGAp 遗传算法 提不错的一款软件 最新的更新

/*
 * This file is part of JGAP.
 *
 * JGAP offers a dual license model containing the LGPL as well as the MPL.
 *
 * For licensing information please see the file license.txt included with JGAP
 * or have a look at the top of class org.jgap.Chromosome which representatively
 * includes the JGAP license policy applicable for any file delivered with JGAP.
 */
package org.jgap.impl;

import java.io.*;
import java.util.*;
import org.jgap.*;
import org.jgap.util.*;
import org.apache.commons.lang.builder.*;

/**
 * Central factory for creating default objects to use, e.g. random generators.
 * Could be made configurable. An instance of JGAPFactory can be accessed via<p>
 * <code>Genotype.getConfiguration().getJGAPFactory();</code><p>
 * To use your own factory class instead, use:<p>
 * <code>
 * System.setProperty(Configuration.PROPERTY_JGAPFACTORY_CLASS, "myFactory");<p>
 * </code>
 * with "myFactory" representing the name of your class to use.
 *
 * @author Klaus Meffert
 * @since 2.6
 */
public class JGAPFactory
    implements IJGAPFactory, Serializable, ICloneable, Comparable {
  /** String containing the CVS revision. Read out via reflection!*/
  private final static String CVS_REVISION = "$Revision: 1.18 $";

  private List m_parameters;

  private List m_cloneHandlers;

  private List m_initer;

  private List m_compareHandlers;

  private ICloneHandler m_defaultCloneHandler;

  private IInitializer m_defaultIniter;

  private ICompareToHandler m_defaultComparer;

  private IGeneticOperatorConstraint m_geneticOpConstraint;

  private transient LRUCache m_cache;

  private boolean m_useCaching;

  public JGAPFactory(boolean a_useCaching) {
    m_initer = new Vector();
    m_cache = new LRUCache(50);
    m_useCaching = a_useCaching;
    m_cloneHandlers = new Vector();
    m_compareHandlers = new Vector();
    // Construct default handlers at the beginning to avoid multi-threading
    // conflicts in getXXXFor methods.
    m_defaultCloneHandler = new DefaultCloneHandler();
    m_defaultIniter = new DefaultInitializer();
    m_defaultComparer = new DefaultCompareToHandler();
  }

  /**
   * Allows setting (generic because unknown) parameters for creating objects.
   *
   * @param a_parameters Collection of generic parameters
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public void setParameters(final Collection a_parameters) {
    m_parameters = new Vector(a_parameters);
  }

  /**
   * @return Collection of generic parameters
   *
   * @author Klaus Meffert
   * @since 3.0
   */
  public Collection getParameters() {
    return m_parameters;
  }

  public RandomGenerator createRandomGenerator() {
    return new StockRandomGenerator();
  }

  /**
   * Registers a clone handler that could be retrieved by
   * getCloneHandlerFor(Class).
   *
   * @param a_cloneHandler the ICloneHandler to register
   * @return index of the added clone handler, needed when removeCloneHandler
   * will be called
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public int registerCloneHandler(final ICloneHandler a_cloneHandler) {
    m_cloneHandlers.add(a_cloneHandler);
    return m_cloneHandlers.size() - 1;
  }

  /**
   * Removes a clone handler at a given index (which is obtained from
   * registerCloneHandler).
   *
   * @param a_index the index of the clone handler to remove
   * @return the removed ICloneHandler, or Exception if not successfull
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public ICloneHandler removeCloneHandler(final int a_index) {
    return (ICloneHandler) m_cloneHandlers.remove(a_index);
  }

  /**
   * Retrieves a clone handler capable of clone the given class.
   *
   * @param a_obj the object to clone (maybe null)
   * @param a_classToClone the class to clone an object of (maybe null)
   * @return the clone handler found capable of clone the given
   * class, or null if none registered
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public ICloneHandler getCloneHandlerFor(final Object a_obj,
      final Class a_classToClone) {
    return (ICloneHandler) findHandlerFor(a_obj, a_classToClone,
        m_cloneHandlers,
        m_defaultCloneHandler,
        "clone");
  }

  /**
   * Registers an initializer that could be retrieved by
   * getInitializerFor(Class).
   *
   * @param a_chromIniter the IChromosomeInitializer to register
   * @return index of the added initializer, needed when
   * removeChromosomeInitializer will be called
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public int registerInitializer(final IInitializer a_chromIniter) {
    m_initer.add(a_chromIniter);
    return m_initer.size() - 1;
  }

  /**
   * Removes an initializer at a given index (which is obtained from
   * registerInitializer).
   *
   * @param a_index the index of the initializer to remove
   * @return the removed IInitializer, or null if not successfull
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public IInitializer removeInitializer(final int a_index) {
    return (IInitializer) m_initer.remove(a_index);
  }

  /**
   * Retrieves an initializer capable of initializing the Object of the given
   * class.
   *
   * @param a_obj the object to init (maybe null)
   * @param a_class the object class to init (maybe null)
   * @return new instance (should be!) of initialized object
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public IInitializer getInitializerFor(final Object a_obj,
                                        final Class a_class) {
    return (IInitializer) findHandlerFor(a_obj, a_class,
        m_initer,
        m_defaultIniter,
        "init");
  }

  public void setGeneticOperatorConstraint(final IGeneticOperatorConstraint
      a_constraint) {
    m_geneticOpConstraint = a_constraint;
  }

  public IGeneticOperatorConstraint getGeneticOperatorConstraint() {
    return m_geneticOpConstraint;
  }

  /**
   * Retrieves a handler capable of comparing two instances of the given class.
   *
   * @param a_obj the object to compare (maybe null)
   * @param a_classToCompareTo the class instances to compare (maybe null)
   * @return the handler found capable of comparing instances
   * of the given class, or null if none registered
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public ICompareToHandler getCompareToHandlerFor(Object a_obj,
      Class a_classToCompareTo) {
    return (ICompareToHandler) findHandlerFor(a_obj, a_classToCompareTo,
        m_compareHandlers,
        m_defaultComparer,
        "compare");
  }

  /**
   * Registers a compareTo-handler that could be retrieved by
   * getCompareToHandlerFor(Class).
   *
   * @param a_compareToHandler the ICompareToHandler to register
   * @return index of the added handler, needed when removeCompareToHandler
   * will be called
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public int registerCompareToHandler(ICompareToHandler a_compareToHandler) {
    m_compareHandlers.add(a_compareToHandler);
    return m_compareHandlers.size() - 1;
  }

  /**
   * Removes a compareTo-handler at a given index (which is obtained from
   * registerCompareToHandler).
   *
   * @param a_index the index of the handler to remove
   * @return the removed handler, or Exception if not successfull
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  public ICompareToHandler removeCompareToHandler(final int a_index) {
    return (ICompareToHandler) m_compareHandlers.remove(a_index);
  }

  /**
   * Helper: Finds a handler for a given Object or Class, returns the default
   * handler, if one is provided. Uses an LRU cache to speedup things!
   *
   * @param a_obj the object to find a handler for (maybe null)
   * @param a_class the class to find a handler for (maybe null)
   * @param a_list list of available handlers
   * @param a_default a default handler to return in none other is found
   * @param a_listID arbitrary unique string for accessing the cache
   * @return the handler found, or null if none registered
   *
   * @author Klaus Meffert
   * @since 2.6
   */
  protected IHandler findHandlerFor(final Object a_obj,
                                    final Class a_class,
                                    final List a_list,
                                    final IHandler a_default,
                                    final String a_listID) {
    String key = null;
    String key1, key2;
    if (m_useCaching) {
      // Construct key for cache lookup:
      // Class name of list + a_class-Name + a_obj.hashCode()
      // ----------------------------------------------------
      if (a_class == null) {
        key1 = "null";
      }
      else {
        key1 = a_class.getName();
      }
      if (a_obj == null) {
        key2 = "null";
      }
      else {
        key2 = a_obj.getClass().getName();
      }
      key = a_listID + "/" + key1 + "/" + key2;
      // Lookup cache.
      // -------------
      Object handler = m_cache.get(key);
      if (handler != null) {
        return (IHandler) handler;
      }
      // Not found in cache. Search initially.
      // -------------------------------------
    }
    IHandler result = null;
    Iterator it = a_list.iterator();
    while (it.hasNext()) {
      IHandler initer = (IHandler) it.next();
      if (initer.isHandlerFor(a_obj, a_class)) {
        result = initer;
        break;
      }
    }
    if (result == null) {
      // No registered handler found. Try the default handler.
      // -----------------------------------------------------
      if (a_default != null) {
        if (a_default.isHandlerFor(a_obj, a_class)) {
          result = a_default;
        }
      }
    }
    if (m_useCaching) {
      // Add to cache.
      // -------------
      if (result != null) {
        m_cache.put(key, result);
      }
    }
    return result;
  }

  /**
   * @return true: caching used, false: no caching used
   *
   * @author Klaus Meffert
   * @since 3.0
   */
  public boolean isUseCaching() {
    return m_useCaching;
  }

  public Object clone() {
    try {
      /**@todo check if it works this way*/
      return super.clone();
    } catch (CloneNotSupportedException cex) {
      throw new CloneException(cex);
    }
  }

  /**
   * The equals-method
   * @param a_other sic
   * @return sic
   *
   * @author Klaus Meffert
   * @since 3.2
   */
  public boolean equals(Object a_other) {
    try {
      return compareTo(a_other) == 0;
    } catch (ClassCastException cex) {
      return false;
    }
  }

  /**
   * @param a_other other object to compare
   * @return as always
   *
   * @author Klaus Meffert
   * @since 3.2
   */
  public int compareTo(Object a_other) {
    if (a_other == null) {
      return 1;
    }
    else {
      // Do not consider m_parameters, m_cache and m_useCaching.
      // -------------------------------------------------------
      JGAPFactory other = (JGAPFactory) a_other;
      return new CompareToBuilder()
          .append(m_cloneHandlers.toArray(), other.m_cloneHandlers.toArray())
          .append(m_initer.toArray(), other.m_initer.toArray())
          .append(m_compareHandlers.toArray(), other.m_compareHandlers.toArray())
          .append(m_defaultCloneHandler, other.m_defaultCloneHandler)
          .append(m_defaultComparer, other.m_defaultComparer)
          .append(m_geneticOpConstraint, other.m_geneticOpConstraint)
          .toComparison();
    }
  }
}