Home | History | Annotate | Download | only in kernel 
      1 /*
      2  * Copyright (c) 2011 jMonkeyEngine
      3  * All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are
      7  * met:
      8  *
      9  * * Redistributions of source code must retain the above copyright
     10  *   notice, this list of conditions and the following disclaimer.
     11  *
     12  * * Redistributions in binary form must reproduce the above copyright
     13  *   notice, this list of conditions and the following disclaimer in the
     14  *   documentation and/or other materials provided with the distribution.
     15  *
     16  * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
     17  *   may be used to endorse or promote products derived from this software
     18  *   without specific prior written permission.
     19  *
     20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
     28  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     29  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     30  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 package com.jme3.network.kernel;
     34 
     35 import java.util.concurrent.ConcurrentLinkedQueue;
     36 import java.util.concurrent.LinkedBlockingQueue;
     37 import java.util.concurrent.atomic.AtomicLong;
     38 import java.util.logging.Level;
     39 import java.util.logging.Logger;
     40 
     41 /**
     42  *  Base implementation of the Kernel interface providing several
     43  *  useful default implementations of some methods.  This implementation
     44  *  assumes that the kernel will be managing its own internal threads
     45  *  and queuing any results for the caller to retrieve on their own
     46  *  thread.
     47  *
     48  *  @version   $Revision: 8843 $
     49  *  @author    Paul Speed
     50  */
     51 public abstract class AbstractKernel implements Kernel
     52 {
     53     static Logger log = Logger.getLogger(AbstractKernel.class.getName());
     54 
     55     private AtomicLong nextId = new AtomicLong(1);
     56 
     57     /**
     58      *  Contains the pending endpoint events waiting for the caller
     59      *  to retrieve them.
     60      */
     61     private ConcurrentLinkedQueue<EndpointEvent> endpointEvents = new ConcurrentLinkedQueue<EndpointEvent>();
     62 
     63     /**
     64      *  Contains the pending envelopes waiting for the caller to
     65      *  retrieve them.
     66      */
     67     private LinkedBlockingQueue<Envelope> envelopes = new LinkedBlockingQueue<Envelope>();
     68 
     69     protected AbstractKernel()
     70     {
     71     }
     72 
     73     protected void reportError( Exception e )
     74     {
     75         // Should really be queued up so the outer thread can
     76         // retrieve them.  For now we'll just log it.  FIXME
     77         log.log( Level.SEVERE, "Unhanddled kernel error", e );
     78     }
     79 
     80     protected long nextEndpointId()
     81     {
     82         return nextId.getAndIncrement();
     83     }
     84 
     85     /**
     86      *  Returns true if there are waiting envelopes.
     87      */
     88     public boolean hasEnvelopes()
     89     {
     90         return !envelopes.isEmpty();
     91     }
     92 
     93     /**
     94      *  Removes one envelope from the received messages queue or
     95      *  blocks until one is available.
     96      */
     97     public Envelope read() throws InterruptedException
     98     {
     99         return envelopes.take();
    100     }
    101 
    102     /**
    103      *  Removes and returnsn one endpoint event from the event queue or
    104      *  null if there are no endpoint events.
    105      */
    106     public EndpointEvent nextEvent()
    107     {
    108         return endpointEvents.poll();
    109     }
    110 
    111     protected void addEvent( EndpointEvent e )
    112     {
    113         endpointEvents.add( e );
    114     }
    115 
    116     protected void addEnvelope( Envelope env )
    117     {
    118         if( !envelopes.offer( env ) ) {
    119             throw new KernelException( "Critical error, could not enqueue envelope." );
    120         }
    121     }
    122 }
    123