Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.search.api.SearchState.java

Here you can find all the information about the file org.dgpf.search.api.SearchState.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-03-30 13:30:26
 * Original Filename: org.dgpf.search.api.SearchState.java
 * Version          : 2.0.3
 * Last modification: 2006-07-23
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" 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.
 */

 
package org.dgpf.search.api;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import org.sfc.collections.Arrays;
import org.sfc.meta.BoundedByteProperty;
import org.sfc.meta.BoundedDoubleProperty;
import org.sfc.meta.BoundedLongProperty;
import org.sfc.meta.MetaInformation;
import org.sfc.meta.Property;
import org.sfc.meta.TimeProperty;
import org.sfc.utils.ICloneable;
import org.sfc.utils.Typesafe;

/**
 * <p>
 * This class represents the state of a search. It contains the status
 * information dynamically updated by the search engine.
 * </p>
 * <p>
 * <h2>SERIALIZATION WARNING</h2>
 * Serializing instances of this class more than once into the same
 * <code>ObjectOutputStream</code> will lead to corruption.
 * <code>ObjectOutputStream</code>s serialize the same object only once,
 * thus serializing an instance of this class twice will lead to only
 * one real copy, and reading it will return the same instance with the
 * same values twice. So if you keep a <code>Geneticstate</code>, wait
 * until its values change and than storing it again will lead to the
 * changed data getting lost.</p>
 * <p>
 * <h2>SERIALIZATION HINT</h2>
 * Whenever serializing an object of this instance, you
 * <strong>must</strong> synchronize on it, like:
 * <code>
 * SearchState<Double> s;
 * ObjectOutputStream  o;
 * ...
 * synchronized(s)
 *  {
 *  o.writeUnshared(s);
 *  }
 *  ...
 * </code>
 * </p>
 *
 * @param <Genotype>    The sort of genotype used to represent individuals.
 *                      This must be a serializable type.
 *              
 * @see SearchStateBag
 * @author Thomas Weise
 */

public class SearchState<Genotype extends     Serializable>
                                  extends     SearchData
                                  implements  ICloneable
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;
  
/**
 * The meta-information of search states.
 */

  public  static  final MetaInformation           SEARCH_STATE_METAINFO ;
  

/**
 * The property for individual comparator.
 */

  public  static  final Property<String>          COMPARATOR ;
/**
 * The property for the adaptation strategy.
 */

  public  static  final Property<String>          ADAPTATION_STRATEGY ;
/**
 * The property for the halt parameters.
 */

  public  static  final Property<String>          HALT_PARAMETERS ;
/**
 * The property for the best individual.
 */

  public  static  final Property<Individual<?>>   BEST ;
/**
 * The property for the best individual of a fitness function.
 */

  public  static  final Property<Individual<?>>   FITNESS_BEST; 
/**
 * The property for the improvement indicator.
 */

  public  static  final BoundedByteProperty       IMPROVEMENT ;
/**
 * The property for the improvement indicator per fitness function.
 */

  public  static  final BoundedDoubleProperty     FITNESS_IMPROVEMENT;
/**
 * The property containing the last update time.
 */

  public  static  final TimeProperty              LAST_UPDATE_TIME;
/**
 * The property for the best individual since the last reset.
 */

  public  static  final Property<Individual<?>>   REL_BEST;
/**
 * The property for the improvment indicator since the last reset.
 */

  public  static  final BoundedByteProperty       REL_IMPROVEMENT;  
/**
 * The property for the count of updates performed.
 */

  public  static  final BoundedLongProperty       UPDATE_COUNT ;
/**
 * The property for the relative updates level.
 */

  public  static  final BoundedLongProperty       UPDATE_LEVEL  ;
