コード例 #1
0
ファイル: TypeUniverse.java プロジェクト: smarr/graal
  private void addClass(Class<?> c) {
    if (classes.add(c)) {
      if (c.getSuperclass() != null) {
        addClass(c.getSuperclass());
      }
      for (Class<?> sc : c.getInterfaces()) {
        addClass(sc);
      }
      for (Class<?> dc : c.getDeclaredClasses()) {
        addClass(dc);
      }
      for (Method m : c.getDeclaredMethods()) {
        addClass(m.getReturnType());
        for (Class<?> p : m.getParameterTypes()) {
          addClass(p);
        }
      }

      if (c != void.class && dimensions(c) < 2) {
        Class<?> arrayClass = Array.newInstance(c, 0).getClass();
        arrayClasses.put(c, arrayClass);
        addClass(arrayClass);
      }
    }
  }
コード例 #2
0
 /** Return the class with the given name. */
 private static Class getClassImpl(Class parent, String name) throws ClassNotFoundException {
   Class[] clazzes = parent.getDeclaredClasses();
   for (int i = 0; i < clazzes.length; i++) {
     if (clazzes[i].getName().equals(parent.getName() + "$" + name)) return clazzes[i];
   }
   throw new ClassNotFoundException("Invalid class : " + parent.getName() + "$" + name);
 }
コード例 #3
0
ファイル: ModBlocks.java プロジェクト: Omegampyre/Botania
  private static void registerSubTileWithMini(String key, Class<? extends SubTileEntity> clazz) {
    BotaniaAPI.registerSubTile(key, clazz);

    for (Class innerClazz : clazz.getDeclaredClasses())
      if (innerClazz.getSimpleName().equals("Mini"))
        BotaniaAPI.registerMiniSubTile(key + "Chibi", innerClazz, key);
  }
コード例 #4
0
 private void verifyExternalClass(final Class clazz) {
   // don't recommended to instantiate the class doing clazz.newInstance().
   clazz.getDeclaredConstructors();
   clazz.getDeclaredFields();
   clazz.getDeclaredMethods();
   clazz.getDeclaredClasses();
   clazz.getDeclaredAnnotations();
 }
コード例 #5
0
 public static Class<?> getDeclaredClass(String className, Class<?> containingClass) {
   for (Class<?> declaredClass : containingClass.getDeclaredClasses()) {
     if (declaredClass.getSimpleName().equals(className)) {
       return declaredClass;
     }
   }
   return null;
 }
コード例 #6
0
ファイル: ReflectUtils.java プロジェクト: chsguitar1/flatlaf
 /**
  * Returns inner class with the specified name.
  *
  * @param fromClass class to look for the inner class
  * @param innerClassName inner class name
  * @return inner class with the specified name
  */
 public static Class getInnerClass(final Class fromClass, final String innerClassName) {
   for (final Class innerClass : fromClass.getDeclaredClasses()) {
     if (getClassName(innerClass).equals(innerClassName)) {
       return innerClass;
     }
   }
   return null;
 }
コード例 #7
0
 /**
  * Searches the class for the specified inner class.
  *
  * @param clz the class to search in.
  * @param simpleName the simpleName of the class to find
  * @returns the class being searched for, or null if it can't be found.
  */
 private Class<?> findInnerClassByName(Class<?> clz, String simpleName) {
   for (Class<?> c : clz.getDeclaredClasses()) {
     if (c.getSimpleName().equals(simpleName)) {
       return c;
     }
   }
   return null;
 }
