/***************************************************************************** *       $Id: IPC.java,v 1.3 2006/01/23 21:43:19 nickr Exp $ * $Revision: 1.3 $ *     $Date: 2006/01/23 21:43:19 $ *   $Author: nickr $ *    $State: Exp $ *   $Locker:  $ * * PROJECT:	NM-DS1 * * FILE:		IPC.java * * DESCRIPTION: JAVA class for IPC. * * IPC.java contains the JNI connection to IPC to enable publishing and * subscribing to IPC messages.  An instance of IPC establishes a * JNI object for communicating over IPC.  Each JAVA program should have * only one IPC object -- if you need to connect to multiple servers, * you can call IPC_connect multiple times (don't forget to do IPC_getContext * after each connection, so that you can switch back and forth between  * servers). * * HISTORY: Based on version by Carroll Thronesbery, Metrica (Sept 2000) * * $Log: IPC.java,v $ * Revision 1.3  2006/01/23 21:43:19  nickr * Updated to match new carmen message formats. * * Revision 1.2  2005/12/12 23:52:26  nickr * Made message classes inherit * * Revision 1.1  2005/08/31 20:33:47  nickr * *** empty log message *** * * Revision 1.1  2005/08/31 20:25:31  nickr * Initial check-in of java class libraries * * Revision 1.3  2002/01/11 22:35:23  reids * Improved error handling for Java version * * Revision 1.2  2002/01/02 21:10:59  reids * Made functions stand alone (no longer throw exceptions -- but catch *  the exceptions, print out the problem, and return appropriate error code). * * Revision 1.1  2002/01/02 17:40:16  reids * Initial (and more, or less, complete) release of Java version of IPC. * * *****************************************************************************/package IPC;import java.lang.*;import java.util.*;import java.io.*;import LDLoad.*;public class IPC {  /*****************************************************************   *   *    CLASSES AND INTERFACES NEEDED TO INTERFACE WITH IPC   *   ****************************************************************/  public static class MSG_INSTANCE {    MSG_INSTANCE(int theCptr) { cptr = theCptr; }    int cptr;  };  public static class IPC_CONTEXT {    IPC_CONTEXT(int theCptr) { cptr = theCptr; }    int cptr;  };  public interface HANDLER_TYPE {    void handle (MSG_INSTANCE msgInstance, Object callData);  }  public interface FD_HANDLER_TYPE {    void handle (int fd);  }  public interface CONNECT_HANDLE_TYPE {    void handle (String moduleName);  }  public interface CHANGE_HANDLE_TYPE {    void handle (String msgName, int numHandlers);  }  public interface TIMER_HANDLER_TYPE {    void handle (long currentTime, long scheduledTime);  }  public static class TIMER_REF {    public TIMER_REF() {}    int cptr;  };  /*****************************************************************   *   *    IPC CONSTANTS   *   ****************************************************************/  public static final long IPC_WAIT_FOREVER = 0xFFFFFFFF;  public static final long TRIGGER_FOREVER = -1;  /* IPC_RETURN_TYPE */  public static final int IPC_Error   = 0;  public static final int IPC_OK      = 1;  public static final int IPC_Timeout = 2;  /* IPC_ERROR_TYPE */  public static final int IPC_No_Error               = 0;  public static final int IPC_Not_Connected          = 1;  public static final int IPC_Not_Initialized        = 2;  public static final int IPC_Message_Not_Defined    = 3;  public static final int IPC_Not_Fixed_Length       = 4;  public static final int IPC_Message_Lengths_Differ = 5;  public static final int IPC_Argument_Out_Of_Range  = 6;  public static final int IPC_Null_Argument          = 7;  public static final int IPC_Illegal_Formatter      = 8;  public static final int IPC_Mismatched_Formatter   = 9;  public static final int IPC_Wrong_Buffer_Length    = 10;  public static final int IPC_Communication_Error    = 11;  /* IPC_VERBOSITY_TYPE */  public static final int IPC_Silent         = 0;  public static final int IPC_Print_Warnings = 1;  public static final int IPC_Print_Errors   = 2;  public static final int IPC_Exit_On_Errors = 3;    /*****************************************************************   *   *    IPC API FUNCTIONS FOR JAVA   *   ****************************************************************/  public static int initialize () { return IPC_initialize(); }  public static int connectModule (String moduleName, String serverName) {    return IPC_connectModule(moduleName, serverName);  }  public static int connect (String moduleName) {      return IPC_connect(moduleName);  }  public static int disconnect () { return IPC_disconnect(); }  public static boolean isConnected () { return IPC_isConnected(); }  public static boolean isModuleConnected (String moduleName) {    return IPC_isModuleConnected(moduleName);  }  public static int defineMsg (String msgName, String formatString) {    return IPC_defineMsg(msgName, formatString);  }  public static boolean isMsgDefined (String msgName) {    return IPC_isMsgDefined(msgName);  }  public static String msgInstanceName (MSG_INSTANCE msgInstance) {    return IPC_msgInstanceName(msgInstance.cptr);  }  public static int subscribeData (String msgName, HANDLER_TYPE msgHandler,				   Class dataClass) {     /* Do it this way because multiple handlers can be subscribed        for the same message */    String handlerName = msgName + msgHandler.getClass().getName();    int handlerNum = ++handlerNumber;    String hashKey = Integer.toString(handlerNum);    msgHashTable.put(handlerName, hashKey);    msgHashTable.put(hashKey, new handlerHashData(msgHandler, dataClass));    return IPC_subscribe(msgName, handlerName, handlerNum);  }  public static int unsubscribe (String msgName, Class msgHandlerClass) {     /* Do it this way because multiple handlers can be subscribed for the       same message */    String handlerName = msgName + msgHandlerClass.getName();    String hashKey = (String)msgHashTable.get(handlerName);    msgHashTable.remove(handlerName);    msgHashTable.remove(hashKey);    return IPC_unsubscribe(msgName, handlerName);  }  public static int unsubscribe (String msgName, HANDLER_TYPE msgHandler) {     return unsubscribe(msgName, msgHandler.getClass());  }  public static int subscribeFD (int fd, FD_HANDLER_TYPE fdHandler) {     /* Note: This is simplified since at most one handler can be subscribed        for each file descriptor */    fdHashTable.put(Integer.toString(fd), fdHandler);    return IPC_subscribeFD(fd);  }  public static int unsubscribeFD (int fd) {     fdHashTable.remove(Integer.toString(fd));    return IPC_unsubscribeFD(fd);  }  public static int listen (long timeoutMSecs) {    return IPC_listen(timeoutMSecs);  }  public static int listenClear (long timeoutMSecs) {    return IPC_listenClear(timeoutMSecs);  }  public static int listenWait (long timeoutMSecs) {    return IPC_listenWait(timeoutMSecs);  }  public static int handleMessage (long timeoutMSecs) {    return IPC_handleMessage(timeoutMSecs);  }  public static int dispatch () { return IPC_dispatch(); }  public static int dataLength (MSG_INSTANCE msgInstance) {    return IPC_dataLength(msgInstance.cptr);  }  public static void perror (String msg) { IPC_perror(msg); }  public static int setCapacity (int capacity) {       return IPC_setCapacity(capacity);  }  public static int setMsgQueueLength (String msgName, int queueLength) {    return IPC_setMsgQueueLength(msgName, queueLength);  }  public static int setMsgPriority (String msgName, int priority) {    return IPC_setMsgPriority(msgName, priority);  }  public static int setVerbosity (int verbosity) {    return IPC_setVerbosity(verbosity);  }  public static int subscribeConnect (CONNECT_HANDLE_TYPE connectHandler) {    /* Do it this way because multiple handlers can be subscribed  */    connectHandlers.add(0, connectHandler);    if (connectHandlers.size() == 1) {	return IPC_subscribeConnect();    } else {	return IPC_OK;    }  }  public static int subscribeDisconnect (CONNECT_HANDLE_TYPE disconnectHandler){    /* Do it this way because multiple handlers can be subscribed  */    disconnectHandlers.add(0, disconnectHandler);    if (disconnectHandlers.size() == 1) {	return IPC_subscribeDisconnect();    } else {	return IPC_OK;    }  }  private static boolean removeFromHandlerList (List list, Class handlerClass) {    boolean found = false;    Iterator iter = list.iterator();    /* Do it this way because multiple handlers can be subscribed  */    while (iter.hasNext() && !found) {      found = (iter.next().getClass() == handlerClass);      if (found) iter.remove();    }    return found;  }  public static int unsubscribeConnect (Class connectHandlerClass) {    if (!removeFromHandlerList(connectHandlers, connectHandlerClass)) {	System.out.println("No connection handler found of class "+			   connectHandlerClass.getName());	return IPC_Error;    } else if (connectHandlers.size() == 0) {	return IPC_unsubscribeConnect();    } else {	return IPC_OK;    }  }  public static int unsubscribeConnect (CONNECT_HANDLE_TYPE connectHandler) {    return unsubscribeConnect(connectHandler.getClass());  }  public static int unsubscribeDisconnect (Class disconnectHandlerClass) {    if (!removeFromHandlerList(disconnectHandlers, disconnectHandlerClass)) {	System.out.println("No disconnection handler found of class "+			   disconnectHandlerClass.getName());	return IPC_Error;    } else if (disconnectHandlers.size() == 0) {	return IPC_unsubscribeDisconnect();    } else {	return IPC_OK;    }  }