/**
 * The property for the time needed for the last search update.
 */

  public  static  final TimeProperty              UPDATE_TIME ;
  
  static
    {
    COMPARATOR = new Property<String>(SearchData2.COMPARATOR,
                                      String.class);
    COMPARATOR.add_port(SearchState.class, true, false, null);
    
    ADAPTATION_STRATEGY =
       new Property<String>("adaptation_strategy",
                             SearchUtils.CONTROL_PROPERTIES,
                             String.class);
    ADAPTATION_STRATEGY.add_port(SearchState.class, true, false, null);
    
    HALT_PARAMETERS =
       new Property<String>("halt_parameters",
                             SearchUtils.CONTROL_PROPERTIES,
                             String.class);
    HALT_PARAMETERS.add_port(SearchState.class, true, false, null);
    
    
    BEST =
       Typesafe.cast(new Property<Individual>(
                             "best",
                             SearchUtils.FITNESS_PROPERTIES,
                             Individual.class));
    BEST.add_port(SearchState.class, true, false, null);


    FITNESS_BEST =
       Typesafe.cast(new Property<Individual>(
                             SearchUtils.FITNESS_PREFIX +
                             BEST.get_name(),
                             SearchUtils.FITNESS_PROPERTIES,
                             Individual.class));
    FITNESS_BEST.add_port(SearchState.class"get_best", null,
                          SearchUtils.FITNESS_FUNCTION_COUNT_FUNC);

    IMPROVEMENT = new BoundedByteProperty("improvement",
                                   SearchUtils.FITNESS_PROPERTIES,
                                   ((byte)(-1)), ((byte)1));
    IMPROVEMENT.add_port(SearchState.class, true, false, null);


    FITNESS_IMPROVEMENT = new BoundedDoubleProperty(
                     SearchUtils.FITNESS_PREFIX + IMPROVEMENT.get_name(),
                     SearchUtils.FITNESS_PROPERTIES,
                     Double.MIN_VALUE, Double.MAX_VALUE);
    FITNESS_IMPROVEMENT.add_port(SearchState.class"get_improvement", null,
                          SearchUtils.FITNESS_FUNCTION_COUNT_FUNC);

    LAST_UPDATE_TIME  =
           new TimeProperty( "last_update_time",
                             SearchUtils.PERFORMANCE_PROPERTIES,
                             0, Long.MAX_VALUE, false);
    LAST_UPDATE_TIME.add_port(SearchState.class, true, false, null);

    REL_BEST =
       Typesafe.cast(new Property<Individual>(
                             SearchUtils.REL_PREFIX + BEST.get_name(),
                             SearchUtils.FITNESS_PROPERTIES,
                             Individual.class));
    REL_BEST.add_port(SearchState.class, true, false, null);

    REL_IMPROVEMENT =
           new BoundedByteProperty(
                             SearchUtils.REL_PREFIX + IMPROVEMENT.get_name(),
                             SearchUtils.FITNESS_PROPERTIES,
                             ((byte)(-1)), ((byte)1));
    REL_IMPROVEMENT.add_port(SearchState.class, true, false, null);
        
    SearchUtils.START_TIME.add_port(SearchState.class, true, false, null);  
    SearchUtils.TASK_COUNT.add_port(SearchState.class, true, false, null);    
    SearchUtils.TOTAL_TIME.add_port(SearchState.class, true, false, null);
  
    UPDATE_COUNT = new BoundedLongProperty(
                               "update_count",
                               SearchUtils.PERFORMANCE_PROPERTIES,
                               0, Long.MAX_VALUE);
    UPDATE_COUNT.add_port(SearchState.class, true, false, null);
  
    UPDATE_LEVEL = new BoundedLongProperty(
                               "update_level",
                               SearchUtils.PERFORMANCE_PROPERTIES,
                               0, Long.MAX_VALUE);
    UPDATE_LEVEL.add_port(SearchState.class, true, false, null);
  
    UPDATE_TIME = new TimeProperty("update_time",
                                   SearchUtils.PERFORMANCE_PROPERTIES,
                                   0, Long.MAX_VALUE, true);
    UPDATE_TIME.add_port(SearchState.class, true, false, null);
      
    SEARCH_STATE_METAINFO = new MetaInformation();
    }
  
/**
 * The name of the comparator used for the search.
 * @see #get_comparator()
 */

  private             String                  m_comparator  ;
/**
 * The (relative) time between the current and the last state update.
 * @see #get_update_time()
 */

  private             long                    m_update_time ;
/**
 * The time when the last state update took place.
 * @see #get_last_update_time()
 */

  private             long                    m_last_update ;
