@Override boolean isVisible(int modifiers) { return Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers); } },
/** Return true if the method includes the {@code protected} modifier. */ public boolean isProtected () { return Modifier.isProtected(method.getModifiers()); }
/** Return true if the method includes the {@code protected} modifier. */ public boolean isProtected () { return Modifier.isProtected(method.getModifiers()); }
/** Return true if the field includes the {@code protected} modifier. */ public boolean isProtected () { return Modifier.isProtected(field.getModifiers()); }
/** Return true if the field includes the {@code protected} modifier. */ public boolean isProtected () { return Modifier.isProtected(field.getModifiers()); }
/** Returns true if the element is protected. */ public final boolean isProtected() { return Modifier.isProtected(getModifiers()); }
/** Returns true if fields with {@code modifiers} are included in the emitted JSON. */ private boolean includeField(boolean platformType, int modifiers) { if (Modifier.isStatic(modifiers) || Modifier.isTransient(modifiers)) return false; return Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers) || !platformType; } };
private static String getAccessLevel(int modifiers) { if (Modifier.isPublic(modifiers)) { return "public"; } else if (Modifier.isProtected(modifiers)) { return "protected"; } else if (Modifier.isPrivate(modifiers)) { return "private"; } else { return "default"; } }
private static String modifier(int mod) { StringBuilder modifier = new StringBuilder(); if (Modifier.isPublic(mod)) { modifier.append("public"); } if (Modifier.isProtected(mod)) { modifier.append("protected"); } if (Modifier.isPrivate(mod)) { modifier.append("private"); } if (Modifier.isStatic(mod)) { modifier.append(" static"); } if (Modifier.isVolatile(mod)) { modifier.append(" volatile"); } return modifier.toString(); }
private static String modifier(int mod) { StringBuilder modifier = new StringBuilder(); if (Modifier.isPublic(mod)) { modifier.append("public"); } if (Modifier.isProtected(mod)) { modifier.append("protected"); } if (Modifier.isPrivate(mod)) { modifier.append("private"); } if (Modifier.isStatic(mod)) { modifier.append(" static"); } if (Modifier.isVolatile(mod)) { modifier.append(" volatile"); } return modifier.toString(); }
/** * Determine whether the given method is overridable in the given target class. * @param method the method to check * @param targetClass the target class to check against */ private static boolean isOverridable(Method method, @Nullable Class<?> targetClass) { if (Modifier.isPrivate(method.getModifiers())) { return false; } if (Modifier.isPublic(method.getModifiers()) || Modifier.isProtected(method.getModifiers())) { return true; } return (targetClass == null || getPackageName(method.getDeclaringClass()).equals(getPackageName(targetClass))); }
/** Returns true if the element is protected. */ public final boolean isProtected() { return Modifier.isProtected(getModifiers()); }
@Override public boolean matches(Method m) { return Modifier.isProtected(m.getModifiers()); } });
private static boolean canInclude(boolean isSamePackage, Method method, Map<String, Set<Method>> collected) { int methodModifiers = method.getModifiers(); boolean visible = (Modifier.isPublic(methodModifiers) || Modifier.isProtected(methodModifiers)) || (isSamePackage && !Modifier.isPrivate(methodModifiers)); boolean hasNoInheritanceTraits = !isOverridden(method, collected) && !Modifier.isAbstract(methodModifiers); return visible && hasNoInheritanceTraits; }
/** Returns true if the element is protected. */ public final boolean isProtected() { return Modifier.isProtected(getModifiers()); }
/** * Checks for final methods on the given {@code Class}, as well as package-visible * methods across ClassLoaders, and writes warnings to the log for each one found. */ private void doValidateClass(Class<?> proxySuperClass, @Nullable ClassLoader proxyClassLoader, Set<Class<?>> ifcs) { if (proxySuperClass != Object.class) { Method[] methods = proxySuperClass.getDeclaredMethods(); for (Method method : methods) { int mod = method.getModifiers(); if (!Modifier.isStatic(mod) && !Modifier.isPrivate(mod)) { if (Modifier.isFinal(mod)) { if (implementsInterface(method, ifcs)) { logger.info("Unable to proxy interface-implementing method [" + method + "] because " + "it is marked as final: Consider using interface-based JDK proxies instead!"); } logger.debug("Final method [" + method + "] cannot get proxied via CGLIB: " + "Calls to this method will NOT be routed to the target instance and " + "might lead to NPEs against uninitialized fields in the proxy instance."); } else if (!Modifier.isPublic(mod) && !Modifier.isProtected(mod) && proxyClassLoader != null && proxySuperClass.getClassLoader() != proxyClassLoader) { logger.debug("Method [" + method + "] is package-visible across different ClassLoaders " + "and cannot get proxied via CGLIB: Declare this method as public or protected " + "if you need to support invocations through the proxy."); } } } doValidateClass(proxySuperClass.getSuperclass(), proxyClassLoader, ifcs); } }
public boolean evaluate(Object arg) { int mod = (arg instanceof Member) ? ((Member)arg).getModifiers() : ((Integer)arg).intValue(); if (Modifier.isPrivate(mod)) { return false; } else if (Modifier.isPublic(mod)) { return true; } else if (Modifier.isProtected(mod)) { return protectedOk; } else { return pkg.equals(TypeUtils.getPackageName(Type.getType(((Member)arg).getDeclaringClass()))); } } }
private boolean isValidShadowMethod(Method method) { int modifiers = method.getModifiers(); if (!Modifier.isPublic(modifiers) && !Modifier.isProtected(modifiers)) { return false; } Implementation implementation = getImplementationAnnotation(method); return matchesSdk(implementation); }
/** * Verifies that the actual {@code Class} is protected. * * @param info contains information about the assertion. * @param actual the "actual" {@code Class}. * @throws AssertionError if {@code actual} is {@code null}. * @throws AssertionError if the actual {@code Class} is not protected. */ public void assertIsProtected(AssertionInfo info, Class<?> actual) { assertNotNull(info, actual); if (!Modifier.isProtected(actual.getModifiers())) { throw failures.failure(info, shouldBeProtected(actual)); } }
@Test public void findField() { Field field = ReflectionUtils.findField(TestObjectSubclassWithPublicField.class, "publicField", String.class); assertNotNull(field); assertEquals("publicField", field.getName()); assertEquals(String.class, field.getType()); assertTrue("Field should be public.", Modifier.isPublic(field.getModifiers())); field = ReflectionUtils.findField(TestObjectSubclassWithNewField.class, "prot", String.class); assertNotNull(field); assertEquals("prot", field.getName()); assertEquals(String.class, field.getType()); assertTrue("Field should be protected.", Modifier.isProtected(field.getModifiers())); field = ReflectionUtils.findField(TestObjectSubclassWithNewField.class, "name", String.class); assertNotNull(field); assertEquals("name", field.getName()); assertEquals(String.class, field.getType()); assertTrue("Field should be private.", Modifier.isPrivate(field.getModifiers())); }