How to use

isAnonymousClass

method

in

java.lang.Class

/**
 * {@inheritDoc}
 */
public boolean isAnonymousType() {
  return type.isAnonymousClass();
}

public static boolean callIsAnonymousClass(Class thiz)
{
  return thiz.isAnonymousClass();
}

  public static Class getRealEnumClass(Class enumClass) {
    if (enumClass.isAnonymousClass()) {
      return enumClass.getSuperclass();
    }
    return enumClass;
  }
}

protected void check(Object task) {
  if (task == null) {
    throw new NullPointerException("Task is not defined");
  }
  if (task.getClass().isAnonymousClass()) {
    throw new IllegalArgumentException("Task can't be created using anonymous class");
  }
  if (task.getClass().isMemberClass()
      && !Modifier.isStatic(task.getClass().getModifiers())) {
    throw new IllegalArgumentException("Task class is an inner class and it should be static");
  }
}

private void check(Object task) {
  if (task == null) {
    throw new NullPointerException("Task is not defined");
  }
  if (task.getClass().isAnonymousClass()) {
    throw new IllegalArgumentException("Task can't be created using anonymous class");
  }
  if (task.getClass().isMemberClass()
      && !Modifier.isStatic(task.getClass().getModifiers())) {
    throw new IllegalArgumentException("Task class is an inner class and it should be static");
  }
}

private void check(Object task) {
  if (task == null) {
    throw new NullPointerException("Task is not defined");
  }
  if (task.getClass().isAnonymousClass()) {
    throw new IllegalArgumentException("Task can't be created using anonymous class");
  }
  if (task.getClass().isMemberClass()
      && !Modifier.isStatic(task.getClass().getModifiers())) {
    throw new IllegalArgumentException("Task class is an inner class and it should be static");
  }
}

protected void check(Object task) {
  if (task == null) {
    throw new NullPointerException("Task is not defined");
  }
  if (task.getClass().isAnonymousClass()) {
    throw new IllegalArgumentException("Task can't be created using anonymous class");
  }
  if (task.getClass().isMemberClass()
      && !Modifier.isStatic(task.getClass().getModifiers())) {
    throw new IllegalArgumentException("Task class is an inner class and it should be static");
  }
}

private static boolean isAnonymousClass(Class clazz) {
  final String name = clazz.getName();
  // isAnonymousClass does not work for anonymous Scala classes; additionally check by class name
  if (name.contains("$anon$") || name.contains("$anonfun") || name.contains("$macro$")) {
    return true;
  }
  // calling isAnonymousClass or getSimpleName can throw InternalError for certain Scala types, see https://issues.scala-lang.org/browse/SI-2034
  // until we move to JDK 9, this try-catch is necessary
  try {
    return clazz.isAnonymousClass();
  } catch (InternalError e) {
    return false;
  }
}

/**
 * @deprecated see https://github.com/eclipse-vertx/vert.x/issues/2774
 */
@Deprecated
public static Logger getLogger(final Class<?> clazz) {
 String name = clazz.isAnonymousClass() ?
  clazz.getEnclosingClass().getCanonicalName() :
  clazz.getCanonicalName();
 return getLogger(name);
}

public void register(PlanOptimizer optimizer)
{
  requireNonNull(optimizer, "optimizer is null");
  checkArgument(!optimizer.getClass().isAnonymousClass());
  stats.put(optimizer.getClass(), new OptimizerStats());
}

public void registerAll(Collection<Rule<?>> rules)
{
  for (Rule<?> rule : rules) {
    checkArgument(!rule.getClass().isAnonymousClass());
    stats.put(rule.getClass(), new RuleStats());
  }
}

@Override
public String unambiguousToStringOf(Object obj) {
 return obj == null ? null
   : String.format("%s (%s@%s)",
           toStringOf(obj),
           obj.getClass().isAnonymousClass() ? obj.getClass().getName() : obj.getClass().getSimpleName(),
           toHexString(System.identityHashCode(obj)));
}

