コード例 #1
0
  private ImagePlus openImage(String directory, String name, String path) {
    Object o = tryOpen(directory, name, path);
    // if an image was returned, assume success
    if (o instanceof ImagePlus) return (ImagePlus) o;

    // try opening the file with LOCI Bio-Formats plugin - always check this last!
    // Do not call Bio-Formats if File>Import>Image Sequence is opening this file.
    if (o == null
        && (IJ.getVersion().compareTo("1.38j") < 0 || !IJ.redirectingErrorMessages())
        && (new File(path).exists())) {
      Object loci = IJ.runPlugIn("loci.plugins.LociImporter", path);
      if (loci != null) {
        // plugin exists and was launched
        try {
          // check whether plugin was successful
          Class c = loci.getClass();
          boolean success = c.getField("success").getBoolean(loci);
          boolean canceled = c.getField("canceled").getBoolean(loci);
          if (success || canceled) {
            width = IMAGE_OPENED;
            return null;
          }
        } catch (Exception exc) {
        }
      }
    }

    return null;
  } // openImage
コード例 #2
0
  static {
    if (!Boolean.getBoolean(GridSystemProperties.GG_JETTY_LOG_NO_OVERRIDE)) {
      String ctgrJetty = "org.eclipse.jetty"; // WARN for this category.
      String ctgrJettyUtil = "org.eclipse.jetty.util.log"; // ERROR for this...
      String ctgrJettyUtilComp = "org.eclipse.jetty.util.component"; // ...and this.

      try {
        Class<?> logCls = Class.forName("org.apache.log4j.Logger");

        Object logJetty = logCls.getMethod("getLogger", String.class).invoke(logCls, ctgrJetty);
        Object logJettyUtil =
            logCls.getMethod("getLogger", String.class).invoke(logCls, ctgrJettyUtil);
        Object logJettyUtilComp =
            logCls.getMethod("getLogger", String.class).invoke(logCls, ctgrJettyUtilComp);

        Class<?> lvlCls = Class.forName("org.apache.log4j.Level");

        Object warnLvl = lvlCls.getField("WARN").get(null);
        Object errLvl = lvlCls.getField("ERROR").get(null);

        logJetty.getClass().getMethod("setLevel", lvlCls).invoke(logJetty, warnLvl);
        logJettyUtil.getClass().getMethod("setLevel", lvlCls).invoke(logJetty, errLvl);
        logJettyUtilComp.getClass().getMethod("setLevel", lvlCls).invoke(logJetty, errLvl);
      } catch (Exception ignored) {
        // No-op.
      }
    }
  }
コード例 #3
0
  public static void main(String[] args)
      throws FileNotFoundException, IOException, NoSuchFieldException, SecurityException,
          IllegalArgumentException, IllegalAccessException {
    Class<Foobar> cls = Foobar.class;

    System.out.println(cls.getField("i").get(null));

    Foobar.i = 6;

    System.out.println(cls.getField("i").get(null));
    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("foobar.out"));

    out.writeObject(cls);
  }
コード例 #4
0
ファイル: Main.java プロジェクト: SalomonSandrock/school
  /**
   * Prints one Unicode property value per line, along with its aliases, if any, for the given
   * unicodeVersion.
   *
   * @param unicodeVersion The Unicode version to print property values and aliases for
   * @throws UnicodeProperties.UnsupportedUnicodeVersionException if unicodeVersion is not supported
   */
  private static void printUnicodePropertyValuesAndAliases(String unicodeVersion)
      throws UnicodeProperties.UnsupportedUnicodeVersionException {
    Pattern versionPattern = Pattern.compile("(\\d+)(?:\\.(\\d+))?(?:\\.\\d+)?");
    Matcher matcher = versionPattern.matcher(unicodeVersion);
    if (!matcher.matches()) {
      throw new UnicodeProperties.UnsupportedUnicodeVersionException();
    }
    String underscoreVersion =
        matcher.group(1) + (null == matcher.group(2) ? "_0" : "_" + matcher.group(2));

    String[] propertyValues;
    String[] propertyValueAliases;
    try {
      Class<?> clazz = Class.forName("jflex.unicode.data.Unicode_" + underscoreVersion);
      Field field = clazz.getField("propertyValues");
      propertyValues = (String[]) field.get(null);
      field = clazz.getField("propertyValueAliases");
      propertyValueAliases = (String[]) field.get(null);
    } catch (Exception e) {
      throw new UnicodeProperties.UnsupportedUnicodeVersionException();
    }
    SortedMap<String, SortedSet<String>> propertyValuesToAliases =
        new TreeMap<String, SortedSet<String>>();
    for (String value : propertyValues) {
      propertyValuesToAliases.put(value, new TreeSet<String>());
    }
    for (int i = 0; i < propertyValueAliases.length; i += 2) {
      String alias = propertyValueAliases[i];
      String value = propertyValueAliases[i + 1];
      SortedSet<String> aliases = propertyValuesToAliases.get(value);
      if (null == aliases) {
        aliases = new TreeSet<String>();
        propertyValuesToAliases.put(value, aliases);
      }
      aliases.add(alias);
    }
    for (Map.Entry<String, SortedSet<String>> entry : propertyValuesToAliases.entrySet()) {
      String value = entry.getKey();
      SortedSet<String> aliases = entry.getValue();
      Out.print(value);
      if (aliases.size() > 0) {
        for (String alias : aliases) {
          Out.print(", " + alias);
        }
      }
      Out.println("");
    }
  }