コード例 #8
0
  private void analyze(Class<?> cls, boolean topLevel) {
    if (!Modifier.isPublic(cls.getModifiers())) {
      return;
    }

    Lookup lookup = MethodHandles.lookup();

    if (topLevel) {
      this.constructor = new DynamicConstructor(getCoercionMatrix());
      Constructor<?>[] constructors = cls.getConstructors();

      for (int i = 0; i < constructors.length; ++i) {
        try {
          this.constructor.addConstructorHandle(lookup.unreflectConstructor(constructors[i]));
        } catch (IllegalAccessException e) {
        }
      }
    }

    Method[] methods = getTargetClass().getMethods();

    for (int i = 0; i < methods.length; ++i) {
      int modifiers = methods[i].getModifiers();

      if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers)) {
        analyzeMethod(methods[i]);
      }
    }

    Field[] fields = getTargetClass().getFields();

    for (int i = 0; i < fields.length; ++i) {
      int modifiers = fields[i].getModifiers();

      if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers)) {
        analyzeField(fields[i]);
      }
    }

    if (cls.getSuperclass() != null) {
      analyze(cls.getSuperclass(), false);
    }

    Class<?>[] interfaces = cls.getInterfaces();
    for (int i = 0; i < interfaces.length; ++i) {
      analyze(interfaces[i], false);
    }

    Class<?>[] innerClasses = cls.getDeclaredClasses();

    for (int i = 0; i < innerClasses.length; ++i) {
      int modifiers = innerClasses[i].getModifiers();
      if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers)) {
        this.propertyReaders.put(
            innerClasses[i].getSimpleName(), MethodHandles.constant(Class.class, innerClasses[i]));
      }
    }
  }
コード例 #9
0
  private static int queryEnums(Class<?> clazz, Hashtable<String, Class<?>> enums) {
    int enumConstantCount = 0;

    Class<?> declaredClasses[] = clazz.getDeclaredClasses();
    for (Class<?> declaredClass : declaredClasses)
      enumConstantCount += putEnumTypeInHash(declaredClass, enums);

    return enumConstantCount;
  }
