/** * {@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"); } } } }