コード例 #5
0
 public void testChainedConstructor() throws Exception {
   Class cls = loadAndPatchClass("TestChainedConstructor.form", "ChainedConstructorTest");
   Field scrollPaneField = cls.getField("myScrollPane");
   Object instance = cls.newInstance();
   JScrollPane scrollPane = (JScrollPane) scrollPaneField.get(instance);
   assertNotNull(scrollPane.getViewport().getView());
 }
コード例 #6
0
ファイル: Javac170Compiler.java プロジェクト: jjsahalf/drjava
  public boolean isAvailable() {
    try {
      // Diagnostic was introduced in the Java 1.6 compiler
      Class<?> diagnostic = Class.forName("javax.tools.Diagnostic");
      diagnostic.getMethod("getKind");
      // javax.lang.model.SourceVersion.RELEASE_7 field introduced in Java 7
      Class<?> sourceVersion = Class.forName("javax.lang.model.SourceVersion");
      sourceVersion.getField("RELEASE_7"); // only exists in Java 7 and later releases
      // javax.tools.Diagnostic and javax.lang.model.SourceVersion are also found in rt.jar;
      // to test if tools.jar is available, we need to test for a class only found in tools.jar
      Class.forName("com.sun.tools.javac.main.JavaCompiler");

      // This is the class that javax.tools.ToolProvider.getSystemJavaCompiler() uses
      // We create an instance of that class directly, bypassing ToolProvider, because ToolProvider
      // returns null
      // if DrJava is started with just the JRE, instead of with the JDK, even if tools.jar is later
      // made available
      // to the class loader.
      JavaCompiler compiler =
          (JavaCompiler) (Class.forName("com.sun.tools.javac.api.JavacTool").newInstance());

      return (compiler != null);
    } catch (Exception e) {
      return false;
    } catch (LinkageError e) {
      return false;
    }
  }
コード例 #7
0
 private JComponent getInstrumentedRootComponent(final String formFileName, final String className)
     throws Exception {
   Class cls = loadAndPatchClass(formFileName, className);
   Field rootComponentField = cls.getField("myRootComponent");
   rootComponentField.setAccessible(true);
   Object instance = cls.newInstance();
   return (JComponent) rootComponentField.get(instance);
 }
コード例 #8
0
ファイル: ImageJ_Updater.java プロジェクト: AlexJoz/docuensj
 // Use reflection to get version since early versions
 // of ImageJ do not have the IJ.getVersion() method.
 String version() {
   String version = "";
   try {
     Class ijClass = ImageJ.class;
     Field field = ijClass.getField("VERSION");
     version = (String) field.get(ijClass);
   } catch (Exception ex) {
   }
   return version;
 }