/**
 * The total time used.
 * @see #get_total_time()
 */

  private             long                    m_total_time  ;
/**
 * The time when the search was started <i>or</i> resumed its work.
 * @see #get_start_time()
 */

  private             long                    m_start_time   ;
/**
 * The count of updates already performed.
 * @see #get_update_count()
 */

  private             long                    m_update_count  ;
/**
 * Normally, the count of updates is equal the update leve. The update
 * count however is increasing strictly, while the update level may be
 * resetted. This could be used, for example, when a search algorithm gets
 * stuck and wants to restart. In this case, it can reset the update level
 * while not influencing the update count.
 * @see #get_update_level()
 */

  private             long                    m_update_level  ;
  
/**
 * For each single fitness function, there exists a superior element.
 * @see #get_best(int)
 */

          transient   Individual<Genotype>[]  m_bests            ;
/**
 * The amount of fitness the new best individual is better than the old
 * best individual. This will be positive if a new best individual of the
 * specified fitness function has been found, and 0 or negative otherwise.
 * @see #get_improvement(int)
 */

          transient   double[]                m_improvements      ;
/**
 * Also there is one globally superior element.
 * @see #get_best()
 */

          transient   Individual<Genotype>    m_best             ;
/**
 * Determines wether there has been an improvement in the last update or
 * not.
 * An improvement means that a new globally supreme element has been found.
 * @see #get_improvement()
 */

                      byte                    m_improvement       ;
/**
 * Also there is one globally superior element in this turn.
 * @see #get_rel_best()
 */

          transient   Individual<Genotype>    m_best_2             ;
/**
 * Determines wether there has been an improvement in the last update or
 * not relatively.
 * An improvement means that a new globally supreme element has been found.
 * @see #get_rel_improvement()
 */

                      byte                    m_improvement_2      ;
/**
 * The human readable description of the halt parameters used.
 * @see #get_halt_parameters()
 */

  private             String                  m_halt_parameters   ;
/**
 * The name of the adaptation strategy.
 * @see #get_adaptation_strategy()
 */

  private             String                  m_adaptation ;
/**
 * The count of tasks processed in total.
 * @see #get_task_count()
 */

                      long                    m_task_count  ;
                      
/**
 * Create a new search state.
 * @param p_ff_count  The count of fitness functions evaluated by this
 *                    search.
 */

  protected SearchState  (final int  p_ff_count)
    {
    super(p_ff_count);
    
    int                     l_i, l_fc;
    Individual<Genotype>[]  l_d;
    
    l_i  = this.get_fitness_function_count();
    l_fc = l_i;
    
    l_d                  = Arrays.create(Individual.class, l_i);
    this.m_improvements  = new double[l_i];
    this.m_bests         = l_d;
    
    for(--l_i; l_i >= 0; l_i--)
      {
      l_d[l_i] = new Individual<Genotype>(l_fc);
      }
    
    this.m_best         = new Individual<Genotype>(l_fc);
    this.m_best_2       = new Individual<Genotype>(l_fc);
    
    this.set_halt_parameters(SearchUtils.DEFAULT_HALT_PARAMETERS.toString());
    this.set_comparator(SearchUtils.DEFAULT_COMPARATOR.toString());
    this.set_adaptation_strategy(
                          SearchUtils.DEFAULT_ADAPTATION_STRATEGY.toString());
    }
  
/**
 * Obtain the name of the comparator used by the search.
 * @return The name of the comparator used by the search.
 * @see IndividualComparator#toString()
 */

  public  final String  get_comparator  ()
    {
    return this.m_comparator;
    }
  
/**
 * Store the name of the comparator used by the search.
 * @param p_name The name of the comparator used by the search.
 */

  private final void  set_comparator  (final String p_name)
    {
    if( (p_name != null) && (p_name.length() > 0) )
      {
      this.m_comparator = p_name;
      }
    }
  
/**
 * Obtain the human readable description of the halt parameters used.
 * @return The human readable description of the halt parameters used.
 */

  public  final String  get_halt_parameters ()
    {
    return this.m_halt_parameters;
    }
  
