How to use

getClasses

method

in

java.lang.Class

  /**
   * Only called reflectively. Do not use programmatically.
   */
  public Enclosed(Class<?> klass, RunnerBuilder builder) throws Throwable {
    super(builder, klass, klass.getClasses());
  }
}

public static Class[] callGetClasses(Class thiz)
{
  return thiz.getClasses();
}

/**
 * Only called reflectively. Do not use programmatically.
 */
public Enclosed(Class<?> klass, RunnerBuilder builder) throws Throwable {
  super(builder, klass, filterAbstractClasses(klass.getClasses()));
}

private void registerClass(Class<?> cl, XmlClass xmlClass) {
 m_map.put(cl, xmlClass);
 if (includeNestedClasses) {
  for (Class<?> c : cl.getClasses()) {
   if (!m_map.containsKey(c)) {
    registerClass(c, xmlClass);
   }
  }
 }
}

 Class serviceManagerClass = Class.forName("android.os.ServiceManager");
Method getService = serviceManagerClass.getMethod("getService", String.class);
IBinder retbinder = (IBinder) getService.invoke(serviceManagerClass, "statusbar");
Class statusBarClass = Class.forName(retbinder.getInterfaceDescriptor());
Object statusBarObject = statusBarClass.getClasses()[0].getMethod("asInterface", IBinder.class).invoke(null, new Object[] { retbinder });
Method clearAll = statusBarClass.getMethod("toggleRecentApps");
clearAll.setAccessible(true);
clearAll.invoke(statusBarObject);

private void registerClass(Class<?> cl, XmlClass xmlClass) {
 m_map.put(cl, xmlClass);
 if (includeNestedClasses) {
  for (Class<?> c : cl.getClasses()) {
   if (!m_map.containsKey(c)) {
    registerClass(c, xmlClass);
   }
  }
 }
}

private void addRClassValues(PackageResourceTable resourceTable, Class<?> rClass) {
 for (Class innerClass : rClass.getClasses()) {
  String resourceType = innerClass.getSimpleName();
  if (!resourceType.equals("styleable")) {
   for (Field field : innerClass.getDeclaredFields()) {
    if (field.getType().equals(Integer.TYPE) && Modifier.isStatic(field.getModifiers())) {
     int id;
     try {
      id = field.getInt(null);
     } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
     }
     String resourceName = field.getName();
     resourceTable.addResource(id, resourceType, resourceName);
    }
   }
  }
 }
}

public TeXIconBuilder(String tex, Color foregroundColor) throws ClassNotFoundException, NoSuchMethodException,
    SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
    InvocationTargetException {
  // TeXFormula formula = new TeXFormula(latex);
  final Class<?> clTeXFormula = Class.forName("org.scilab.forge.jlatexmath.TeXFormula");
  final Object formula = clTeXFormula.getConstructor(String.class).newInstance(tex);
  // TeXIcon icon = formula.new TeXIconBuilder().setStyle(TeXConstants.STYLE_DISPLAY).setSize(20).build();
  final Class<?> clTeXIconBuilder = clTeXFormula.getClasses()[0];
  final Object builder = clTeXIconBuilder.getConstructors()[0].newInstance(formula);
  clTeXIconBuilder.getMethod("setStyle", int.class).invoke(builder, 0);
  clTeXIconBuilder.getMethod("setSize", float.class).invoke(builder, (float) 20);
  icon = (Icon) clTeXIconBuilder.getMethod("build").invoke(builder);
  final int margin = 1;
  final Insets insets = new Insets(margin, margin, margin, margin);
  icon.getClass().getMethod("setInsets", insets.getClass()).invoke(icon, insets);
  icon.getClass().getMethod("setForeground", foregroundColor.getClass()).invoke(icon, foregroundColor);
}

r = Class.forName(packageName + ".R");
Class[] classes = r.getClasses();
Class desireClass = null;

for (Class innerClass : rClass.getClasses()) {
 if (innerClass.getSimpleName().equals("styleable")) {

Object serviceManagerObject;
telephonyClass = Class.forName(telephonyName);
telephonyStubClass = telephonyClass.getClasses()[0];
serviceManagerClass = Class.forName(serviceManagerName);
serviceManagerNativeClass = Class.forName(serviceManagerNativeName);

  @Test
  public void iteration() throws SecurityException, NoSuchMethodException {
    List<Class<?>> types = new ArrayList<Class<?>>();
//        types.addAll(Arrays.<Class<?>>asList(Alias.class.getClasses()));
    types.addAll(Arrays.asList(Operation.class.getClasses()));
    types.addAll(Arrays.asList(Path.class.getClasses()));
    for (Class<?> innerType : types) {
      if (!innerType.isInterface() && Expression.class.isAssignableFrom(innerType)) {
        Visitor.class.getDeclaredMethod("visit",innerType);
      }
    }
    System.out.println("successful for " + types.size() + " types");
  }

  private Optional<Method> getImplementation(Class<?> type, Method method) {
    return Stream.of(type.getClasses())
        .filter(c -> c.getSimpleName().equals("DefaultImpls"))
        .flatMap(c -> Stream.of(c.getMethods()).filter(m -> m.getName().equals(method.getName())))
        .findAny();
  }
};

for ( Class<?> cmd : Command.class.getClasses() )
for ( Class<?> cmd : IndexCommand.class.getClasses() )

@Test
public void testExpr() {
  for (Class<?> cl : Expression.class.getClasses()) {
    assertTrue(cl.getName(), Expression.class.isAssignableFrom(cl));
  }
}

@Test
public void testPath() {
  for (Class<?> cl : Path.class.getClasses()) {
    assertTrue(cl.getName(), Path.class.isAssignableFrom(cl));
    if (!cl.isInterface()) {
      assertTrue(cl.getName(), Expression.class.isAssignableFrom(cl));
    }
  }
}

@Test
public void test() {
  GenericExporter exporter = new GenericExporter();
  exporter.setTargetFolder(new File("target/" + getClass().getSimpleName()));
  exporter.export(getClass().getClasses());
}

@Test
public void test() {
  GenericExporter exporter = new GenericExporter();
  exporter.setTargetFolder(new File("target/" + getClass().getSimpleName()));
  exporter.export(getClass().getClasses());
}

@SuppressWarnings("unchecked")
@Test
public void patternAvailability() throws IllegalArgumentException, IllegalAccessException {
  Templates ops = new DummyTemplates();
  Set<Field> missing = new HashSet<Field>();
  for (Field field : Ops.class.getFields()) {
    if (field.getType().equals(Operator.class)) {
      Operator op = (Operator) field.get(null);
      if (ops.getTemplate(op) == null) {
        missing.add(field);
      }
    }
  }
  for (Class<?> cl : Ops.class.getClasses()) {
    for (Field field : cl.getFields()) {
      if (field.getType().equals(Operator.class)) {
        Operator op = (Operator) field.get(null);
        if (ops.getTemplate(op) == null) {
          missing.add(field);
        }
      }
    }
  }
  if (!missing.isEmpty()) {
    for (Field field : missing) {
      System.err.println(field.getName());
    }
    fail();
  }
}

  @Test
  public void export() {
    GenericExporter exporter = new GenericExporter();
    exporter.setTargetFolder(new File("target/Generic2Test"));
    exporter.export(Generic2Test.class.getClasses());
  }
}