コード例 #10
0
ファイル: Zadanie2.java プロジェクト: krzysiekbielicki/UTP
 public Zadanie2() {
   String className = JOptionPane.showInputDialog("Podaj nazwę klasy");
   Class<?> cls = null;
   try {
     cls = Class.forName(className);
     Class<?>[] classes = cls.getDeclaredClasses();
     for (Class<?> c : classes) {
       System.out.println("Własciwości obiektu " + c.getCanonicalName());
       Class<?>[] cl = c.getDeclaredClasses();
       for (Class<?> cc : cl) {
         System.out.println("\t" + cc.getCanonicalName());
       }
     }
   } catch (ClassNotFoundException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
  /**
   * Determine imports for the given bundle. Based on the user settings, this method will consider
   * only the the test hierarchy until the testing framework is found or all classes available
   * inside the test bundle.
   *
   * <p>Note that split packages are not supported.
   *
   * @return
   */
  private String[] determineImports() {

    boolean useTestClassOnly = false;

    // no jar entry present, bail out.
    if (jarEntries == null || jarEntries.isEmpty()) {
      logger.debug("No test jar content detected, generating bundle imports from the test class");
      useTestClassOnly = true;
    } else if (createManifestOnlyFromTestClass()) {
      logger.info("Using the test class for generating bundle imports");
      useTestClassOnly = true;
    } else logger.info("Using all classes in the jar for the generation of bundle imports");

    // className, class resource
    Map entries;

    if (useTestClassOnly) {

      entries = new LinkedHashMap(4);

      // get current class (test class that bootstraps the OSGi infrastructure)
      Class<?> clazz = getClass();
      String clazzPackage = null;
      String endPackage = AbstractOnTheFlyBundleCreatorTests.class.getPackage().getName();

      do {

        // consider inner classes as well
        List classes = new ArrayList(4);
        classes.add(clazz);
        CollectionUtils.mergeArrayIntoCollection(clazz.getDeclaredClasses(), classes);

        for (Iterator iterator = classes.iterator(); iterator.hasNext(); ) {
          Class<?> classToInspect = (Class) iterator.next();

          Package pkg = classToInspect.getPackage();
          if (pkg != null) {
            clazzPackage = pkg.getName();
            String classFile = ClassUtils.getClassFileName(classToInspect);
            entries.put(
                classToInspect.getName().replace('.', '/').concat(ClassUtils.CLASS_FILE_SUFFIX),
                new InputStreamResource(classToInspect.getResourceAsStream(classFile)));
          }
          // handle default package
          else {
            logger.warn("Could not find package for class " + classToInspect + "; ignoring...");
          }
        }

        clazz = clazz.getSuperclass();

      } while (!endPackage.equals(clazzPackage));
    } else entries = jarEntries;

    return determineImportsFor(entries);
  }
コード例 #12
0
ファイル: AndroidJarLoader.java プロジェクト: TeamNyx/sdk
    @Override
    public IClassDescriptor[] getDeclaredClasses() {
      Class<?>[] classes = mClass.getDeclaredClasses();
      IClassDescriptor[] iclasses = new IClassDescriptor[classes.length];
      for (int i = 0; i < classes.length; i++) {
        iclasses[i] = new ClassWrapper(classes[i]);
      }

      return iclasses;
    }
コード例 #13
0
ファイル: ClassLoaderUtil.java プロジェクト: ruochenxing/tiny
 /**
  * Retrieves a given inner class definition from the specified outer class.
  *
  * @param cls the outer Class
  * @param innerClassName the fully-qualified name of the inner class of interest
  */
 private static Class getInnerClass(Class cls, String innerClassName) {
   Class result = null;
   Class[] innerClasses = cls.getDeclaredClasses();
   for (Class c : innerClasses) {
     if (c.getName().equals(innerClassName)) {
       result = c;
       break;
     }
   }
   return result;
 }
コード例 #14
0
  private static void getSelectColumns(final Class<?> klass, final StringBuilder builder)
      throws Exception {
    final Field[] fields = klass.getFields();
    for (final Field field : fields) {
      getSelectColumn(field, builder);
    }

    final Class<?>[] klasses = klass.getDeclaredClasses();
    for (int i = 0; i < klasses.length; i++) {
      getSelectColumns(klasses[i], builder);
    }
  }
コード例 #15
0
ファイル: CrossModUtils.java プロジェクト: Mazdallier/AsieLib
 public static ItemStack getItemStack(String modid, String name, int stackSize, int metadata) {
   if (classNames.containsKey(modid)) { // Use classNames
     for (String classname : classNames.get(modid)) {
       try {
         Class klass = null;
         if (classname.split("\\$").length == 1) {
           klass = CrossModUtils.class.getClassLoader().loadClass(classname);
         } else {
           klass = CrossModUtils.class.getClassLoader().loadClass(classname.split("\\$")[0]);
           for (Class innerklass : klass.getDeclaredClasses()) {
             if (innerklass.getName().equals(classname)) klass = innerklass;
           }
         }
         if (klass != null) {
           Object o = klass.getField(name).get(null);
           if (o instanceof Block) return new ItemStack((Block) o, stackSize, metadata);
           else if (o instanceof Item) return new ItemStack((Item) o, stackSize, metadata);
           else if (o instanceof Integer)
             return new ItemStack(((Integer) o).intValue(), stackSize, metadata);
           else {
             try {
               int id = klass.getField(name).getInt(null);
               return new ItemStack(id, stackSize, metadata);
             } catch (Exception e) {
               AsieLibMod.log.warning(
                   "Could not get right object for field "
                       + name
                       + " in class "
                       + classNames.get(modid));
             }
           }
         }
       } catch (Exception e) {
         e.printStackTrace();
       }
     }
     // We're still here!?
     AsieLibMod.log.severe(
         "Could not load class for mod "
             + modid
             + ", trying worst-case alternatives - PROBABLY BROKEN");
   }
   if (GameRegistry.findBlock(modid, name) != null)
     return new ItemStack(GameRegistry.findBlock(modid, name), stackSize, metadata);
   else if (GameRegistry.findItem(modid, name) != null)
     return new ItemStack(GameRegistry.findItem(modid, name), stackSize, metadata);
   else if (GameRegistry.findItemStack(modid, name, stackSize) != null) {
     ItemStack stack = GameRegistry.findItemStack(modid, name, stackSize);
     if (stack != null) stack.setItemDamage(metadata);
     return stack;
   }
   return null; // in case we already haven't
 }
コード例 #16
0
 private static void findAnnotatedClasses(List<Class<?>> classList, File dir, int level)
     throws SQLException, IOException {
   for (File file : dir.listFiles()) {
     if (file.isDirectory()) {
       // recurse if we aren't deep enough
       if (level < maxFindSourceLevel) {
         findAnnotatedClasses(classList, file, level + 1);
       }
       continue;
     }
     // skip non .java files
     if (!file.getName().endsWith(".java")) {
       continue;
     }
     String packageName = getPackageOfClass(file);
     if (packageName == null) {
       System.err.println("Could not find package name for: " + file);
       continue;
     }
     // get the filename and cut off the .java
     String name = file.getName();
     name = name.substring(0, name.length() - ".java".length());
     String className = packageName + "." + name;
     Class<?> clazz;
     try {
       clazz = Class.forName(className);
     } catch (Throwable t) {
       // amazingly, this sometimes throws an Error
       System.err.println("Could not load class file for: " + file);
       System.err.println("     " + t);
       continue;
     }
     if (classHasAnnotations(clazz)) {
       classList.add(clazz);
     }
     // handle inner classes
     try {
       for (Class<?> innerClazz : clazz.getDeclaredClasses()) {
         if (classHasAnnotations(innerClazz)) {
           classList.add(innerClazz);
         }
       }
     } catch (Throwable t) {
       // amazingly, this sometimes throws an Error
       System.err.println("Could not load inner classes for: " + clazz);
       System.err.println("     " + t);
       continue;
     }
   }
 }
コード例 #17
0
ファイル: YBEffect.java プロジェクト: KingBowser/YiffBukkit
  @SuppressWarnings("unchecked")
  public static YBEffect createTrail(Class<? extends YBEffect> effectClass, Entity entity)
      throws YiffBukkitCommandException {
    if (!effectClass.getAnnotation(EffectProperties.class).potionTrail()) return new NullEffect();

    // Class.forName(effectClass.getCanonicalName()+".PotionTrail");
    for (Class<?> enclosedClass : effectClass.getDeclaredClasses()) {
      if (enclosedClass.getSimpleName().equals("PotionTrail"))
        return create((Class<? extends YBEffect>) enclosedClass, entity);
    }

    throw new YiffBukkitCommandException(
        "Effect doesn't have a PotionTrail enclosed class but is flagged as having one.");
  }
コード例 #18
0
ファイル: KotlinTestUtils.java プロジェクト: yilab/kotlin
 private static void assertTestClassPresentByMetadata(
     @NotNull Class<?> outerClass, @NotNull File testDataDir) {
   for (Class<?> nestedClass : outerClass.getDeclaredClasses()) {
     TestMetadata testMetadata = nestedClass.getAnnotation(TestMetadata.class);
     if (testMetadata != null && testMetadata.value().equals(getFilePath(testDataDir))) {
       return;
     }
   }
   Assert.fail(
       "Test data directory missing from the generated test class: "
           + testDataDir
           + "\n"
           + PLEASE_REGENERATE_TESTS);
 }
コード例 #19
0
ファイル: JProxyEngine.java プロジェクト: sillelien/dollar
  private void reloadSource(
      @NotNull ClassDescriptorSourceUnit sourceFile, boolean detectInnerClasses) {
    Class clasz = customClassLoader.loadClass(sourceFile, true);

    LinkedList<ClassDescriptorInner> innerClassDescList = sourceFile.getInnerClassDescriptors();
    if (innerClassDescList != null && !innerClassDescList.isEmpty()) {
      for (ClassDescriptorInner innerClassDesc : innerClassDescList) {
        customClassLoader.loadClass(innerClassDesc, true);
      }
    } else if (detectInnerClasses) {
      // Aprovechando la carga de la clase, hacemos el esfuerzo de cargar todas las clases
      // dependientes lo más
      // posible
      clasz
          .getDeclaredClasses(); // Provoca que las inner clases miembro indirectamente se procesen
                                 // y carguen
      // a través del JProxyClassLoader de la clase padre clasz

      // Ahora bien, lo anterior NO sirve para las anonymous inner classes, afortunadamente en ese
      // caso podemos
      // conocer y cargar por fuerza bruta
      // http://stackoverflow.com/questions/1654889/java-reflection-how-can-i-retrieve-anonymous-inner-classes
      // ?rq=1

      for (int i = 1; i < Integer.MAX_VALUE; i++) {
        String anonClassName = sourceFile.getClassName() + "$" + i;
        Class innerClasz = customClassLoader.loadInnerClass(sourceFile, anonClassName);
        if (innerClasz == null) {
          break; // No hay más o no hay ninguna (si i es 1)
        }
      }

      // ¿Qué es lo que queda por cargar pero que no podemos hacer explícitamente?
      // 1) Las clases privadas autónomas que fueron definidas en el mismo archivo que la clase
      // principal: no
      // las soportamos pues no podemos identificar en el ClassLoader que es una clase "hot
      // reloadable", no son
      // inner classes en el sentido estricto
      // 2) Las clases privadas "inner" locales, es decir no anónimas declaradas dentro de un
      // método, se
      // cargarán la primera vez que se usen, no podemos conocerlas a priori
      //    porque siguen la notación className$NclassName  ej.
      // JReloadExampleDocument$1AuxMemberInMethod. No
      // hay problema con que se carguen con un class loader antiguo pues
      //    el ClassLoader de la clase padre contenedora será el encargado de cargarla en cuanto se
      // pase por el
      // método que la declara.
    }
  }
コード例 #20
0
  private Operator<?>[] getSelfContainedOperators() {
    final List<Operator<?>> result = new ArrayList<>();

    for (Class<?> c : ClassUtils.hierarchy(getClass(), interfacesPolicy)) {
      for (Class<?> inner : c.getDeclaredClasses()) {
        if (Operator.class.isAssignableFrom(inner)) {
          final Operator<?> operator = newInstance(inner.asSubclass(Operator.class));
          if (operator != null) {
            result.add(operator);
          }
        }
      }
    }
    return result.toArray(new Operator[result.size()]);
  }
コード例 #21
0
  // Verify that all the fields of the inner classes of |R| have a valid mapping.
  // This ensures that if a resource is added upstream, we won't miss providing
  // a mapping downstream.
  private static void verifyFields(Class<?> R) {
    for (Class<?> c : R.getDeclaredClasses()) {
      verifyFields(c); // recursively check inner classes.
    }

    for (Field f : R.getDeclaredFields()) {
      try {
        if (f.getInt(null) == 0) {
          throw new RuntimeException(
              "Missing resource mapping for " + R.getName() + "." + f.getName());
        }
      } catch (IllegalAccessException e) {
      }
    }
  }
コード例 #22
0
ファイル: ClassTest.java プロジェクト: GodsLeft/JavaTest
  public static void main(String[] args) throws Exception {
    Class<ClassTest> clazz = ClassTest.class;

    System.out.println("=============================================");
    Constructor[] ctors = clazz.getDeclaredConstructors();
    System.out.println("classTest的全部构造器如下:");
    for (Constructor c : ctors) {
      System.out.println(c);
    }

    System.out.println("=============================================");
    Constructor[] publicCtors = clazz.getConstructors();
    System.out.println("ClassTest的全部public构造器如下:");
    for (Constructor c : publicCtors) {
      System.out.println(c);
    }

    System.out.println("=============================================");
    Method[] mtds = clazz.getMethods();
    System.out.println("ClassTest的全部public方法如下:");
    for (Method md : mtds) {
      System.out.println(md);
    }

    System.out.println("=============================================");
    System.out.println("ClassTest带一个字符串参数的info方法为:" + clazz.getMethod("info", String.class));

    Annotation[] ans = clazz.getAnnotations();
    System.out.println("ClassTest的全部annotation为:");
    for (Annotation an : ans) {
      System.out.println(an);
    }
    System.out.println("该元素上的@SuppressWarnings注释为:" + clazz.getAnnotation(SuppressWarnings.class));

    System.out.println("=============================================");
    Class<?>[] inners = clazz.getDeclaredClasses();
    System.out.println("ClassTest的全部内部类如下:");
    for (Class c : inners) {
      System.out.println(c);
    }

    System.out.println("=============================================");

    Class inClazz = Class.forName("ClassTest$Inner");
    System.out.println("inClazz对应的外部类为:" + inClazz.getDeclaringClass());
    System.out.println("ClassTest的包为:" + clazz.getPackage());
    System.out.println("ClassTest的父类:" + clazz.getSuperclass());
  }
コード例 #23
0
ファイル: IOUtil.java プロジェクト: nagyist/bonita-engine
 public static Map<String, byte[]> getResources(final Class<?>... classes) throws IOException {
   if (classes == null || classes.length == 0) {
     final String message = "No classes available";
     throw new IOException(message);
   }
   final Map<String, byte[]> resources = new HashMap<String, byte[]>();
   for (final Class<?> clazz : classes) {
     resources.put(
         clazz.getName().replace(".", "/") + ".class", ClassDataUtil.getClassData(clazz));
     for (final Class<?> internalClass : clazz.getDeclaredClasses()) {
       resources.put(
           internalClass.getName().replace(".", "/") + ".class",
           ClassDataUtil.getClassData(internalClass));
     }
   }
   return resources;
 }
コード例 #24
0
  private static String getSelect(final Class<?> klass) throws Exception {

    final SelectFrom from = klass.getAnnotation(SelectFrom.class);
    if (from != null) {
      return getSelectString(klass, from);
    }

    final Class<?>[] klasses = klass.getDeclaredClasses();
    for (int i = 0; i < klasses.length; i++) {
      final String declared = getSelect(klasses[i]);
      if (!TextUtils.isEmpty(declared)) {
        return declared;
      }
    }

    return "";
  }
コード例 #25
0
  /**
   * Recursively finds inner classes of the specified access level in the supplied class and
   * superclasses.
   *
   * @param c the class to start the search in - nothing is done if this is NULL
   * @param level the access level to look for
   * @param sb the StringBuffer where the results should be added
   */
  private static void recursiveListInnerClasses(Class c, int level, StringBuffer sb) {
    if (c == null) {
      return;
    }

    Class[] innerClasses;
    Class innerClass;
    String clas;

    // ----- Added by Petter for interfaces
    if (level == PUBLIC) {
      // For public access, we can use getClasses() and skip
      // recursion. This ensures that the method works for
      // interface types, and saves some function calls.  XXX -
      // actually, this doesn't work properly, since classes
      // defined in interfaces don't show up here.
      innerClasses = c.getClasses();
    } else {
      innerClasses = c.getDeclaredClasses();
    }
    // ----- End addition by Petter

    for (int index = 0; index < innerClasses.length; index++) {
      innerClass = innerClasses[index];
      if (isAccessible(innerClass.getModifiers(), level)) {
        clas = printClass(innerClass.getName());
        if (sb.toString().lastIndexOf(clas) == -1) {
          sb.append(clas);
        }
      }
    }

    // ----- Addition by Petter to reduce the number of function
    //       calls and not list non-accessible private fields.
    if (!c.isInterface() && level != PRIVATE && level != PUBLIC) {
      // For interfaces, the getSuperClass() method will return
      // nil, and in any case, the only type of access relevant
      // for interfaces is PUBLIC. For PUBLIC access, the
      // getClasses() call has listed all the relevant members.
      // For PRIVATE access, that is only applicable in the
      // calling class anyway, so we shouldn't do recursion.
      recursiveListInnerClasses(c.getSuperclass(), level, sb);
    }
    // ----- End addition by Petter
  }
コード例 #26
0
  private boolean nestedClassRegistration(
      Named owner, Class<?> commands, Object instance, org.spout.api.command.Command parent) {
    boolean success = true, anyRegistered = false;
    for (Class<?> clazz : commands.getDeclaredClasses()) {
      Object subInstance = null;
      if (!Modifier.isStatic(clazz.getModifiers())) {
        try {
          Constructor<?> constr = getClosestConstructor(clazz, commands);
          if (constr == null) {
            continue;
          }

          constr.setAccessible(true);
          subInstance = constr.newInstance(instance);
        } catch (InvocationTargetException e) {
          e.printStackTrace();
          continue;
        } catch (InstantiationException e) {
          e.printStackTrace();
          continue;
        } catch (IllegalAccessException ignore) {
        }
      }

      org.spout.api.command.Command child = createCommand(owner, parent, clazz);
      if (child == null) {
        continue;
      }
      anyRegistered = true;

      if (!nestedClassRegistration(owner, clazz, subInstance, child)) {
        for (Method method : clazz.getDeclaredMethods()) {
          if (!method.isAnnotationPresent(Executor.class)) {
            continue;
          }

          Platform platform = method.getAnnotation(Executor.class).value();
          child.setExecutor(
              platform, executorFactory.getAnnotatedCommandExecutor(subInstance, method));
        }
      }
    }
    return success && anyRegistered;
  }
コード例 #27
0
ファイル: PresenterRef.java プロジェクト: johnhurt/orgama
  public PresenterRef(Class<?> presenterClass) {
    super(presenterClass);
    Class<?>[] internalClasses = presenterClass.getDeclaredClasses();

    for (Class<?> internalClass : internalClasses) {
      if (View.class.isAssignableFrom(internalClass)) {
        viewInterface = internalClass;
        break;
      }
    }

    if (getWrappedClass().isAnnotationPresent(NameToken.class)) {
      nameToken = getWrappedClass().getAnnotation(NameToken.class).value();
    } else {
      nameToken = "";
    }

    this.disableCodeSplitting = getWrappedClass().isAnnotationPresent(DisableCodeSplit.class);
  }
コード例 #28
0
 public static Class<? extends Message> getInnerClass(
     String canonicalParentName, String subclassName) {
   try {
     Class<?> outerClass = Class.forName(canonicalParentName);
     for (Class<?> innerClass : outerClass.getDeclaredClasses()) {
       if (innerClass.getSimpleName().equals(subclassName)) {
         return innerClass.asSubclass(Message.class);
       }
     }
   } catch (ClassNotFoundException e) {
     LOG.error(
         "Could not find class with parent "
             + canonicalParentName
             + " and inner class "
             + subclassName,
         e);
     throw new IllegalArgumentException(e);
   }
   return null;
 }
コード例 #29
0
 public static void PrintInnerClasses(Class<?> cls) {
   System.out.println("Innerclasses for class: " + cls.getName());
   Class<?>[] innerClasses = cls.getDeclaredClasses();
   if (innerClasses.length == 0) {
     System.out.println("- None");
   } else {
     for (Class<?> declaredClass : innerClasses) {
       System.out.println("- " + declaredClass.getName());
       System.out.println("- is enum: " + declaredClass.isEnum());
       //
       if (declaredClass.isEnum()) {
         Class<? extends Enum> enumClass = (Class<? extends Enum>) declaredClass;
       }
       //
       Annotation[] annotations = declaredClass.getAnnotations();
       for (Annotation a : annotations) {
         System.out.println("- - with annotation: " + a.getClass().getName());
       }
     }
   }
 }
コード例 #30
0
    public Collection<SourceClass> getMemberClasses() throws IOException {
      Object sourceToProcess = this.source;
      if (sourceToProcess instanceof Class<?>) {
        Class<?> sourceClass = (Class<?>) sourceToProcess;
        try {
          Class<?>[] declaredClasses = sourceClass.getDeclaredClasses();
          List<SourceClass> members = new ArrayList<SourceClass>(declaredClasses.length);
          for (Class<?> declaredClass : declaredClasses) {
            members.add(asSourceClass(declaredClass));
          }
          return members;
        } catch (NoClassDefFoundError err) {
          // getDeclaredClasses() failed because of non-resolvable dependencies
          // -> fall back to ASM below
          sourceToProcess = metadataReaderFactory.getMetadataReader(sourceClass.getName());
        }
      }

      // ASM-based resolution - safe for non-resolvable classes as well
      MetadataReader sourceReader = (MetadataReader) sourceToProcess;
      String[] memberClassNames = sourceReader.getClassMetadata().getMemberClassNames();
      List<SourceClass> members = new ArrayList<SourceClass>(memberClassNames.length);
      for (String memberClassName : memberClassNames) {
        try {
          members.add(asSourceClass(memberClassName));
        } catch (IOException ex) {
          // Let's skip it if it's not resolvable - we're just looking for candidates
          if (logger.isDebugEnabled()) {
            logger.debug(
                "Failed to resolve member class ["
                    + memberClassName
                    + "] - not considering it as a configuration class candidate");
          }
        }
      }
      return members;
    }