/**
 * Store the human readable description of the halt parameters used.
 * @param p_name The human readable description of the halt parameters used.
 */

  private final void  set_halt_parameters (final String p_name)
    {
    if( (p_name != null) && (p_name.length() > 0) )
      {
      this.m_halt_parameters = p_name;
      }
    }
  
/**
 * Obtain the name of the adaptation strategy adjusting the related search
 * parameter set.
 * @return The name of the adaptation strategy adjusting the related search
 *         parameter set.
 */

  public  final String  get_adaptation_strategy ()
    {
    return this.m_adaptation;
    }
  
/**
 * Set the name of the adaptation strategy adjusting the related search
 * parameter set.
 * @param p_strategy  The new adaptation strategy's name to of the 
 *                    related search parameter set.
 */

  private final void  set_adaptation_strategy (final String p_strategy)
    {
    if((p_strategy != null) && (p_strategy.length() > 0))
      {
      this.m_adaptation = p_strategy;
      }
    }
  
/**
 * Obtain the time of the last update of the search's state. This might be,
 * for example, the end time of the last generation in genetic algorithms.
 * @return  The time of the last update of the search's state.
 */

  public  final long  get_last_update_time ()
    {
    return this.m_last_update;
    }
  
/**
 * Obtain the time between the last and the current update of the search's
 * state. This might be, for example, the time it took to evaluate a
 * generation in genetic algorithms.
 * @return The time between the last and the current update of the search's
 *         state.
 */

  public  final long  get_update_time ()
    {
    return this.m_update_time;
    }
  
    
/**
 * Obtain the total time the search has consumed up to now. If the search
 * was stored as a snapshot and now restarted, the total time will be
 * preserved and accumulated.
 * @return The total time the search has consumed up to now.
 */

  public  final long  get_total_time  ()
    {
    return this.m_total_time;
    }
  
/**
 * Obtain the time the search was started <i>or</i> resumed.
 * @return The time the search was started <i>or</i> resumed.
 */

  public  final long  get_start_time  ()
    {
    return this.m_start_time;
    }
  
/**
 * Returns the (absolute) count of updates already performed. This might be,
 * for example, the count of generations in genetic algorithms.
 * @return The (absolute, total) count of updates already performed.
 * @see #get_update_level()
 */

  public  final long  get_update_count  ()
    {
    return this.m_update_count;
    }
  

/**
 * Returns the (relative) count of updates already performed. 
 * Normally, the (absolute) count of updates is equal the update leve.
 * The update count however is increasing strictly, while the update level
 * may be resetted. This could be used, for example, when a search algorithm
 * gets stuck and wants to restart. In this case, it can reset the update
 * level while not influencing the update count.
 * @return The (relative) count of updates already performed.
 * @see #get_update_count()
 */

  public  final long  get_update_level  ()
    {
    return this.m_update_level;
    }
  
/**
 * The distance between the fitness of the current maximum element of the
 * specified fitness function and the best element found up to the last
 * update. This will be positive if a new best individual of the
 * specified fitness function has been found, and 0 or negative otherwise.
 * @param p_index The index of the fitness function of interest.
 * @return  The distance between the fitness of the current maximum element
 *          of the specified fitness function and the best element found up
 *          to the last update. This will be positive if a new best
 *          individual of the specified fitness function has been found,
 *          and 0 or negative otherwise.
 */

  public  final double    get_improvement (final int p_index)
    {
    return this.m_improvements[p_index];
    }

/**
 * Obtain the currently superior element concerning a specific fitness
 * function.
 * @param p_index The index of the fitness function of interest.
 * @return  The individual information on the superior element concerning a
 *          specific fitness function.
 */

  public  final Individual<Genotype>  get_best  (final int p_index)
    {
    return this.m_bests[p_index];
    }

/**
 * Returns wether there has been an improvement in the last update or not.
 * An improvement means that a new globally supreme element has been found.
 * @return  <code>&gt;0</code> if and only if there was an improvement
 *          concerning the search's comparator in the last update.
 *          <code>0</code> if and only if an individual of the same
 *          fitness concerning the search's comparator has been found
 *          (or re-discovered) in the last search update.
 *          <code>&lt;0</code> if and only if no improvement could be
 *          measured in the last search update, nor has an individual been
 *          discovered with at least the same fitness as the current
 *          supremum.
 * @see #get_rel_improvement()
 * @see #get_update_level()
 * @see #get_update_count()
 */

  public  final byte get_improvement ()
    {
    return this.m_improvement;
    }

  
  
  
