private void fixNullOutputsForSOAP(CrownCounselIndexGetList_Properties fromClient) {
   // Transform null to "null"
   Class c = fromClient.getClass();
   java.beans.BeanInfo beanInfo = null;
   try {
     beanInfo = java.beans.Introspector.getBeanInfo(c);
   } catch (Exception e) {
   }
   java.beans.PropertyDescriptor[] properties = beanInfo.getPropertyDescriptors();
   for (int i = 0; i < properties.length; i++) {
     java.beans.PropertyDescriptor property = properties[i];
     java.lang.reflect.Method readMethod = property.getReadMethod();
     java.lang.reflect.Method writeMethod = property.getWriteMethod();
     if ((readMethod != null) && (writeMethod != null)) {
       String currentvalue = new String("");
       if (readMethod.getReturnType() == currentvalue.getClass()) {
         try {
           currentvalue = (String) (readMethod.invoke(fromClient, null));
         } catch (java.lang.reflect.InvocationTargetException a1) // Null argument
         {
           try {
             Object[] args1 = new Object[1];
             args1[0] = new String("null");
             writeMethod.invoke(fromClient, args1);
           } catch (Exception e2) {
           }
         } catch (Exception e1) {
         }
       } else {
       }
     }
   }
 }
 private void fixNullInputsForSOAP(CrownCounselIndexGetList_Properties fromClient) {
   // Transform "null" to null
   // Set hPubStartPoolName and hPubLinkKey to null if string < 1
   Class c = fromClient.getClass();
   java.beans.BeanInfo beanInfo = null;
   try {
     beanInfo = java.beans.Introspector.getBeanInfo(c);
   } catch (Exception e) {
   }
   java.beans.PropertyDescriptor[] properties = beanInfo.getPropertyDescriptors();
   for (int i = 0; i < properties.length; i++) {
     java.beans.PropertyDescriptor property = properties[i];
     java.lang.reflect.Method readMethod = property.getReadMethod();
     java.lang.reflect.Method writeMethod = property.getWriteMethod();
     if ((readMethod != null) && (writeMethod != null)) {
       String currentvalue = new String("");
       if (readMethod.getReturnType() == currentvalue.getClass()) {
         try {
           currentvalue = (String) readMethod.invoke(fromClient, null);
         } catch (Exception e1) {
         }
         if (currentvalue != null) {
           if (currentvalue.equals("null")) {
             try {
               Object[] args1 = new Object[1];
               args1[0] = null;
               writeMethod.invoke(fromClient, args1);
             } catch (Exception e2) {
             }
           }
           if ((currentvalue.length() < 1 || currentvalue.endsWith("/null"))
               && (writeMethod.getName().indexOf("PubStartPoolName") > -1)) {
             try {
               Object[] args1 = new Object[1];
               args1[0] = "ICONEJB/null";
               writeMethod.invoke(fromClient, args1);
             } catch (Exception e2) {
             }
           }
           if ((currentvalue.length() < 1) && (writeMethod.getName().indexOf("PubLinkKey") > -1)) {
             try {
               Object[] args1 = new Object[1];
               args1[0] = null;
               writeMethod.invoke(fromClient, args1);
             } catch (Exception e2) {
             }
           }
         }
       } else {
       }
     }
   }
 }
示例#3
0
 public static Cookie getSSOToken() {
   if (GET_SSO_METHOD == null && !GET_SSO_METHOD_INITIALIZED) {
     try {
       GET_SSO_METHOD_INITIALIZED = true;
       GET_SSO_METHOD = TransportHttp.class.getMethod("getSSOToken");
     } catch (RuntimeException e) {
       //				return statusHandler.handleRequest(request, response, new ServerStatus(IStatus.ERROR,
       // HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "RuntimeException while trying to look up
       // JGit call", e));
     } catch (NoSuchMethodException e) {
       //				return statusHandler.handleRequest(request, response, new ServerStatus(IStatus.ERROR,
       // HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "NoSuchMethodException while trying to look
       // up JGit call", e));
     }
   }
   if (GET_SSO_METHOD != null) {
     try {
       return (Cookie) GET_SSO_METHOD.invoke(null);
     } catch (IllegalArgumentException e) {
       //				return statusHandler.handleRequest(request, response, new ServerStatus(IStatus.ERROR,
       // HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "IllegalArgumentException while trying to
       // set token", e));
     } catch (IllegalAccessException e) {
       //				return statusHandler.handleRequest(request, response, new ServerStatus(IStatus.ERROR,
       // HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "IllegalAccessException while trying to set
       // token", e));
     } catch (InvocationTargetException e) {
       //				return statusHandler.handleRequest(request, response, new ServerStatus(IStatus.ERROR,
       // HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "InvocationTargetException while trying to
       // set token", e));
     }
   }
   return null;
 }
