icltermobjectreceiver.java

SRI international 发布的OAA框架软件

package com.sri.oaa2.simplefac;

import com.sri.oaa2.icl.*;
import java.net.*;
import java.io.*;
import org.apache.log4j.Logger;

public class IclTermObjectReceiver implements IclTermReceiver
{
  // Socket connected to client agent
  private Socket clientSocket = null;

  // ObjectInputSteram associated with socket
  private ObjectInputStream clientReader = null;

  // Are we connected?
  private boolean connected = true;

  // The object that does the work
  ObjectReceiverParser parser;

  // Connection
  SimpleFacConnection conn;

  Throwable closeException;

  /**
   * Construct with the given socket
   */
  public IclTermObjectReceiver(Socket s, SimpleFacConnection c)
  {
    connected = true;
    setSocket(s);
    setConn(c);
    try {
      clientReader = new ObjectInputStream(clientSocket.getInputStream());
    }
    catch(IOException ioe) {
      throw new RuntimeException("IclTermObjectReceiver could not create BufferedReader: " + ioe.toString());
    }
    parser = new ObjectReceiverParser(clientReader);
    Thread t = new Thread(parser);
    StringBuffer b = new StringBuffer();
    b.append("ObjectReceiverParser:");
    b.append(getConn().getId().toString());
    t.setName(b.toString());
   t.start();
  }

  protected void setSocket(Socket s)
  {
    clientSocket = s;
  }

  protected Socket getSocket()
  {
    return clientSocket;
  }

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

  protected SimpleFacConnection getConn()
  {
    return conn;
  }

  /**
   * Disconnect request
   */
  public synchronized void disconnect()
  {
    connected = false;
  }

  /**
   * Check if disconnect requested
   */
  public synchronized boolean isConnected()
  {
    return connected;
  }

    public Throwable getCloseException() {
        return closeException;
    }

    /**
   * Get next term; may return null if not connected
   */
  public IclTerm getNextTerm()
  {
    IclTerm t = parser.getTerm();
    if(!parser.isConnected()) {
      disconnect();
      return null;
    }
    return t;
  }

  /**
   * Check if there is a next term
   */
  public boolean haveNextTerm()
  {
    return parser.hasTerm();
  }
}

/**
 * Class to parse incoming string IclTerms
 */
class ObjectReceiverParser extends AbstractReceiverParser
{
  // Logger
  static Logger logger = Logger.getLogger(ObjectReceiverParser.class.getName());

  ObjectInputStream reader;

  /**
   * Construct using given reader.
   */
  public ObjectReceiverParser(ObjectInputStream r)
  {
    reader = r;
  }

  /**
   * Keep trying to parse the reader, as long as we are connected
   */
  public void run()
  {
    GETTING_TERMS:
    while(true) {
      if(!isConnected()) {
        try {
          reader.close();
        }
        catch(IOException ioe) {
          throw new RuntimeException("ObjectReceiverParser could not close reader");
        }

        return;
      }
      try {
        setTerm((IclTerm)reader.readObject());
      }
      catch(InterruptedIOException iioe) {
        continue GETTING_TERMS;
      }
      catch(OptionalDataException ode) {
        String errMessage = "ObjectReceiverParser got primitive data";
        logger.error(errMessage);
        closeException = new Exception(errMessage);
        disconnect();
      }
      catch(IOException ioe) {
        closeException = ioe;
        disconnect();
        if(logger.isInfoEnabled()) {
          logger.info("ObjectReceiverParser got IOException: " +
                      ioe.toString() +
                      "; closing stream");
        }
        setTerm(null);
        return;
      }
      catch(Exception e) {
        throw new RuntimeException(e.toString());
      }
    }
  }
}