public boolean checkClass(Class<?> klass) {
  return !(klass.isInterface()
       || klass.isArray()
       || klass.isEnum()
       || klass.isPrimitive()
       || klass.isMemberClass()
       || klass.isAnnotation()
       || klass.isAnonymousClass());
}

/**
 * get cross platform symbolic class identifier
 * @param cl
 * @return
 */
public String getCPNameForClass( Class cl ) {
  String res = minbinNamesReverse.get(cl.getName());
  if (res == null) {
    if (cl.isAnonymousClass()) {
      return getCPNameForClass(cl.getSuperclass());
    }
    return cl.getName();
  }
  return res;
}

 private static String asTag(Class<?> cls) {
  if (cls.isAnonymousClass()) {
   return asTag(cls.getEnclosingClass());
  }
  return cls.getSimpleName();
 }
}

private static String generateFunctionName(Function function) {
  Class<? extends Function> functionClass = function.getClass();
  if (functionClass.isAnonymousClass()) {
    // getSimpleName returns an empty String for anonymous classes
    Type[] interfaces = functionClass.getInterfaces();
    if (interfaces.length == 0) {
      // extends an existing class (like RichMapFunction)
      Class<?> functionSuperClass = functionClass.getSuperclass();
      return functionSuperClass.getSimpleName() + functionClass.getName().substring(functionClass.getEnclosingClass().getName().length());
    } else {
      // implements a Function interface
      Class<?> functionInterface = functionClass.getInterfaces()[0];
      return functionInterface.getSimpleName() + functionClass.getName().substring(functionClass.getEnclosingClass().getName().length());
    }
  } else {
    return functionClass.getSimpleName();
  }
}

public static ClassName get(Class<?> clazz) {
 checkNotNull(clazz, "clazz == null");
 checkArgument(!clazz.isPrimitive(), "primitive types cannot be represented as a ClassName");
 checkArgument(!void.class.equals(clazz), "'void' type cannot be represented as a ClassName");
 checkArgument(!clazz.isArray(), "array types cannot be represented as a ClassName");
 String anonymousSuffix = "";
 while (clazz.isAnonymousClass()) {
  int lastDollar = clazz.getName().lastIndexOf('$');
  anonymousSuffix = clazz.getName().substring(lastDollar) + anonymousSuffix;
  clazz = clazz.getEnclosingClass();
 }
 String name = clazz.getSimpleName() + anonymousSuffix;
 if (clazz.getEnclosingClass() == null) {
  // Avoid unreliable Class.getPackage(). https://github.com/square/javapoet/issues/295
  int lastDot = clazz.getName().lastIndexOf('.');
  String packageName = (lastDot != -1) ? clazz.getName().substring(0, lastDot) : null;
  return new ClassName(packageName, null, name);
 }
 return ClassName.get(clazz.getEnclosingClass()).nestedClass(name);
}

  @Override
  public boolean apply(Class<?> input) {
    return !input.isAnonymousClass()
        && !input.isMemberClass();
  }
};

private String getAggregatorName(Class<? extends MeasureAggregator> clazz) {
  if (!clazz.isAnonymousClass()) {
    return clazz.getSimpleName();
  }
  String[] parts = clazz.getName().split("\\.");
  return parts[parts.length - 1];
}

  private static void validataSerialVersionUID(Class<?> clazz) {
    // all non-interface types must have a serial version UID
    if (!clazz.isInterface()) {
      assertFalse("Anonymous state handle classes have problematic serialization behavior: " + clazz,
          clazz.isAnonymousClass());

      try {
        Field versionUidField = clazz.getDeclaredField("serialVersionUID");

        // check conditions first via "if" to prevent always constructing expensive error messages
        if (!(Modifier.isPrivate(versionUidField.getModifiers()) &&
            Modifier.isStatic(versionUidField.getModifiers()) &&
            Modifier.isFinal(versionUidField.getModifiers()))) {
          fail(clazz.getName() + " - serialVersionUID is not 'private static final'");
        }
      }
      catch (NoSuchFieldException e) {
        fail("State handle implementation '" + clazz.getName() + "' is missing the serialVersionUID");
      }
    }
  }
}