/**
 * Obtain the currently supreme element concerning the search's comparator.
 * @return The currently supreme element concerning the search's comparator.
 * @see #get_rel_best()
 * @see #get_update_level()
 * @see #get_update_count()
 */

  public  final Individual<Genotype>  get_best  ()
    {
    return this.m_best;
    }
  
  
/**
 * Returns wether there has been an improvement in the last update or not.
 * An improvement means that a new globally supreme element has been found.
 * This method is somehow similar to <code>get_improvement()</code>, except
 * that it does not work on all updates ever performed but only on the
 * current run. This means, that if we have an update level different from
 * the update count, we might also have a different relative improvement.
 * In other words, if the update level is resetted, the relative
 * improvement also will.
 * @return  <code>&gt;0</code> if and only if there was an improvement
 *          concerning the search's comparator in the last update.
 *          <code>0</code> if and only if an individual of the same
 *          fitness concerning the search's comparator has been found
 *          (or re-discovered) in the last search update.
 *          <code>&lt;0</code> if and only if no improvement could be
 *          measured in the last search update, nor has an individual been
 *          discovered with at least the same fitness as the current
 *          supremum.
 * @see #get_improvement()
 * @see #get_update_level()
 * @see #get_update_count()
 */

  public  final byte get_rel_improvement ()
    {
    return this.m_improvement_2;
    }

  
  
  
/**
 * Obtain the currently supreme element concerning the search's comparator.
 * This method is somehow similar to <code>get_best()</code>, except
 * that it does not work on all updates ever performed but only on the
 * current run. This means, that if we have an update level different from
 * the update count, we might also have a different relative best
 * individual.
 * In other words, if the update level is resetted, the relative
 * best individual also will.
 * @return The currently supreme element concerning the search's comparator.
 * @see #get_best()
 * @see #get_update_level()
 * @see #get_update_count()
 */

  public  final Individual<Genotype>  get_rel_best  ()
    {
    return this.m_best_2;
    }
  
/**
 * Returns the count of tasks processed in total.
 * @return  The count of tasks processed in total.
 */

  public  final long  get_task_count  ()
    {
    return this.m_task_count;
    }
  
  
/**
 * Assign the internal data of this search data to the data of
 * another one.
 * @param p_data  The simulation data  to assign to.
 */

  @Override
  protected void  assign  (final Object p_data)
    {    
    SearchData2<Genotype>       l_sd;
    SearchState<Genotype>       l_ss;
    SearchParameters<Genotype>  l_sp;
    Object                      l_o;
        
    if(p_data instanceof SearchData2)
      {      
      l_sd = Typesafe.cast(p_data);
      
      l_o  = l_sd.get_comparator();
      if(l_o != null) this.set_comparator(l_o.toString());      
      }
    
    if(p_data instanceof SearchParameters)
      {
      l_sp = Typesafe.cast(p_data);
      
      l_o = l_sp.get_halt_parameters();
      if(l_o != null) this.set_halt_parameters(l_o.toString());
      
      l_o = l_sp.get_adaptation_strategy();
      if(l_o != null) this.set_adaptation_strategy(l_o.toString());
      }
    
    if(p_data instanceof SearchState)
      {
      l_ss = Typesafe.cast(p_data);
      this.set_comparator(l_ss.m_comparator);                 
      this.set_halt_parameters(l_ss.m_halt_parameters);
      this.set_adaptation_strategy(l_ss.m_adaptation);
      }
    
    super.assign(p_data);
    }
  
/**
 * Reset the update level back to zero. This method is called instead of
 * <code>update()</code> when the search is resetted.
 * @see #update()
 */

  final void  reset_update_level()
    {
    this.m_update_count++;
    this.m_update_level  = 0;
    this.m_best_2.clear();
    this.m_improvement_2 = 0;
    }
    
