@Override public boolean isInterface() { return Modifier.isInterface(modifiers); }
public boolean isInterface() { return modifiers >= 0 && Modifier.isInterface(modifiers); }
/** * Checks, whether the class is a proper class, i.e. not abstract or an interface, and not a primitive type. * * @param clazz The class to check. * @return True, if the class is a proper class, false otherwise. */ public static boolean isProperClass(Class<?> clazz) { int mods = clazz.getModifiers(); return !(Modifier.isAbstract(mods) || Modifier.isInterface(mods) || Modifier.isNative(mods)); }
/** * Determine if the given class is declared abstract. * * @param clazz The class to check. * @return True if the class is abstract, false otherwise. */ public static boolean isAbstractClass(Class clazz) { int modifier = clazz.getModifiers(); return Modifier.isAbstract(modifier) || Modifier.isInterface(modifier); }
protected boolean isAbstract(Class<?> type) { int modifiers = type.getModifiers(); return Modifier.isAbstract(modifiers) || Modifier.isInterface(modifiers); }
protected boolean isConcrete(Class<?> type) { int modifiers = type.getModifiers(); return !Modifier.isAbstract(modifiers) && !Modifier.isInterface(modifiers); }
public boolean isInterface() { return Modifier.isInterface(getModifiers()); }
public boolean isInterface() { return Modifier.isInterface(getModifiers()); }
static <T> void checkDSCls(Class<? extends T> dsCls, Class<T> t) throws OperationFailedException { if (Modifier.isInterface(dsCls.getModifiers()) || Modifier.isAbstract(dsCls.getModifiers())) { throw SUBSYSTEM_DATASOURCES_LOGGER.notAValidDataSourceClass(dsCls.getName(), t.getName()); } }
public static boolean isModule(Class<?> classZ, EntryDeterminer determiner) { int classModify = classZ.getModifiers(); if (!Modifier.isPublic(classModify) || Modifier.isAbstract(classModify) || Modifier.isInterface(classModify)) return false; for (Method method : classZ.getMethods()) if (determiner.isEntry(classZ, method)) return true; return false; }
@Override public T createInstance() { if(Modifier.isAbstract(type.getModifiers()) || Modifier.isInterface(type.getModifiers()) ) { return null; } else { checkKryoInitialized(); try { return kryo.newInstance(type); } catch(Throwable e) { return null; } } }
private void checkModifiers(int modifiers) { if (Modifier.isAbstract(modifiers) || Modifier.isInterface(modifiers) || ! Modifier.isPublic((modifiers))) { throw new ELException("Imported class must be public, and cannot be abstract or an interface"); } } }
public static BugCheckerInfo create(Class<? extends BugChecker> checker) { BugPattern pattern = checkNotNull( checker.getAnnotation(BugPattern.class), "BugCheckers must be annotated with @BugPattern"); checkArgument( !(Modifier.isAbstract(checker.getModifiers()) || Modifier.isInterface(checker.getModifiers())), "%s must be a concrete class", checker); try { BugPatternValidator.validate(pattern); } catch (ValidationException e) { throw new IllegalStateException(e); } return new BugCheckerInfo(checker, pattern); }
private static void verifyModifiers(final String className, final short flags, final Collection<MdbValidityStatus> mdbComplianceIssueList) { // must *not* be an interface if (Modifier.isInterface(flags)) { EjbLogger.DEPLOYMENT_LOGGER.mdbClassCannotBeAnInterface(className); mdbComplianceIssueList.add(MdbValidityStatus.MDB_CANNOT_BE_AN_INTERFACE); } // bean class must be public, must *not* be abstract or final if (!Modifier.isPublic(flags) || Modifier.isAbstract(flags) || Modifier.isFinal(flags)) { EjbLogger.DEPLOYMENT_LOGGER.mdbClassMustBePublicNonAbstractNonFinal(className); mdbComplianceIssueList.add(MdbValidityStatus.MDB_CLASS_CANNOT_BE_PRIVATE_ABSTRACT_OR_FINAL); } }
@Override @SuppressWarnings("unchecked") public <T> Class<T> getInstanceType(Class<T> beanClass) { Mapper<T> mapper = realTypeMapper.get(beanClass); if (null != mapper) { return mapper.getTarget(); } mapper = initCache(beanClass); if (mapper != null) { return mapper.getTarget(); } return Modifier.isAbstract(beanClass.getModifiers()) || Modifier.isInterface(beanClass.getModifiers()) ? null : beanClass; }
private void getAllAsyncListenerClasses(CompositeIndex index, Set<String> classes) { if (index != null) { Set<ClassInfo> classInfos = index.getAllKnownImplementors(ASYNC_LISTENER_INTERFACE); for (ClassInfo classInfo : classInfos) { if(!Modifier.isAbstract(classInfo.flags()) && !Modifier.isInterface(classInfo.flags())) { classes.add(classInfo.name().toString()); } } } } }
@Override public ObjectDeserializer getDeserializer(Type type) { ObjectDeserializer derializer = getDeserializers().get(type); if (derializer != null) { return derializer; } if (type instanceof Class) { Class classType = ((Class) type); if (classType.isEnum()) { return super.getDeserializer(type); } checkAutoType(type.getTypeName(), ((Class) type)); if (Modifier.isAbstract(classType.getModifiers()) || Modifier.isInterface(classType.getModifiers())) { Class realType; if (entityFactory != null && (realType = entityFactory.getInstanceType(classType)) != null) { return new JavaBeanDeserializer(this, realType, type); } } else { return new JavaBeanDeserializer(this, classType); } } return super.getDeserializer(type); } };
private void checkAbstractMethodVisibility(ClassNode node) { // we only do check abstract classes (including enums), no interfaces or non-abstract classes if (!isAbstract(node.getModifiers()) || isInterface(node.getModifiers())) return; List<MethodNode> abstractMethods = node.getAbstractMethods(); if (abstractMethods == null || abstractMethods.isEmpty()) return; for (MethodNode method : abstractMethods) { if (method.isPrivate()) { addError("Method '" + method.getName() + "' from " + getDescription(node) + " must not be private as it is declared as an abstract method.", method); } } }
@Override public void invoke( MethodReference method, Expression[] arguments ) { for ( Expression argument : arguments ) { argument.accept( this ); } methodVisitor.visitMethodInsn( INVOKESTATIC, byteCodeName( method.owner() ), method.name(), desc( method ), Modifier.isInterface( method.owner().modifiers() ) ); }
@Override public void invoke( Expression target, MethodReference method, Expression[] arguments ) { target.accept( this ); for ( Expression argument : arguments ) { argument.accept( this ); } if ( Modifier.isInterface( method.owner().modifiers() ) ) { methodVisitor .visitMethodInsn( INVOKEINTERFACE, byteCodeName( method.owner() ), method.name(), desc( method ), true ); } else if ( method.isConstructor() ) { methodVisitor .visitMethodInsn( INVOKESPECIAL, byteCodeName( method.owner() ), method.name(), desc( method ), false ); } else { methodVisitor .visitMethodInsn( INVOKEVIRTUAL, byteCodeName( method.owner() ), method.name(), desc( method ), false ); } }