} else {	timerHashTable.put(Integer.toString(refVal), hashKey);      timerRef.cptr = refVal;      return IPC_OK;    }  }  public static int addOneShotTimer (long tdelay, TIMER_HANDLER_TYPE handler) {    return IPC.addTimer(tdelay, 1, handler);  }  public static int addPeriodicTimer (long tdelay,				      TIMER_HANDLER_TYPE handler) {    return IPC.addTimer(tdelay, TRIGGER_FOREVER, handler);  }  public static int removeTimer (Class handlerClass) {    String hashKey = handlerClass.getName();    String handlerNum = (String)timerHashTable.get(hashKey);    timerHashTable.remove(hashKey);    timerHashTable.remove(handlerNum);    return IPC_removeTimer(Integer.parseInt(handlerNum));  }  public static int removeTimer (TIMER_HANDLER_TYPE handler) {    return removeTimer(handler.getClass());  }  public static int removeTimerByRef (TIMER_REF timerRef) {    String hashKey = Integer.toString(timerRef.cptr);    String handlerNum = (String)timerHashTable.get(hashKey);    timerHashTable.remove(hashKey);    timerHashTable.remove(handlerNum);    return IPC_removeTimerByRef(timerRef.cptr);  }  public static long timeInMillis () {    return IPC_timeInMillis();  }  /*****************************************************************   *   *    INTERNAL FUNCTIONS   *   ****************************************************************/  private native static int IPC_initialize();  private native static int IPC_connectModule(String moduleName,					      String serverName);  private native static int IPC_connect(String moduleName);  private native static int IPC_disconnect();  private native static boolean IPC_isConnected();  private native static boolean IPC_isModuleConnected(String moduleName);  private native static int IPC_defineMsg(String msgName, String formatString);  private native static boolean IPC_isMsgDefined(String msgName);  private native static int IPC_dataLength (int msgInstance);  private native static String IPC_msgInstanceName (int msgInstance);  private native static int IPC_msgInstanceFormatter (int msgInstance);  private native static int IPC_subscribe(String msgName, String handlerName,					  int handlerNum);  private native static int IPC_unsubscribe(String msgName, String handlerName);  private native static int IPC_subscribeFD(int fd);  private native static int IPC_unsubscribeFD(int fd);  private native static int IPC_publish (String msgName, 					 int length, int byteArray);  private native static int IPC_listen(long timeoutMSecs);  private native static int IPC_listenClear(long timeoutMSecs);  private native static int IPC_listenWait(long timeoutMSecs);  private native static int IPC_handleMessage(long timeoutMSecs);  private native static int IPC_dispatch();  private native static void IPC_perror(String msg);  private native static int IPC_setCapacity (int capacity);  private native static int IPC_setMsgQueueLength (String msgName, 						   int queueLength);  private native static int IPC_setMsgPriority (String msgName, int priority);  private native static int IPC_setVerbosity (int verbosity);  private native static int IPC_subscribeConnect ();  private native static int IPC_subscribeDisconnect ();  private native static int IPC_unsubscribeConnect ();  private native static int IPC_unsubscribeDisconnect ();  private native static int IPC_subscribeHandlerChange (String msgName);  private native static int IPC_unsubscribeHandlerChange (String msgName);  private native static int IPC_numHandlers (String msgName);   private native static int IPC_respond (int msgInstance, String msgName,					 int length, int byteArray);  private native static int IPC_queryNotify (String msgName,					     int length, int byteArray,					     int handlerNum);  private native static int IPC_queryResponse (String msgName,					       int length, int byteArray,					       queryResponse response,					       long timeoutMSecs);  private native static int IPC_defineFormat (String formatName,					      String formatString);  private native static int IPC_checkMsgFormats (String formatName,						 String formatString);  private native static int IPC_getContext ();   private native static int IPC_setContext (int context);  private native static long IPC_getPID();  private native static void IPC_freeByteArray(int byteArray);  private native static int IPC_msgFormatter(String msgName);  private native static int IPC_addTimer(long tdelay, long count, 					 int handlerNum);  private native static int IPC_addTimerGetRef(long tdelay, long count, 					       int handlerNum);  private native static int IPC_removeTimer(int handlerNum);  private native static int IPC_removeTimerByRef(int timerRef);  private native static long IPC_timeInMillis();  private static Map msgHashTable = Collections.synchronizedMap(new HashMap());  private static List connectHandlers =      Collections.synchronizedList(new ArrayList());  private static List disconnectHandlers =       Collections.synchronizedList(new ArrayList());  private static Map handlerChangeHashTable =      Collections.synchronizedMap(new HashMap());  private static Map fdHashTable = Collections.synchronizedMap(new HashMap());  private static Map timerHashTable =      Collections.synchronizedMap(new HashMap());  private static int handlerNumber = 0;  private static class queryResponse {    int byteArray;    int formatter;  }  private static class handlerHashData {    handlerHashData (HANDLER_TYPE msgHandler, Class theClass) {      handler = msgHandler; dataClass = theClass; }    HANDLER_TYPE handler;    Class dataClass;  }  // Change primitive types into types that IPC can handle (same with  //  the JAVA object versions of those types).  private static Class coerceDataClass (Class dataClass) {    if (dataClass == int.class || dataClass == Integer.class) {      return formatters.IPCInteger.class;    } else if (dataClass == double.class || dataClass == Double.class) {      return formatters.IPCDouble.class;    } else if (dataClass == String.class) {      return formatters.IPCString.class;    } else if (dataClass == float.class || dataClass == Float.class) {      return formatters.IPCFloat.class;    } else if (dataClass == short.class || dataClass == Short.class) {      return formatters.IPCShort.class;    } else if (dataClass == long.class || dataClass == Long.class) {      return formatters.IPCLong.class;    } else if (dataClass == char.class) {      return formatters.IPCChar.class;    } else if (dataClass == boolean.class || dataClass == Boolean.class) {      return formatters.IPCBoolean.class;    } else if (dataClass == byte.class || dataClass == Byte.class) {      return formatters.IPCByte.class;    } else {      return dataClass;    }  }  // Change Java types that "objectize" primitives (plus String)  //   to types that IPC can handle.  private static Object coerceDataObject (Object dataObject) {    Class dataClass = dataObject.getClass();    if (formatters.IPCPrim.class.isAssignableFrom(dataClass)) {      return dataObject;    } else if (dataClass == Integer.class) {      return new formatters.IPCInteger(((Integer)dataObject).intValue());    } else if (dataClass == Double.class) {      return new formatters.IPCDouble(((Double)dataObject).intValue());    } else if (dataClass == String.class) {      return new formatters.IPCString((String)dataObject);    } else if (dataClass == Float.class) {      return new formatters.IPCFloat(((Float)dataObject).floatValue());    } else if (dataClass == Short.class) {      return new formatters.IPCShort(((Short)dataObject).shortValue());    } else if (dataClass == Long.class) {      return new formatters.IPCLong(((Long)dataObject).longValue());    } else if (dataClass == Boolean.class) {      return new formatters.IPCBoolean(((Boolean)dataObject).booleanValue());    } else if (dataClass == Byte.class) {      return new formatters.IPCByte(((Byte)dataObject).byteValue());    } else {      return dataObject;    }  }  private static Object unmarshallMsgData (int formatter, int byteArray,					   Class msgDataClass)       throws Exception {    Object object = null;    // Throw an exception if class does not match formatter    formatters.checkDataClass(formatter, msgDataClass);    if (msgDataClass.isArray()) {      // Create a top-level fixed-length array, based on the formatter.      object = formatters.createFixedArray(msgDataClass.getComponentType(),					   formatter);    } else {      // Create an object type that Java IPC can handle      object = coerceDataClass(msgDataClass).newInstance();    }    formatters.unmarshall(formatter, byteArray, object);    IPC_freeByteArray(byteArray);    if (formatters.IPCPrim.class.isAssignableFrom(object.getClass())) {	object = ((formatters.IPCPrim)object).coerce();    }    return object;  }  private static void msgCallbackHandler (int handlerNum, int msgInstance,					  int byteArray) {    handlerHashData handlerData = 	(handlerHashData)msgHashTable.get(Integer.toString(handlerNum));    if (handlerData != null) {      Object object;      try {	  int formatter = IPC_msgInstanceFormatter(msgInstance);	  object = unmarshallMsgData(formatter, byteArray,				     handlerData.dataClass);	  handlerData.handler.handle(new MSG_INSTANCE(msgInstance), object);      } catch ( Exception e) {	  handleException("msgCallbackHandler", 			  IPC_msgInstanceName(msgInstance), e);      }    } else      System.out.println("Ooops -- no handler for "+			 IPC_msgInstanceName(msgInstance));  }  private static void queryNotifyCallbackHandler (int handlerNum,						  int msgInstance,						  int byteArray) {    String hashKey = Integer.toString(handlerNum);    handlerHashData handlerData = (handlerHashData)msgHashTable.get(hashKey);    msgHashTable.remove(hashKey);    if (handlerData != null) {      Object object;      try {	object = unmarshallMsgData(IPC_msgInstanceFormatter(msgInstance),				   byteArray, handlerData.dataClass);	handlerData.handler.handle(new MSG_INSTANCE(msgInstance), object);      } catch ( Exception e) { 	handleException("queryNotifyCallbackHandler", 			IPC_msgInstanceName(msgInstance), e);      }    } else      System.out.println("Ooops -- no query notification handler for "+			 IPC_msgInstanceName(msgInstance));  }  private static void fdCallbackHandler (int fd) {    FD_HANDLER_TYPE handler =      (FD_HANDLER_TYPE)fdHashTable.get(Integer.toString(fd));    if (handler != null) {      handler.handle(fd);    } else      System.out.println("Ooops -- no handler for fd");  }  private static void timerCallbackHandler (int handlerNum, long currentTime,					    long scheduledTime) {    TIMER_HANDLER_TYPE handler =      (TIMER_HANDLER_TYPE)timerHashTable.get(Integer.toString(handlerNum));    if (handler != null) {      handler.handle(currentTime, scheduledTime);    } else      System.out.println("Ooops -- no handler for timer");  }  private static void connectCallbackHandler (String moduleName,					      boolean isConnect) {    Iterator iter = (isConnect ? connectHandlers.iterator()		     : disconnectHandlers.iterator());    while (iter.hasNext()) {      CONNECT_HANDLE_TYPE handler = (CONNECT_HANDLE_TYPE)iter.next();      handler.handle(moduleName);    }  }  private static void changeCallbackHandler (String msgName, int numHandlers) {    List handlerList = (List)handlerChangeHashTable.get(msgName);    if (handlerList == null) {      System.out.println("Ooops -- no change handlers for message "+msgName);      return;    }    Iterator iter = handlerList.iterator();    while (iter.hasNext()) {      ((CHANGE_HANDLE_TYPE)iter.next()).handle(msgName, numHandlers);    }  }  private static void handleException(String where, String msgName, 				      Exception e) {    System.err.println("ERROR: "+ where +": For message \""+msgName +"\": "+ 		       e.getMessage());    e.printStackTrace();  }  static {    LDLoad.loadFromJar("Carmen.jar", "libipcjava.so");  }}