コード例 #9
0
    /**
     * Initializes the fields of this class based on the first two lines of a case which include the
     * class name and parameter types.
     *
     * @return true is end of file is reached.
     */
    private static boolean initFields(LineNumberReader commands, boolean generatingCommands) {

      results = new StringBuffer();

      String className = getNextRealLine(commands);

      // End of file reached
      if (className == null) return true;

      // Load the class from file
      Class<? extends Invariant> classToTest = asInvClass(getClass(className));

      try {
        classToTest.getField("dkconfig_enabled"); // Enable if needs to be done
        InvariantAddAndCheckTester.config.apply(className + ".enabled", "true");
      } catch (NoSuchFieldException e) { // Otherwise do nothing
      }

      if (generatingCommands) {
        results.append(className + lineSep);
      }

      // Instantiate variables to be used as the names in the
      // invariants, variables are labeled a,b,c and so on as they
      // appear
      String typeString = getNextRealLine(commands);

      types = getTypes(typeString);

      VarInfo[] vars = getVarInfos(classToTest, types);
      PptSlice sl = createSlice(vars, daikon.test.Common.makePptTopLevel("Test:::OBJECT", vars));

      // Create an actual instance of the class
      invariantToTest = instantiateClass(classToTest, sl);

      addModified = getAddModified(invariantToTest.getClass());
      checkModified = getCheckModified(invariantToTest.getClass());
      outputProducer = getOutputProducer(invariantToTest.getClass());

      assert getArity(invariantToTest.getClass()) == types.length;

      if (generatingCommands) {
        results.append(typeString + lineSep);
      }
      return false;
    }
コード例 #10
0
ファイル: RPC.java プロジェクト: jonathangizmo/HadoopDistJ
 /**
  * Get the protocol version from protocol class. If the protocol class has a ProtocolAnnotation,
  * then get the protocol name from the annotation; otherwise the class name is the protocol name.
  */
 public static long getProtocolVersion(Class<?> protocol) {
   if (protocol == null) {
     throw new IllegalArgumentException("Null protocol");
   }
   long version;
   ProtocolInfo anno = protocol.getAnnotation(ProtocolInfo.class);
   if (anno != null) {
     version = anno.protocolVersion();
     if (version != -1) return version;
   }
   try {
     Field versionField = protocol.getField("versionID");
     versionField.setAccessible(true);
     return versionField.getLong(protocol);
   } catch (NoSuchFieldException ex) {
     throw new RuntimeException(ex);
   } catch (IllegalAccessException ex) {
     throw new RuntimeException(ex);
   }
 }
コード例 #11
0
ファイル: JavaAdapter.java プロジェクト: sq001/aurora-project
  // Needed by NativeJavaObject serializer
  public static void writeAdapterObject(Object javaObject, ObjectOutputStream out)
      throws IOException {
    Class<?> cl = javaObject.getClass();
    out.writeObject(cl.getSuperclass().getName());

    Class<?>[] interfaces = cl.getInterfaces();
    String[] interfaceNames = new String[interfaces.length];

    for (int i = 0; i < interfaces.length; i++) interfaceNames[i] = interfaces[i].getName();

    out.writeObject(interfaceNames);

    try {
      Object delegee = cl.getField("delegee").get(javaObject);
      out.writeObject(delegee);
      return;
    } catch (IllegalAccessException e) {
    } catch (NoSuchFieldException e) {
    }
    throw new IOException();
  }
コード例 #12
0
ファイル: Output.java プロジェクト: pgoelz/xfp
  /**
   * Returns a compressing output stream using JZLib (http://www.jcraft.com/jzlib/). If JZLib is not
   * available on your system, this method will return null.
   */
  public static OutputStream makeCompressingOutputStream(OutputStream out) {
    // to do this, we're going to use reflection.  But here's the equivalent code:
    /*
      com.jcraft.jzlib.ZOutputStream stream = new com.jcraft.jzlib.ZOutputStream(out, com.jcraft.jzlib.JZlib.Z_BEST_SPEED);
      stream.setFlushMode(com.jcraft.jzlib.JZlib.Z_SYNC_FLUSH);
      return stream;
    */
    try {
      Class outz = Class.forName("com.jcraft.jzlib.JZlib");
      int Z_BEST_SPEED = outz.getField("Z_BEST_SPEED").getInt(null);
      int Z_SYNC_FLUSH = outz.getField("Z_SYNC_FLUSH").getInt(null);

      Class outc = Class.forName("com.jcraft.jzlib.ZOutputStream");
      Object outi =
          outc.getConstructor(new Class[] {OutputStream.class, Integer.TYPE})
              .newInstance(new Object[] {out, new Integer(Z_BEST_SPEED)});
      outc.getMethod("setFlushMode", new Class[] {Integer.TYPE})
          .invoke(outi, new Object[] {new Integer(Z_SYNC_FLUSH)});
      return (OutputStream) outi;
    } catch (Exception e) {
      return null;
    } // failed, probably doesn't have JZLib on the system
  }