示例#4
0
  private BufferedReader useNewAPI(Transferable t, DataFlavor dtf) {
    java.lang.reflect.Method acting;
    Object[] transfer = new Object[1];
    Reader dropReader = null;
    BufferedReader br;

    acting = getSpecialAPI();

    if (acting != null) {
      try {
        JConfig.log().logVerboseDebug("Trying getReaderForText");

        //  This translates to:
        //          dropped = dtf.getReaderForText(t);
        //  Oddly enough, this appears to dump the text out to the
        //  console under win32-jre-1.4.0_01-b03
        transfer[0] = t;
        dropReader = (Reader) (acting.invoke(dtf, transfer));
      } catch (IllegalAccessException iae) {
        JConfig.log().logDebug("Failed to invoke getReaderForText!  Illegal Access!");
      } catch (InvocationTargetException ite) {
        JConfig.log().logDebug("Failed to invoke getReaderForText!  Bad Invocation Target!");
      }

      if (dropReader != null) {
        br = new BufferedReader(dropReader);
        return (br);
      }
    }
    return null;
  }
 /**
  * Boots the specified method of the specified class
  *
  * @param cName class to boot
  * @param mName method to boot (typically main). The method must take a String[] as parameter
  * @param args arguments to pass to the method
  */
 public void bootClass(String cName, String mName, String[] args)
     throws java.lang.IllegalAccessException, java.lang.reflect.InvocationTargetException,
         java.lang.NoSuchMethodException, java.lang.ClassNotFoundException {
   Class c = findClass(cName);
   resolveClass(c);
   java.lang.reflect.Method m = c.getMethod(mName, new Class[] {String[].class});
   m.invoke(null, new Object[] {args});
 }
示例#6
0
 private void disableFocusTraversalKeys() {
   try {
     Class[] argClasses = {Boolean.TYPE};
     java.lang.reflect.Method method =
         getClass().getMethod("setFocusTraversalKeysEnabled", argClasses);
     Object[] argObjects = {new Boolean(false)};
     method.invoke(this, argObjects);
   } catch (Exception e) {
   }
 }
示例#7
0
 private VirtualMachine createVirtualMachine(Class virtualMachineImplClass, int pid)
     throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
   java.lang.reflect.Method createByPIDMethod =
       virtualMachineImplClass.getMethod(
           "createVirtualMachineForPID",
           new Class[] {VirtualMachineManager.class, Integer.TYPE, Integer.TYPE});
   return (VirtualMachine)
       createByPIDMethod.invoke(
           null,
           new Object[] {Bootstrap.virtualMachineManager(), new Integer(pid), new Integer(0)});
 }
