public void printSortedPlayers(Collection<? extends Integer> playerIDs) { ArrayList<Player> sortPlayers = new ArrayList<Player>(); for (int id : playerIDs) { sortPlayers.add(players.get(id)); } Collections.sort(sortPlayers, new Player.PlayerComparator()); int nPlayers = sortPlayers.size(); for (int i = 0; i < nPlayers; i++) { Player p = sortPlayers.get(nPlayers - i - 1); System.out.printf("%4s %-16s %-16s \n", (i + 1 + "."), p, (p.getGamerScore() + " pts")); } System.out.println(); }
public void go(SystemEnvironment sysEnv) throws SDMSException { sysEnv.checkFeatureAvailability(SystemEnvironment.S_OBJECT_MONITOR); SDMSOutputContainer d_container = null; Vector desc = new Vector(); desc.add("ID"); desc.add("NAME"); desc.add("PRIVS"); d_container = new SDMSOutputContainer(sysEnv, "List of Watch Types", desc); Collections.sort(d_container.dataset, d_container.getComparator(sysEnv, 1)); result.setOutputContainer(d_container); result.setFeedback( new SDMSMessage( sysEnv, "02108241006", "$1 Watch Type(s) found", new Integer(d_container.lines))); }
public static void main(String[] args) throws IOException { Scanner scanner = new Scanner(new BufferedInputStream(System.in)); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int num; while ((num = scanner.nextInt()) != 0) { ArrayList<String> all = new ArrayList<String>(); for (int i = 0; i < num; i++) { all.add(scanner.next()); } Collections.sort(all, comptr); StringBuilder sb = new StringBuilder(""); for (String s : all) { sb.append(s); } System.out.println(sb); } }
public class IPC { /** * *************************************************************** * * <p>CLASSES AND INTERFACES NEEDED TO INTERFACE WITH IPC * * <p>************************************************************** */ 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; }; /** * *************************************************************** * * <p>IPC CONSTANTS * * <p>************************************************************** */ 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; /** * *************************************************************** * * <p>IPC API FUNCTIONS FOR JAVA * * <p>************************************************************** */ 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; } } public static int unsubscribeDisconnect(CONNECT_HANDLE_TYPE disconnectHandler) { return unsubscribeDisconnect(disconnectHandler.getClass()); } public static int subscribeHandlerChange( String msgName, CHANGE_HANDLE_TYPE handlerChangeHandler) { /* Do it this way because multiple handlers can be subscribed for same message */ List list = (List) handlerChangeHashTable.get(msgName); if (list == null) { list = new LinkedList(); handlerChangeHashTable.put(msgName, list); } list.add(0, handlerChangeHandler); if (list.size() == 1) { return IPC_subscribeHandlerChange(msgName); } else { return IPC_OK; } } public static int unsubscribeHandlerChange(String msgName, Class handlerChangeHandlerClass) { List handlerList = (List) handlerChangeHashTable.get(msgName); if (handlerList == null) { return IPC_Error; } else if (!removeFromHandlerList(handlerList, handlerChangeHandlerClass)) { System.out.println( "No change handler found for message " + msgName + " of class " + handlerChangeHandlerClass.getName()); return IPC_Error; } else if (handlerList.size() == 0) { return IPC_unsubscribeHandlerChange(msgName); } else { return IPC_OK; } } public static int unsubscribeHandlerChange( String msgName, CHANGE_HANDLE_TYPE handlerChangeHandler) { return unsubscribeHandlerChange(msgName, handlerChangeHandler.getClass()); } public static int numHandlers(String msgName) { return IPC_numHandlers(msgName); } public static int defineFormat(String formatName, String formatString) { return IPC_defineFormat(formatName, formatString); } public static int checkMsgFormats(String formatName, String formatString) { return IPC_checkMsgFormats(formatName, formatString); } public static int publishData(String msgName, Object data) { formatters.VARCONTENT varcontent = new formatters.VARCONTENT(); int retVal, marshallRet = IPC_OK; try { marshallRet = formatters.marshall(IPC_msgFormatter(msgName), coerceDataObject(data), varcontent); } catch (Exception e) { handleException("publishData", msgName, e); } if (marshallRet == IPC_Error) { return IPC_Error; } else { retVal = IPC_publish(msgName, varcontent.length, varcontent.byteArray); if (varcontent.byteArray != 0) IPC_freeByteArray(varcontent.byteArray); return retVal; } } /* Specialized versions of "publish" to handle primitive data types */ public static int publishData(String msgName, char data) { return publishData(msgName, new formatters.IPCChar(data)); } public static int publishData(String msgName, boolean data) { return publishData(msgName, new formatters.IPCBoolean(data)); } public static int publishData(String msgName, byte data) { return publishData(msgName, new formatters.IPCByte(data)); } public static int publishData(String msgName, short data) { return publishData(msgName, new formatters.IPCShort(data)); } public static int publishData(String msgName, int data) { return publishData(msgName, new formatters.IPCInteger(data)); } public static int publishData(String msgName, long data) { return publishData(msgName, new formatters.IPCLong(data)); } public static int publishData(String msgName, float data) { return publishData(msgName, new formatters.IPCFloat(data)); } public static int publishData(String msgName, double data) { return publishData(msgName, new formatters.IPCDouble(data)); } public static int respondData(MSG_INSTANCE msgInstance, String msgName, Object data) { formatters.VARCONTENT varcontent = new formatters.VARCONTENT(); int retVal, marshallRet = IPC_OK; try { marshallRet = formatters.marshall(IPC_msgFormatter(msgName), coerceDataObject(data), varcontent); } catch (Exception e) { handleException("respondData", msgName, e); } if (marshallRet == IPC_Error) { return IPC_Error; } else { retVal = IPC_respond(msgInstance.cptr, msgName, varcontent.length, varcontent.byteArray); if (varcontent.byteArray != 0) IPC_freeByteArray(varcontent.byteArray); return retVal; } } /* Specialized versions of "respond" to handle primitive data types */ public static int respondData(MSG_INSTANCE msgInstance, String msgName, char data) { return respondData(msgInstance, msgName, new formatters.IPCChar(data)); } public static int respondData(MSG_INSTANCE msgInstance, String msgName, boolean data) { return respondData(msgInstance, msgName, new formatters.IPCBoolean(data)); } public static int respondData(MSG_INSTANCE msgInstance, String msgName, byte data) { return respondData(msgInstance, msgName, new formatters.IPCByte(data)); } public static int respondData(MSG_INSTANCE msgInstance, String msgName, short data) { return respondData(msgInstance, msgName, new formatters.IPCShort(data)); } public static int respondData(MSG_INSTANCE msgInstance, String msgName, int data) { return respondData(msgInstance, msgName, new formatters.IPCInteger(data)); } public static int respondData(MSG_INSTANCE msgInstance, String msgName, long data) { return respondData(msgInstance, msgName, new formatters.IPCLong(data)); } public static int respondData(MSG_INSTANCE msgInstance, String msgName, float data) { return respondData(msgInstance, msgName, new formatters.IPCFloat(data)); } public static int respondData(MSG_INSTANCE msgInstance, String msgName, double data) { return respondData(msgInstance, msgName, new formatters.IPCDouble(data)); } public static int queryNotifyData( String msgName, Object data, HANDLER_TYPE handler, Class responseClass) { formatters.VARCONTENT varcontent = new formatters.VARCONTENT(); int retVal, marshallRet = IPC_OK; try { marshallRet = formatters.marshall(IPC_msgFormatter(msgName), coerceDataObject(data), varcontent); } catch (Exception e) { handleException("queryNotifyData", msgName, e); } if (marshallRet == IPC_Error) { return IPC_Error; } else { int handlerNum = ++handlerNumber; String hashKey = Integer.toString(handlerNum); msgHashTable.put(hashKey, new handlerHashData(handler, responseClass)); retVal = IPC_queryNotify(msgName, varcontent.length, varcontent.byteArray, handlerNum); if (varcontent.byteArray != 0) IPC_freeByteArray(varcontent.byteArray); return retVal; } } /* Specialized versions of "queryNotify" to handle primitive data types */ public static int queryNotifyData( String msgName, char data, HANDLER_TYPE handler, Class responseClass) { return queryNotifyData(msgName, new formatters.IPCChar(data), handler, responseClass); } public static int queryNotifyData( String msgName, boolean data, HANDLER_TYPE handler, Class responseClass) { return queryNotifyData(msgName, new formatters.IPCBoolean(data), handler, responseClass); } public static int queryNotifyData( String msgName, byte data, HANDLER_TYPE handler, Class responseClass) { return queryNotifyData(msgName, new formatters.IPCByte(data), handler, responseClass); } public static int queryNotifyData( String msgName, short data, HANDLER_TYPE handler, Class responseClass) { return queryNotifyData(msgName, new formatters.IPCShort(data), handler, responseClass); } public static int queryNotifyData( String msgName, int data, HANDLER_TYPE handler, Class responseClass) { return queryNotifyData(msgName, new formatters.IPCInteger(data), handler, responseClass); } public static int queryNotifyData( String msgName, long data, HANDLER_TYPE handler, Class responseClass) { return queryNotifyData(msgName, new formatters.IPCLong(data), handler, responseClass); } public static int queryNotifyData( String msgName, float data, HANDLER_TYPE handler, Class responseClass) { return queryNotifyData(msgName, new formatters.IPCFloat(data), handler, responseClass); } public static int queryNotifyData( String msgName, double data, HANDLER_TYPE handler, Class responseClass) { return queryNotifyData(msgName, new formatters.IPCDouble(data), handler, responseClass); } public static Object queryResponseData( String msgName, Object data, Class responseClass, long timeoutMSecs) { formatters.VARCONTENT varcontent = new formatters.VARCONTENT(); Object responseObject = null; int retVal; try { if (formatters.marshall(IPC_msgFormatter(msgName), coerceDataObject(data), varcontent) != IPC_Error) { queryResponse response = new queryResponse(); retVal = IPC_queryResponse( msgName, varcontent.length, varcontent.byteArray, response, timeoutMSecs); if (varcontent.byteArray != 0) IPC_freeByteArray(varcontent.byteArray); if (retVal == IPC_OK && varcontent.byteArray != 0) { responseObject = unmarshallMsgData(response.formatter, response.byteArray, responseClass); } } } catch (Exception e) { handleException("queryResponseData", msgName, e); } return responseObject; } /* Specialized versions of "queryResponse" to handle primitive data types */ public static Object queryResponseData( String msgName, char data, Class responseClass, long timeOutMSecs) { return queryResponseData(msgName, new formatters.IPCChar(data), responseClass, timeOutMSecs); } public static Object queryResponseData( String msgName, boolean data, Class responseClass, long timeOutMSecs) { return queryResponseData(msgName, new formatters.IPCBoolean(data), responseClass, timeOutMSecs); } public static Object queryResponseData( String msgName, byte data, Class responseClass, long timeOutMSecs) { return queryResponseData(msgName, new formatters.IPCByte(data), responseClass, timeOutMSecs); } public static Object queryResponseData( String msgName, short data, Class responseClass, long timeOutMSecs) { return queryResponseData(msgName, new formatters.IPCShort(data), responseClass, timeOutMSecs); } public static Object queryResponseData( String msgName, int data, Class responseClass, long timeOutMSecs) { return queryResponseData(msgName, new formatters.IPCInteger(data), responseClass, timeOutMSecs); } public static Object queryResponseData( String msgName, long data, Class responseClass, long timeOutMSecs) { return queryResponseData(msgName, new formatters.IPCLong(data), responseClass, timeOutMSecs); } public static Object queryResponseData( String msgName, float data, Class responseClass, long timeOutMSecs) { return queryResponseData(msgName, new formatters.IPCFloat(data), responseClass, timeOutMSecs); } public static Object queryResponseData( String msgName, double data, Class responseClass, long timeOutMSecs) { return queryResponseData(msgName, new formatters.IPCDouble(data), responseClass, timeOutMSecs); } public static IPC_CONTEXT getContext() { return new IPC_CONTEXT(IPC_getContext()); } public static int setContext(IPC_CONTEXT context) { return IPC_setContext(context.cptr); } public static long getPID() { return IPC_getPID(); } public static int addTimer(long tdelay, long count, TIMER_HANDLER_TYPE handler) { int handlerNum = ++handlerNumber; String hashKey = Integer.toString(handlerNum); timerHashTable.put(handler.getClass().getName(), hashKey); timerHashTable.put(hashKey, handler); return IPC_addTimer(tdelay, count, handlerNum); } public static int addTimerGetRef( long tdelay, long count, TIMER_HANDLER_TYPE handler, TIMER_REF timerRef) { int refVal, handlerNum = ++handlerNumber; String hashKey = Integer.toString(handlerNum); timerHashTable.put(hashKey, handler); refVal = IPC_addTimerGetRef(tdelay, count, handlerNum); if (refVal == 0) { return IPC_Error; } 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(); } /** * *************************************************************** * * <p>INTERNAL FUNCTIONS * * <p>************************************************************** */ private static native int IPC_initialize(); private static native int IPC_connectModule(String moduleName, String serverName); private static native int IPC_connect(String moduleName); private static native int IPC_disconnect(); private static native boolean IPC_isConnected(); private static native boolean IPC_isModuleConnected(String moduleName); private static native int IPC_defineMsg(String msgName, String formatString); private static native boolean IPC_isMsgDefined(String msgName); private static native int IPC_dataLength(int msgInstance); private static native String IPC_msgInstanceName(int msgInstance); private static native int IPC_msgInstanceFormatter(int msgInstance); private static native int IPC_subscribe(String msgName, String handlerName, int handlerNum); private static native int IPC_unsubscribe(String msgName, String handlerName); private static native int IPC_subscribeFD(int fd); private static native int IPC_unsubscribeFD(int fd); private static native int IPC_publish(String msgName, int length, int byteArray); private static native int IPC_listen(long timeoutMSecs); private static native int IPC_listenClear(long timeoutMSecs); private static native int IPC_listenWait(long timeoutMSecs); private static native int IPC_handleMessage(long timeoutMSecs); private static native int IPC_dispatch(); private static native void IPC_perror(String msg); private static native int IPC_setCapacity(int capacity); private static native int IPC_setMsgQueueLength(String msgName, int queueLength); private static native int IPC_setMsgPriority(String msgName, int priority); private static native int IPC_setVerbosity(int verbosity); private static native int IPC_subscribeConnect(); private static native int IPC_subscribeDisconnect(); private static native int IPC_unsubscribeConnect(); private static native int IPC_unsubscribeDisconnect(); private static native int IPC_subscribeHandlerChange(String msgName); private static native int IPC_unsubscribeHandlerChange(String msgName); private static native int IPC_numHandlers(String msgName); private static native int IPC_respond(int msgInstance, String msgName, int length, int byteArray); private static native int IPC_queryNotify( String msgName, int length, int byteArray, int handlerNum); private static native int IPC_queryResponse( String msgName, int length, int byteArray, queryResponse response, long timeoutMSecs); private static native int IPC_defineFormat(String formatName, String formatString); private static native int IPC_checkMsgFormats(String formatName, String formatString); private static native int IPC_getContext(); private static native int IPC_setContext(int context); private static native long IPC_getPID(); private static native void IPC_freeByteArray(int byteArray); private static native int IPC_msgFormatter(String msgName); private static native int IPC_addTimer(long tdelay, long count, int handlerNum); private static native int IPC_addTimerGetRef(long tdelay, long count, int handlerNum); private static native int IPC_removeTimer(int handlerNum); private static native int IPC_removeTimerByRef(int timerRef); private static native 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"); } }
public static void main(String[] args) throws IOException { BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); String line = null; while ((line = reader.readLine()) != null) { StringTokenizer token = new StringTokenizer(line); int n = Integer.parseInt(token.nextToken()); int m = Integer.parseInt(token.nextToken()); if (n == 0 && m == 0) { break; } for (int i = 0; i < n; i++) { parentRank[i][0] = i; parentRank[i][1] = 0; } edgeList.clear(); for (int i = 0; i < m; i++) { token = new StringTokenizer(reader.readLine()); int x = Integer.parseInt(token.nextToken()); int y = Integer.parseInt(token.nextToken()); int w = Integer.parseInt(token.nextToken()); edgeList.add(new Edge(x, y, w)); } List<Integer> maxWeights = new ArrayList<Integer>(); Collections.sort(edgeList); int maxWeight = 0; for (int i = 0; i < edgeList.size(); i++) { Edge edge = edgeList.get(i); int x = find(edge.a); int y = find(edge.b); if (x != y) { maxWeight = Math.max(maxWeight, edge.weight); union(x, y); } else { maxWeights.add(Math.max(maxWeight, edge.weight)); } } if (maxWeights.size() > 0) { for (int i = 0; i < maxWeights.size(); i++) { if (i + 1 != maxWeights.size()) { System.out.print(maxWeights.get(i) + " "); } else { System.out.print(maxWeights.get(i)); } } System.out.println(); } else { System.out.println("forest"); } } }
public void go(SystemEnvironment sysEnv) throws SDMSException { Long sgId = null; Long ZERO = new Long(0); if (!sysEnv.cEnv.gid().contains(SDMSObject.adminGId)) { SDMSPrivilege p = new SDMSPrivilege(); Vector v = SDMSMemberTable.idx_uId.getVector(sysEnv, sysEnv.cEnv.uid()); for (int i = 0; i < v.size(); i++) { SDMSMember m = (SDMSMember) v.get(i); try { SDMSGrant gr = SDMSGrantTable.idx_objectId_gId_getUnique( sysEnv, new SDMSKey(ZERO, m.getGId(sysEnv))); p.addPriv(sysEnv, gr.getPrivs(sysEnv).longValue()); } catch (NotFoundException nfe) { } } try { if (sysEnv.selectGroup != null) { SDMSGroup sg = SDMSGroupTable.idx_name_getUnique(sysEnv, sysEnv.selectGroup); sgId = sg.getId(sysEnv); } } catch (NotFoundException nfe) { } if (!(p.can(SDMSPrivilege.MANAGE_SEL) || (sgId != null && sysEnv.cEnv.gid().contains(sgId)))) throw new AccessViolationException( new SDMSMessage(sysEnv, "03003081235", "Insufficient Privileges")); } int read = 0; SDMSOutputContainer d_container = null; if (cl_size > 0) { clist = new int[cl_size]; ctype = new int[cl_size]; } try { Statement stmt = sysEnv.dbConnection.createStatement(); ResultSet rset = stmt.executeQuery(selectCmd); ResultSetMetaData mdset = rset.getMetaData(); Vector desc = collist(mdset); d_container = new SDMSOutputContainer(sysEnv, "Selected Values", desc); while (rset.next()) { Vector data = new Vector(); int j = 0; for (int i = 1; i <= desc.size(); i++) { Object o = rset.getObject(i); if (cl_size > 0 && j < cl_size && i == clist[j]) { o = convert(sysEnv, o, j); j++; } data.addElement((rset.wasNull() ? null : o)); } d_container.addData(sysEnv, data); read++; } stmt.close(); sysEnv.dbConnection.commit(); } catch (SQLException sqle) { try { sysEnv.dbConnection.rollback(); } catch (SQLException sqle2) { throw new RecoverableException(new SDMSMessage(sysEnv, "03310281524", "Connection lost")); } throw new CommonErrorException( new SDMSMessage(sysEnv, "03204170024", "SQL Error : $1", sqle.toString())); } if (sv != null && sv.size() > 0) { int sca[] = new int[sv.size()]; for (int i = 0; i < sv.size(); i++) { sca[i] = ((Integer) sv.get(i)).intValue(); if (sca[i] >= d_container.columns) throw new CommonErrorException( new SDMSMessage( sysEnv, "03003081227", "The sort column specified ($1) exceeds the number of columns in the output", new Integer(sca[i]))); } Collections.sort(d_container.dataset, d_container.getComparator(sysEnv, sca)); } result.setOutputContainer(d_container); result.setFeedback( new SDMSMessage(sysEnv, "03204112153", "$1 Row(s) selected", new Integer(read))); }