abstractreceiverparser.java

SRI international 发布的OAA框架软件

package com.sri.oaa2.simplefac;

import com.sri.oaa2.icl.*;

import edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue;

import java.io.*;
import org.apache.log4j.Logger;

public abstract class AbstractReceiverParser implements Runnable
{
   // Logger
  static Logger logger = Logger.getLogger(AbstractReceiverParser.class.getName());

  boolean connected = true;
  SimpleFacConnection conn;
  ArrayBlockingQueue termSlot = new ArrayBlockingQueue(1);
  // This is an invalid variable
  static IclTerm nullTerm = new IclVar("___________________null");
    Throwable closeException;

  protected void setConn(SimpleFacConnection c)
  {
    conn = c;
  }

  protected SimpleFacConnection getConn()
  {
    return conn;
  }

  /**
   * Check if disconnect has been requested
   */
  public synchronized boolean isConnected()
  {
    if(logger.isDebugEnabled()) {
      logger.debug("AbstractReceiverParser disconnecting: " + termSlot.peek());
    }
    return connected;
  }

  /**
   * Request disconnect
   */
  public synchronized void disconnect()
  {
    if(logger.isInfoEnabled()) {
      RuntimeException re = new RuntimeException();
      re.fillInStackTrace();
      StringWriter sw = new StringWriter();
      PrintWriter pw = new PrintWriter(sw);
      re.printStackTrace(pw);
      pw.flush();
      logger.info("AbstractReceiverParser.disconnect() called; stack trace: " + sw.toString());
    }
    connected = false;
  }

  /**
   * Set next term to return
   */
  public void setTerm(IclTerm t)
  {
    //Logger logger = Logger.getLogger("com.sri.oaa2.simplefac.arp");

    try {
      if(t == null) {
        t = nullTerm;
      }

      if(logger.isDebugEnabled()) {
        logger.debug("AbstractReceiverParser trying to set term with slot at: " + termSlot.peek());
      }
      termSlot.put(t);
      if(logger.isDebugEnabled()) {
        logger.debug("AbstractReceiverParser set term");
      }
    }
    catch(InterruptedException ie) {
      if(logger.isDebugEnabled()) {
        logger.debug("AbstractReceiverParser::setTerm() disconnect on InterruptedException");
      }
      closeException = ie;
      disconnect();
      return;
    }
  }

  /**
   * Return last term.
   */
  public IclTerm getTerm()
  {
    IclTerm toRet = null;
    try {
      toRet = (IclTerm)termSlot.take();
      if(toRet == nullTerm) {
        return null;
      }
    }
    catch(InterruptedException ie) {
      StringWriter sw = new StringWriter();
      PrintWriter pw = new PrintWriter(sw);
      ie.printStackTrace(pw);
      pw.flush();
      logger.error("AbstractReceiverParser.getTerm() interrupted: " + sw.toString());
      closeException = ie;
      disconnect();
      return null;
    }
    return toRet;
  }

  /**
   * Check if there is a term available
   */
  public boolean hasTerm()
  {
    if(termSlot.peek() != null) {
      return true;
    }
    else {
      return false;
    }
  }

  public abstract void run();
}