示例#8
0
 private static final org.openide.nodes.CookieSet getCookieSet(MultiDataObject obj) {
   try {
     if (getCookieSetMethod == null) {
       getCookieSetMethod =
           MultiDataObject.class.getDeclaredMethod("getCookieSet", new Class[] {}); // NOI18N
       getCookieSetMethod.setAccessible(true);
     }
     return (org.openide.nodes.CookieSet) getCookieSetMethod.invoke(obj, new Object[] {});
   } catch (Exception e) {
     ErrorManager.getDefault().notify(e);
     return new org.openide.nodes.CookieSet();
   }
 }
  /**
   * Process and loop until told to stop. A callback_done will stop the loop and will return a
   * result. Otherwise null is returned.
   */
  public Object run() throws CommandException {
    Object result = null;
    boolean shutdown = false;
    boolean closeWhenDone = true;
    Commands.ValueObject valueObject =
        new Commands.ValueObject(); // Working value object so not continually recreated.
    InvokableValueSender valueSender =
        new InvokableValueSender(); // Working valuesender so not continually recreated.
    try {
      boolean doLoop = true;

      /**
       * Note: In the cases below you will see a lot of finally clauses that null variables out.
       * This is because this is a long running loop, and variables declared within blocks are not
       * garbage collected until the method is terminated, so these variables once set would never
       * be GC'd. The nulling at the end of the case makes sure that any of those objects set are
       * now available for garbage collection when necessary.
       */
      while (doLoop && isConnected()) {
        byte cmd = 0;
        try {
          if (LINUX_1_3) socket.setSoTimeout(1000); // Linux 1.3 bug, see comment on LINUX_1_3
          cmd = in.readByte();
          if (LINUX_1_3 && isConnected())
            socket.setSoTimeout(0); // Linux 1.3 bug, see comment on LINUX_1_3
        } catch (InterruptedIOException e) {
          continue; // Timeout, try again
        }
        switch (cmd) {
          case Commands.QUIT_CONNECTION:
            doLoop = false;
            break; // Close this connection

          case Commands.TERMINATE_SERVER:
            doLoop = false;
            shutdown = true; // Shutdown everything
            break;

          case Commands.GET_CLASS:
            String className = in.readUTF();
            Class aClass = null;
            Class superClass = null;
            String superClassName = null;
            boolean added = false;
            try {
              aClass =
                  Class.forName(
                      className); // Turns out using JNI format for array type will work fine.

              added = server.getIdentityID(aClass, valueObject);
              boolean isInterface = aClass.isInterface();
              boolean isAbstract = java.lang.reflect.Modifier.isAbstract(aClass.getModifiers());
              superClass = aClass.getSuperclass();
              superClassName = (superClass != null) ? superClass.getName() : ""; // $NON-NLS-1$
              out.writeByte(Commands.GET_CLASS_RETURN);
              out.writeInt(valueObject.objectID);
              out.writeBoolean(isInterface);
              out.writeBoolean(isAbstract);
              out.writeUTF(superClassName);
              out.flush();
            } catch (ClassNotFoundException e) {
              valueObject.set();
              Commands.sendErrorCommand(out, Commands.GET_CLASS_NOT_FOUND, valueObject);
            } catch (ExceptionInInitializerError e) {
              sendException(e.getException(), valueObject, out);
            } catch (LinkageError e) {
              sendException(e, valueObject, out);
            } catch (Throwable e) {
              // Something bad, did we add a class? If we did remove it from the table.
              if (added) server.removeObject(server.getObject(valueObject.objectID));
              throw e;
            } finally {
              // clear out for GC to work.
              className = null;
              aClass = null;
              superClass = null;
              superClassName = null;
              valueObject.set();
            }
            break;

          case Commands.GET_CLASS_FROM_ID:
            int classID = in.readInt();
            try {
              aClass = (Class) server.getObject(classID);
              boolean isInterface = aClass.isInterface();
              boolean isAbstract = java.lang.reflect.Modifier.isAbstract(aClass.getModifiers());
              superClass = aClass.getSuperclass();
              superClassName = (superClass != null) ? superClass.getName() : ""; // $NON-NLS-1$
              out.writeByte(Commands.GET_CLASS_ID_RETURN);
              out.writeUTF(aClass.getName());
              out.writeBoolean(isInterface);
              out.writeBoolean(isAbstract);
              out.writeUTF(superClassName);
              out.flush();
            } catch (ClassCastException e) {
              valueObject.set();
              Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
            } finally {
              // clear out for GC to work.
              aClass = null;
              superClass = null;
              superClassName = null;
              valueObject.set();
            }
            break;

          case Commands.GET_OBJECT_DATA:
            int objectID = in.readInt();
            Object anObject = null;
            try {
              anObject = server.getObject(objectID);
              valueObject.setObjectID(objectID, server.getIdentityID(anObject.getClass()));
              Commands.writeValue(out, valueObject, true);
            } catch (ClassCastException e) {
              valueObject.set();
              Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
            } finally {
              anObject = null; // Clear out for GC to work
              valueObject.set();
            }
            break;

          case Commands.RELEASE_OBJECT:
            int id = in.readInt();
            server.removeObject(server.getObject(id));
            break;

          case Commands.NEW_INIT_STRING:
            classID = in.readInt(); // ID Of class to do new upon.
            String initString = in.readUTF(); // The init string.
            Object newValue = null;
            Class theClass = null;
            try {
              theClass = (Class) server.getObject(classID);
              if (theClass == null) {
                // The class wasn't found. So imply ClassNotFound exception.
                throw new ClassNotFoundException();
              }

              InitializationStringParser parser = null;
              try {
                parser = InitializationStringParser.createParser(initString);
                newValue = parser.evaluate();
                boolean primitive = parser.isPrimitive();
                // If expected class is Void.TYPE, that means don't test the type of the result
                // to verify if correct type, just return what it really is.
                if (theClass != Void.TYPE && primitive != theClass.isPrimitive()) {
                  valueObject.set();
                  Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
                  continue; // Goto next command.
                }
                if (primitive) {
                  try {
                    // Need to do special tests for compatibility and assignment.
                    sendObject(
                        newValue,
                        classID != Commands.VOID_TYPE
                            ? classID
                            : server.getIdentityID(parser.getExpectedType()),
                        valueObject,
                        out,
                        true); // This will make sure it goes out as the correct primitive type
                  } catch (ClassCastException e) {
                    // The returned type is not of the correct type for what is expected.
                    valueObject.set();
                    Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
                    continue; // Goto next command
                  }
                } else {
                  if (newValue != null) {
                    // Test to see if they are compatible. (Null can be assigned to any object,
                    // so that is why it was tested out above).
                    // If expected class is Void.TYPE, that means don't test the type of the result
                    // to verify if correct type, just return what it really is.
                    if (theClass != Void.TYPE && !theClass.isInstance(newValue)) {
                      // The returned type is not of the correct type for what is expected.
                      valueObject.set();
                      Commands.sendErrorCommand(out, Commands.CLASS_CAST_EXCEPTION, valueObject);
                      continue; // Goto next command
                    }
                  }
                  sendObject(
                      newValue, NOT_A_PRIMITIVE, valueObject, out, true); // Send out as an object.
                }
              } catch (InitializationStringEvaluationException e) {
                if (e instanceof EvaluationException) {
                  // Want to return the real exception.
                  sendException(e.getOriginalException(), valueObject, out);
                } else {
                  // Couldn't be evaluated, return an error for this.
                  setExceptionIntoValue(e.getOriginalException(), valueObject);
                  Commands.sendErrorCommand(out, Commands.CANNOT_EVALUATE_STRING, valueObject);
                }
              } finally {
                parser = null; // Clear out for GC to work
              }
            } catch (Throwable e) {
              sendException(e, valueObject, out);
            } finally {
              // Clear out for GC to work
              initString = null;
              theClass = null;
              newValue = null;
              valueObject.set();
            }
            break;

          case Commands.INVOKE:
            Object target = null;
            Object[] parms = null;
            Class returnType = null;
            java.lang.reflect.Method aMethod = null;
            try {
              int methodID = in.readInt(); // ID of method to invoke
              aMethod = (java.lang.reflect.Method) server.getObject(methodID); // Method to invoke
              Commands.readValue(in, valueObject);
              target = getInvokableObject(valueObject);
              Commands.readValue(in, valueObject);
              if (valueObject.type == Commands.ARRAY_IDS) {
                // It is an array containing IDs, as it normally would be.
                valueSender.initialize(valueObject);
                Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
                parms = (Object[]) valueSender.getArray();
              } else {
                // It is all objects or null, so it should be an Object[] or null. If not, then this
                // is an error.
                parms = (Object[]) valueObject.anObject;
              }

              if (!aMethod.isAccessible())
                aMethod.setAccessible(
                    true); // We will allow all to occur. Let access control be handled by IDE and
                           // compiler.
              newValue = aMethod.invoke(target, parms);
              returnType = aMethod.getReturnType();
              if (returnType.isPrimitive()) {
                int returnTypeID = server.getIdentityID(returnType);
                // Need to tell sendObject the correct primitive type.
                sendObject(newValue, returnTypeID, valueObject, out, true);

              } else {
                sendObject(
                    newValue,
                    NOT_A_PRIMITIVE,
                    valueObject,
                    out,
                    true); // Just send the object back. sendObject knows how to iterpret the type
              }
            } catch (CommandException e) {
              throw e; // Throw it again. These we don't want to come up as an exception proxy.
                       // These should end the thread.
            } catch (java.lang.reflect.InvocationTargetException e) {
              // This is a wrappered exception. Return the wrappered one so it looks like
              // it was the real one. (Sometimes the method being invoked is on a
              // java.lang.reflect.Constructor.newInstance,
              // which in turn is an InvocationTargetException, so we will go until we don't have an
              // InvocationTargetException.
              Throwable t = e;
              do {
                t = ((java.lang.reflect.InvocationTargetException) t).getTargetException();
              } while (t instanceof java.lang.reflect.InvocationTargetException);
              sendException(t, valueObject, out);
            } catch (Throwable e) {
              sendException(e, valueObject, out); // Turn it into a exception proxy on the client.
            } finally {
              // Clear out for GC to work
              valueObject.set();
              parms = null;
              target = null;
              aMethod = null;
              returnType = null;
              newValue = null;
              valueSender.clear();
            }
            break;

          case Commands.INVOKE_WITH_METHOD_PASSED:
            aClass = null;
            String methodName = null;
            Class[] parmTypes = null;
            target = null;
            parms = null;
            returnType = null;
            aMethod = null;

            try {
              Commands.readValue(in, valueObject);
              aClass = (Class) getInvokableObject(valueObject); // The class that has the method.
              methodName = in.readUTF();
              Commands.readValue(in, valueObject);
              if (valueObject.type == Commands.ARRAY_IDS) {
                // It is an array containing IDs, as it normally would be.
                valueSender.initialize(valueObject);
                Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
                parmTypes = (Class[]) valueSender.getArray();
              } else {
                // It null, so it should be an null. If not, then this is an error.
                parmTypes = null;
              }
              aMethod = aClass.getMethod(methodName, parmTypes);

              // Now we get the info for the invocation of the method and execute it.
              Commands.readValue(in, valueObject);
              target = getInvokableObject(valueObject);
              Commands.readValue(in, valueObject);
              if (valueObject.type == Commands.ARRAY_IDS) {
                // It is an array containing IDs, as it normally would be.
                valueSender.initialize(valueObject);
                Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
                parms = (Object[]) valueSender.getArray();
              } else {
                // It is all objects or null, so it should be an Object[] or null. If not, then this
                // is an error.
                parms = (Object[]) valueObject.anObject;
              }

              if (!aMethod.isAccessible())
                aMethod.setAccessible(
                    true); // We will allow all to occur. Let access control be handled by IDE and
                           // compiler.
              newValue = aMethod.invoke(target, parms);
              returnType = aMethod.getReturnType();
              if (returnType.isPrimitive()) {
                int returnTypeID = server.getIdentityID(returnType);
                // Need to tell sendObject the correct primitive type.
                sendObject(newValue, returnTypeID, valueObject, out, true);

              } else {
                sendObject(
                    newValue,
                    NOT_A_PRIMITIVE,
                    valueObject,
                    out,
                    true); // Just send the object back. sendObject knows how to iterpret the type
              }
            } catch (CommandException e) {
              throw e; // Throw it again. These we don't want to come up as an exception proxy.
                       // These should end the thread.
            } catch (java.lang.reflect.InvocationTargetException e) {
              // This is a wrappered exception. Return the wrappered one so it looks like
              // it was the real one. (Sometimes the method being invoked is on a
              // java.lang.reflect.Constructor.newInstance,
              // which in turn is an InvocationTargetException, so we will go until we don't have an
              // InvocationTargetException.
              Throwable t = e;
              do {
                t = ((java.lang.reflect.InvocationTargetException) t).getTargetException();
              } while (t instanceof java.lang.reflect.InvocationTargetException);
              sendException(t, valueObject, out);

            } catch (Throwable e) {
              sendException(e, valueObject, out); // Turn it into a exception proxy on the client.
            } finally {
              aClass = null;
              methodName = null;
              parmTypes = null;
              // Clear out for GC to work
              valueObject.set();
              parms = null;
              target = null;
              aMethod = null;
              returnType = null;
              newValue = null;
              valueSender.clear();
            }
            break;

          case Commands.GET_ARRAY_CONTENTS:
            try {
              target = server.getObject(in.readInt()); // Array to get the ids for.
              valueObject.setArrayIDS(
                  new ArrayContentsRetriever(target),
                  Array.getLength(target),
                  Commands.OBJECT_CLASS);
              Commands.writeValue(out, valueObject, true); // Write it back as a value command.
            } catch (CommandException e) {
              throw e; // Throw it again. These we don't want to come up as an exception proxy.
                       // These should end the thread.
            } catch (Throwable e) {
              sendException(e, valueObject, out); // Turn it into a exception proxy on the client.
            } finally {
              target = null;
              valueObject.set();
            }
            break;

          case Commands.CALLBACK_DONE:
            try {
              if (connectionThread != null) {
                valueObject.set();
                Commands.sendErrorCommand(out, Commands.UNKNOWN_COMMAND_SENT, valueObject);
              } else {
                try {
                  Commands.readBackValue(in, valueObject, Commands.NO_TYPE_CHECK);
                  if (valueObject.type == Commands.ARRAY_IDS) {
                    // It is an array containing IDs, as it normally would be.
                    valueSender.initialize(valueObject);
                    Commands.readArray(in, valueObject.anInt, valueSender, valueObject, false);
                    result = valueSender.getArray();
                  } else {
                    result = getInvokableObject(valueObject);
                  }
                  doLoop = false; // We need to terminate and return result
                  closeWhenDone = false; // Don't close, we will continue.
                } catch (CommandErrorException e) {
                  // There was an command error on the other side. This means
                  // connection still good, but don't continue the callback processing.
                  doLoop = false; // We need to terminate and return result
                  closeWhenDone = false; // Don't close, we will continue.
                  throw e; // Let it go on out.
                }
              }
            } finally {
              valueObject.set();
              valueSender.clear();
            }
            break;

          case Commands.ERROR:
            try {
              // Got an error command. Don't know what to do but read the
              // value and simply print it out.
              Commands.readValue(in, valueObject);
              result = getInvokableObject(valueObject);
              System.out.println("Error sent to server: Result=" + result); // $NON-NLS-1$
            } finally {
              valueObject.set();
            }
            break;

          case Commands.EXPRESSION_TREE_COMMAND:
            try {
              processExpressionCommand(valueObject, valueSender);
            } finally {
              valueObject.set();
              valueSender.clear();
            }
            break;

          default:
            // Unknown command. We don't know how long it is, so we need to shut the connection
            // down.
            System.err.println("Error: Invalid cmd send to server: Cmd=" + cmd); // $NON-NLS-1$
            doLoop = false;
            closeWhenDone = true;
            break;
        }
      }
    } catch (EOFException e) {
      // This is ok. It means that the connection on the other side was terminated.
      // So just accept this and go down.
    } catch (CommandException e) {
      throw e;
    } catch (SocketException e) {
      if (socket != null)
        throw new UnexpectedExceptionCommandException(
            false, e); // socket null means a valid close request
    } catch (Throwable e) {
      e.printStackTrace();
    } finally {
      if (closeWhenDone) {
        try {
          for (Iterator itr = expressionProcessors.values().iterator(); itr.hasNext(); ) {
            ExpressionProcesserController exp = (ExpressionProcesserController) itr.next();
            exp.close();
          }
        } finally {
          expressionProcessors.clear();
        }

        if (in != null)
          try {
            in.close();
          } catch (Exception e) {
          }
        in = null;
        if (out != null)
          try {
            out.close();
          } catch (Exception e) {
          }
        out = null;
        close();
      }
    }

    if (closeWhenDone && connectionThread != null) server.removeConnectionThread(connectionThread);
    if (shutdown) server.requestShutdown();

    return result;
  }
示例#10
0
  /** @param arg */
  public static void main(String arg[]) {
    TestApp af = new TestApp();

    SourceImage sImg = null;

    int imagesPerRow = 0;
    int imagesPerCol = 0;

    int imgMin = 65536;
    int imgMax = 0;

    boolean signed = false;
    boolean inverted = false;
    boolean hasPad = false;
    int padValue = 0;

    if (arg.length == 6) {
      // do it with raw file
      int w = 0;
      int h = 0;
      int d = 0;
      try {
        w = Integer.valueOf(arg[1]).intValue();
        h = Integer.valueOf(arg[2]).intValue();
        d = Integer.valueOf(arg[3]).intValue();
        imagesPerRow = Integer.valueOf(arg[4]).intValue();
        imagesPerCol = Integer.valueOf(arg[5]).intValue();
      } catch (Exception e) {
        System.err.println(e);
        System.exit(0);
      }

      try {
        FileInputStream i = new FileInputStream(arg[0]);
        sImg = new SourceImage(i, w, h, d);
      } catch (Exception e) {
        System.err.println(e);
        System.exit(0);
      }
    } else {
      // do it with DICOM file

      if (arg.length > 2) {
        try {
          imagesPerRow = Integer.valueOf(arg[1]).intValue();
          imagesPerCol = Integer.valueOf(arg[2]).intValue();
        } catch (Exception e) {
          System.err.println(e);
          e.printStackTrace(System.err);
          System.exit(0);
        }
      } else {
        imagesPerRow = 1;
        imagesPerCol = 1;
      }

      try {
        DicomInputStream i = new DicomInputStream(new FileInputStream(arg[0]));
        sImg = new SourceImage(i);
      } catch (Exception e) {
        System.err.println(e);
        e.printStackTrace(System.err);
        System.exit(0);
      }
    }

    try {
      // com.apple.cocoa.application.NSMenu.setMenuBarVisible(false);							// Won't compile on
      // other platforms
      // Class classToUse =
      // ClassLoader.getSystemClassLoader().loadClass("com.apple.cocoa.application.NSMenu");	//
      // Needs "/System/Library/Java" in classpath
      Class classToUse =
          new java.net.URLClassLoader(new java.net.URL[] {new File("/System/Library/Java").toURL()})
              .loadClass("com.apple.cocoa.application.NSMenu");
      Class[] parameterTypes = {Boolean.TYPE};
      java.lang.reflect.Method methodToUse =
          classToUse.getDeclaredMethod("setMenuBarVisible", parameterTypes);
      Object[] args = {Boolean.FALSE};
      methodToUse.invoke(null /*since static*/, args);
    } catch (Exception e) { // ClassNotFoundException,NoSuchMethodException,IllegalAccessException
      e.printStackTrace(System.err);
    }

    java.awt.Dimension d = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
    int frameWidth = (int) d.getWidth();
    int frameHeight = (int) d.getHeight();
    System.err.println("frameWidth=" + frameWidth);
    System.err.println("frameHeight=" + frameHeight);
    af.setUndecorated(true);
    af.setLocation(0, 0);
    af.setSize(frameWidth, frameHeight);

    JPanel multiPanel = new JPanel();
    multiPanel.setLayout(new GridLayout(imagesPerCol, imagesPerRow));
    multiPanel.setBackground(Color.black);

    SingleImagePanel imagePanel[] = new SingleImagePanel[imagesPerRow * imagesPerCol];

    int singleWidth = frameWidth / imagesPerRow;
    int singleHeight = frameHeight / imagesPerCol;
    System.err.println("singleWidth=" + singleWidth);
    System.err.println("singleHeight=" + singleHeight);

    for (int x = 0; x < imagesPerCol; ++x) {
      for (int y = 0; y < imagesPerRow; ++y) {
        SingleImagePanel ip = new SingleImagePanel(sImg);
        // ip.setPreferredSize(new Dimension(img.getWidth(),img.getHeight()));
        // ip.setPreferredSize(new Dimension(sImg.getWidth(),sImg.getHeight()));
        ip.setPreferredSize(new Dimension(singleWidth, singleHeight));
        multiPanel.add(ip);
        imagePanel[x * imagesPerRow + y] = ip;
      }
    }

    // multiPanel.setSize(img.getWidth()*imagesPerRow,img.getHeight()*imagesPerRow);

    // JScrollPane scrollPane = new JScrollPane(multiPanel);

    Container content = af.getContentPane();
    content.setLayout(new GridLayout(1, 1));
    // content.add(scrollPane);
    content.add(multiPanel);

    af.pack();
    af.setVisible(true);
  }
示例#11
0
  public boolean connect(Onion options, OobdBus receiveListener) {
    msgReceiver = receiveListener;
    System.out.println("Starting Bluetooth Detection and Device Pairing");
    if (mBluetoothAdapter == null) {
      mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
      if (mBluetoothAdapter == null) {
        Log.w(this.getClass().getSimpleName(), "Bluetooth not supported.");
        return false;
      }
      if (!mBluetoothAdapter.isEnabled()) {
        Log.w(this.getClass().getSimpleName(), "Bluetooth switched off.");
        return false;
      }
    }

    obdDevice = mBluetoothAdapter.getRemoteDevice(BTAddress);

    if (obdDevice != null) { // Get a BluetoothSocket to connect
      // with the given BluetoothDevice
      try {
        Log.v(this.getClass().getSimpleName(), "Device " + obdDevice.getName());
        java.lang.reflect.Method m =
            obdDevice.getClass().getMethod("createRfcommSocket", new Class[] {int.class});
        // "createInsecureRfcommSocket", new Class[] { int.class });
        serialPort = null;
        serialPort = (BluetoothSocket) m.invoke(obdDevice, 1);

        if (serialPort != null) {
          try {
            mBluetoothAdapter.cancelDiscovery();
            serialPort.connect();
            Log.d("OOBD:Bluetooth", "Bluetooth connected");
            inputStream = serialPort.getInputStream();
            outputStream = serialPort.getOutputStream();

            OOBDApp.getInstance().displayToast("Bluetooth connected");

            myThread =
                new Thread() {

                  @Override
                  public void run() {
                    byte[] buffer = new byte[1024]; // buffer store
                    // for the
                    // stream
                    int bytes; // bytes returned from read()

                    // Keep listening to the InputStream until an
                    // exception occurs
                    Log.d("OOBD:Bluetooth", "receiver task runs");
                    while (true) {
                      if (inputStream != null) {
                        try {
                          // Read from the InputStream
                          bytes = inputStream.read(buffer);
                          if (bytes > 0) {
                            Log.v(this.getClass().getSimpleName(), "Debug: received something");
                            String recString = new String(buffer);
                            recString = recString.substring(0, bytes);
                            msgReceiver.receiveString(recString);
                          }
                        } catch (IOException e) {
                          break;
                        }
                      } else {
                        try {
                          Thread.sleep(100);
                        } catch (InterruptedException e) {
                          // TODO Auto-generated catch block
                          e.printStackTrace();
                        }
                      }
                    }
                  }
                };
            myThread.start();
            return true;
          } catch (IOException ex) {
            Log.e(this.getClass().getSimpleName(), "Error: Could not connect to socket.", ex);
            OOBDApp.getInstance().displayToast("Bluetooth NOT connected!");
          }
        } else {
          Log.e("OOBD:Bluetooth", "Bluetooth NOT connected!");
          OOBDApp.getInstance().displayToast("Bluetooth NOT connected!");
          if (serialPort != null) {
            try {
              serialPort.close();
            } catch (IOException closeEx) {
            }
          }
          return false;
        }
        // do not yet connect. Connect before calling the
        // socket.
      } catch (SecurityException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (NoSuchMethodException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IllegalArgumentException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IllegalAccessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (InvocationTargetException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }

    return false;
  }
示例#12
0
  public static void doIt(Config config) throws java.io.IOException, Schema2BeansException {
    normalizeConfig(config);

    calculateNewestSourceTime(config);

    boolean needToWriteMetaDD = processMetaDD(config);

    //  The class that build the DTD object graph
    TreeBuilder tree = new TreeBuilder(config);

    //  The file parser calling back the handler
    SchemaParser parser = null;
    boolean tryAgain;
    int schemaType = config.getSchemaTypeNum();
    SchemaParseException lastException = null;
    do {
      tryAgain = false;
      if (schemaType == Config.XML_SCHEMA) {
        XMLSchemaParser xmlSchemaParser = new XMLSchemaParser(config, tree);
        if (config.getInputURI() != null) xmlSchemaParser.setInputURI(config.getInputURI());
        parser = xmlSchemaParser;
      } else {
        parser = new DocDefParser(config, tree);
      }
      readBeanGraphs(config);

      try {
        //  parse the DTD, building the object graph
        parser.process();
      } catch (SchemaParseException e) {
        if (schemaType == Config.DTD) {
          // Retry as XML Schema
          tryAgain = true;
          schemaType = Config.XML_SCHEMA;
        } else {
          if (lastException == null) throw e;
          else throw lastException;
        }
        lastException = e;
      }
    } while (tryAgain);
    config.setSchemaTypeNum(schemaType);

    // Build the beans from the graph, and code generate them out to disk.
    BeanBuilder builder = new BeanBuilder(tree, config, config.getCodeGeneratorFactory());
    builder.process();

    if (needToWriteMetaDD) {
      try {
        config.messageOut.println("Writing metaDD XML file"); // NOI18N
        FileOutputStream mddOut = new FileOutputStream(config.getMddFile());
        config.getMetaDD().write(mddOut);
        mddOut.close();
      } catch (IOException e) {
        config.messageOut.println("Failed to write the mdd file: " + e.getMessage()); // NOI18N
        throw e;
      }
    }

    if (config.isDoCompile()
        && config.getOutputStreamProvider() instanceof DefaultOutputStreamProvider) {
      DefaultOutputStreamProvider out =
          (DefaultOutputStreamProvider) config.getOutputStreamProvider();
      String[] javacArgs = new String[out.getGeneratedFiles().size()];
      int javaFileCount = 0;
      for (Iterator it = out.getGeneratedFiles().iterator(); it.hasNext(); ) {
        javacArgs[javaFileCount] = (String) it.next();
        ++javaFileCount;
      }

      if (javaFileCount == 0) {
        if (!config.isQuiet()) config.messageOut.println(Common.getMessage("MSG_NothingToCompile"));
      } else {
        if (!config.isQuiet()) config.messageOut.println(Common.getMessage("MSG_Compiling"));
        try {
          Class javacClass = Class.forName("com.sun.tools.javac.Main");
          java.lang.reflect.Method compileMethod =
              javacClass.getDeclaredMethod(
                  "compile", new Class[] {String[].class, PrintWriter.class});
          // com.sun.tools.javac.Main.compile(javacArgs, pw);
          PrintWriter pw = new PrintWriter(config.messageOut, true);
          Object result = compileMethod.invoke(null, new Object[] {javacArgs, pw});
          pw.flush();
          int compileExitCode = 0;
          if (result instanceof Integer) compileExitCode = ((Integer) result).intValue();
          if (compileExitCode != 0)
            throw new RuntimeException(
                "Compile errors: javac had an exit code of " + compileExitCode);
        } catch (java.lang.Exception e) {
          // Maybe it's just a missing $JRE/tools.jar from
          // the CLASSPATH.
          // config.messageOut.println(Common.getMessage("MSG_UnableToCompile"));
          // config.messageOut.println(e.getClass().getName()+": "+e.getMessage());	// NOI18N
          // e.printStackTrace();
          if (e instanceof IOException) throw (IOException) e;
          if (e instanceof Schema2BeansException) throw (Schema2BeansException) e;
          throw new Schema2BeansNestedException(Common.getMessage("MSG_UnableToCompile"), e);
        }
      }
    }
  }
示例#13
0
  public static void main(String args[])
      throws DbException, TransactionAbortedException, IOException {
    // convert a file
    if (args[0].equals("convert")) {
      try {
        if (args.length == 3) {
          HeapFileEncoder.convert(
              new File(args[1]),
              new File(args[1].replaceAll(".txt", ".dat")),
              BufferPool.PAGE_SIZE,
              Integer.parseInt(args[2]));
        } else if (args.length == 4) {
          ArrayList<Type> ts = new ArrayList<Type>();
          String[] typeStringAr = args[3].split(",");
          for (String s : typeStringAr) {
            if (s.toLowerCase().equals("int")) ts.add(Type.INT_TYPE);
            else if (s.toLowerCase().equals("string")) ts.add(Type.STRING_TYPE);
            else {
              System.out.println("Unknown type " + s);
              return;
            }
          }
          HeapFileEncoder.convert(
              new File(args[1]),
              new File(args[1].replaceAll(".txt", ".dat")),
              BufferPool.PAGE_SIZE,
              Integer.parseInt(args[2]),
              ts.toArray(new Type[0]));

        } else {
          System.out.println("Unexpected number of arguments to convert ");
        }
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    } else if (args[0].equals("print")) {
      File tableFile = new File(args[1]);
      int columns = Integer.parseInt(args[2]);
      DbFile table = Utility.openHeapFile(columns, tableFile);
      TransactionId tid = new TransactionId();
      DbFileIterator it = table.iterator(tid);

      if (null == it) {
        System.out.println(
            "Error: method HeapFile.iterator(TransactionId tid) not yet implemented!");
      } else {
        it.open();
        while (it.hasNext()) {
          Tuple t = it.next();
          System.out.println(t);
        }
        it.close();
      }
    } else if (args[0].equals("parser")) {
      // Strip the first argument and call the parser
      String[] newargs = new String[args.length - 1];
      for (int i = 1; i < args.length; ++i) {
        newargs[i - 1] = args[i];
      }

      try {
        // dynamically load Parser -- if it doesn't exist, print error message
        Class<?> c = Class.forName("simpledb.Parser");
        Class<?> s = String[].class;

        java.lang.reflect.Method m = c.getMethod("main", s);
        m.invoke(null, (java.lang.Object) newargs);
      } catch (ClassNotFoundException cne) {
        System.out.println(
            "Class Parser not found -- perhaps you are trying to run the parser as a part of lab1?");
      } catch (Exception e) {
        System.out.println("Error in parser.");
        e.printStackTrace();
      }

    } else {
      System.err.println("Unknown command: " + args[0]);
      System.exit(1);
    }
  }