/**
 * Update the state information. This method is called whenever the search
 * proceeds normally.
 * @see #reset_update_level()
 */

  final void  update  ()
    {    
    long  l_t, l_v;
    
    l_t                  = System.currentTimeMillis();
    l_v                  = l_t - this.m_last_update;
    this.m_last_update   = l_t;
    this.m_update_time   = l_v;
    this.m_total_time   += l_v;
    }

/**
 * Advance to the next update.
 */

  final void  inc_update_level()
    {     
    this.m_update_count++;
    this.m_update_level++;
    }
  
/**
 * This method is called when the search starts or resumes.
 */

  final void  start ()
    {
    long  l_t;
    
    l_t                 = System.currentTimeMillis();
    this.m_last_update  = l_t;
    this.m_update_time  = 0;
    this.m_start_time   = l_t;
    this.m_update_count = 0;
    }
  
  
/**
 * Creates and returns a copy of this object.  The precise meaning 
 * of "copy" may depend on the class of the object. 
 *
 * @return     A clone of this instance.
 * 
 * @see java.lang.Cloneable
 */

  @Override
  public  Object  clone ()
    {
    final SearchState<Genotype>   l_ss;
    final Individual<Genotype>[]  l_id;
          int                     l_i;
    
    try
      {
      l_ss                = Typesafe.cast(super.clone());      
      l_ss.m_best         = Typesafe.cast(l_ss.m_best.clone());
      l_ss.m_best_2       = Typesafe.cast(l_ss.m_best_2.clone());
      l_ss.m_improvements = l_ss.m_improvements.clone();
      l_ss.m_bests = l_id = l_ss.m_bests.clone();
      
      for(l_i = (l_id.length-1); l_i >= 0; l_i--)
        {
        l_id[l_i] = Typesafe.cast(l_id[l_i].clone());
        }
      
      return l_ss;
      }
    catch(Throwable l_t)
      {
      return this;
      }
    }
  


/**
 * Stores the <code>SfcEvent</code> into the stream.
 * @param p_s The output stream.
 * @throws  IOException If something io-like went wrong.
 */

  private final void writeObject(final ObjectOutputStream p_s)
        throws IOException
    {
    p_s.defaultWriteObject();

    int                       l_c;
    Individual<Genotype>[]    l_b;

    p_s.writeUnshared(this.m_improvements);
    p_s.writeUnshared(this.m_best);
    if(this.m_update_count != this.m_update_level)
      {
      p_s.writeUnshared(this.m_best_2);
      }

    l_b  = this.m_bests;
    l_c  = l_b.length;

    for(--l_c; l_c >= 0; l_c--)
      {
      p_s.writeUnshared(l_b[l_c]);
      }
    }
  


/**
 * Reconstitute the <code>SfcEvent</code> instance from a stream (that is,
 * deserialize it).
 * @param p_s The input stream.
 * @throws  IOException If something io-like went wrong.
 * @throws  ClassNotFoundException  If a needed class could not be found.
 */

  private final void readObject(final ObjectInputStream p_s)
        throws IOException, ClassNotFoundException
    {
    p_s.defaultReadObject();

    int                       l_c;
    Individual<Genotype>[]    l_b;

    this.m_improvements     = Typesafe.cast(p_s.readUnshared());
    this.m_best             = Typesafe.cast(p_s.readUnshared());
    
    if(this.m_update_count != this.m_update_level)
      {
      this.m_best_2         = Typesafe.cast(p_s.readUnshared());
      }
    else
      {
      this.m_best_2         = new Individual<Genotype>(
                                      this.get_fitness_function_count());
      this.m_best_2.assign(this.m_best);
      }

    l_c = this.get_fitness_function_count();
    this.m_bests = l_b = Arrays.create(Individual.class, l_c);

    for(--l_c; l_c >= 0; l_c--)
      {
      l_b[l_c] = Typesafe.cast(p_s.readUnshared());
      }
    }
  
  
  }

File Information:

file name:SearchState.java
package:org.dgpf.search.api
qualified name:org.dgpf.search.api.SearchState.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/search/api/SearchState.java
size:27.027 KB (27676 B)
uploaded: 2015-07-22 04:11:00 GMT+0000
last update: 2006-07-23 12:10:13 GMT+0000
last access: 2017-11-19 02:42:29 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2017-11-19 02:42:29 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo