Logo
Distributed Genetic Programming Framework
print print

File org.sfc.events.AsyncEventPropagator.java

Here you can find all the information about the file org.sfc.events.AsyncEventPropagator.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-07-24 08:44:45
 * Original Filename: org.sfc.events.AsyncEventPropagator.java
 * Version          : 1.0.1
 * Last modification: 2006-07-24
 *                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.sfc.events;

import org.sfc.collections.CircularBuffer;
import org.sfc.parallel.IAbortable;
import org.sfc.parallel.IStartable;
import org.sfc.parallel.IWaitable;
import org.sfc.parallel.SfcThread;
import org.sfc.parallel.SfcThreadGroup;


/**
 * This class denotes an asynchron event propagator. It caches so and so
 * much events and lets them be delivered by an internal thread.
 *
 * @author Thomas Weise
 */

public class AsyncEventPropagator extends     EventPropagator
                                  implements  IStartable, IWaitable,
                                              IAbortable
  {
/**
 * The serial version uid.
 */

  private static  final long  serialVersionUID  = 1;
/**
 * The buffer for the sfc events. 
 */

          final CircularBuffer<SfcEvent>  m_buffer  ;
/**
 * The sfc worker thread.
 */

  private final SfcThread                 m_worker  ;
  
  
/**
 * Create a new asynchron event propagator.
 * @param p_buffer_size   The count of pending events that should be
 *                        buffered. Set this to <code>-1</code> to use a
 *                        reasonable default.
 * @param p_thread_group  The thread groups the internal thread should
 *                        become part of.
 */

  public  AsyncEventPropagator  (final int            p_buffer_size,
                                 final SfcThreadGroup p_thread_group)
    {
    super();
    this.m_buffer = new Buffer(p_buffer_size);
    this.m_worker = new WorkerThread(p_thread_group);
    }
  
/**
 * Create a new asynchron event propagator.
 * @param p_buffer_size   The count of pending events that should be
 *                        buffered. Set this to <code>-1</code> to use a
 *                        reasonable default.
 */

  public  AsyncEventPropagator  (final int            p_buffer_size)
    {
    this(p_buffer_size, null);
    }
  
/**
 * This method delivers an event to a list of listeners.
 * @param p_event     The event to be delivered.
 */

  @Override
  public final  void  receive(final SfcEvent p_event)
    {
    this.m_buffer.enqueue(p_event);
    }
  

/**
 * Start this activity.
 */

  public  final void  start ()
    {
    this.m_worker.start();
    }
  

/**
 * Wait for this object.
 */

  public  final void  wait_for  ()
    {
    this.m_worker.wait_for();
    }
  

/**
 * Abort this activity.
 * This method does not block.
 */

  public  final void  abort ()
    {
    this.m_buffer.abort();
    this.m_worker.abort();
    }

/**
 * Tells the activity to stop its actions. This is the proper method to
 * allow the activity to terminate itself.
 * This method does block until the activity has finished.
 * @see #abort()
 */

  public  final void  abort_and_wait  ()
    {
    this.abort();
    this.wait_for();
    }
  
/**
 * This method delivers an event to a list of listeners.
 * @param p_event     The event to be delivered.
 */

  final  void  super_receive(final SfcEvent p_event)
    {
    super.receive(p_event);
    }
  
  
/**
 * The internal buffer class.
 *
 * @author Thomas Weise
 */

  private static  final class Buffer  extends CircularBuffer<SfcEvent>
    {
/**
 * Create a new circular buffer for at most a specified count of items of
 * the specified class.
 * @param p_size    The size of the buffer to allocate.
 */

    public  Buffer  (final int       p_size)
      {
      super(SfcEvent.class, ((p_size <= 0) ? 512 : p_size));
      }
    
/**
 * This method will be called whenever the buffer overflows and an item
 * should be determined to be dropped. If none can be found, the new item
 * will be dropped. This method returns <code>true</code> if the specified
 * old item can be dropped and the new one can be buffered instead.
 * @param p_old_item    The old item to be maybe dropped.
 * @param p_new_item    The new item, which could possible replace the old
 *                      one.
 * @return  <code>true</code> if and only if the new item may replace the
 *          old one, <code>false</code> if the old item should be kept.
 */

    @Override
    protected final boolean can_drop  (final SfcEvent p_old_item,
                                       final SfcEvent p_new_item)
      {
      return (p_new_item != null);
      }
    }
    
/**
 * The internal worker thread.
 */

  private final class WorkerThread  extends SfcThread
    {
/**
 * Create a new sfc thread.
 * @param p_group The sfc-thread group owning this thread. This can be
 *                <code>null</code>.
 */

    public  WorkerThread (final  SfcThreadGroup p_group)
      {
      super(p_group);
      }
   
/**
 * This method is called by <code>abort()</code> to perform some work before
 * halting the thread.
 * @see #abort()
 */

    @Override
    protected void  do_abort()
      {
      AsyncEventPropagator.this.m_buffer.abort();
      super.do_abort();
      }
    
/**
 * This method must be overriden to contain the thread's code. It will be
 * executed in a loop as long as it returns <code>true</code> and throws
 * <b>no</b> <code>Throwable</code>.
 * @return  <code>true</code> if this method should be executed again.
 * @throws  Throwable Whenever it likes to, however, the execution loop
 *                    will be stopped when something is thrown.
 */

    @Override
    protected final boolean do_run  ()  throws Throwable
      {
      SfcEvent l_f;
      
      l_f = AsyncEventPropagator.this.m_buffer.dequeue();
      if(l_f != null)
        {
        AsyncEventPropagator.this.super_receive(l_f);
        return true;
        }
      
      return false;
      }
    


/**
 * Obtain the name of the thread.
 * @return  A human readable name of the sfc thread.
 */

    @Override
    public  final String  toString()
      {
      return (AsyncEventPropagator.class.getSimpleName() + ".WorkerThread");
      }
    }  
  }

File Information:

file name:AsyncEventPropagator.java
package:org.sfc.events
qualified name:org.sfc.events.AsyncEventPropagator.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/events/AsyncEventPropagator.java
size:6.989 KB (7157 B)
uploaded: 2015-07-22 04:11:11 GMT+0000
last update: 2006-07-24 06:11:17 GMT+0000
last access: 2018-01-22 00:18:56 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 2018-01-22 00:18:56 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo