@Override public final boolean isAccessible() { return accessibleObject.isAccessible(); }
@Override public final boolean isAccessible() { return accessibleObject.isAccessible(); }
@Override public final boolean isAccessible() { return accessibleObject.isAccessible(); }
/** * changes the accessibleObject accessibility and returns true if accessibility was changed */ public void enableAccess(AccessibleObject accessibleObject) { wasAccessible = accessibleObject.isAccessible(); accessibleObject.setAccessible(true); } }
@Override public final boolean isAccessible() { return accessibleObject.isAccessible(); }
/** * changes the accessibleObject accessibility and returns true if accessibility was changed */ public void enableAccess(AccessibleObject accessibleObject) { wasAccessible = accessibleObject.isAccessible(); accessibleObject.setAccessible(true); } }
/** * Suppress access check against a reflection object. SecurityException is silently ignored. * Checks first if the object is already accessible. */ public static void forceAccess(AccessibleObject accObject){ if (accObject.isAccessible()) { return; } try { accObject.setAccessible(true); } catch (SecurityException sex) { // ignore } }
public static void ensureAccessibility(AccessibleObject accessibleObject) { if ( accessibleObject.isAccessible() ) { return; } accessibleObject.setAccessible( true ); }
private void setAccessible(AccessibleObject obj) { if (obj.isAccessible()) { return; } try { obj.setAccessible(true); } catch (AccessControlException ignored) { } }
private void setAccessible(AccessibleObject obj) { if (obj.isAccessible()) { return; } try { obj.setAccessible(true); } catch (AccessControlException ignored) { } }
public static void makeAccessible(AccessibleObject accessible) { if (!accessible.isAccessible()) { accessible.setAccessible(true); } }
static void setAccessible(AccessibleObject obj){ if(!setAccessibleEnable){ return; } if(obj.isAccessible()){ return; } try{ obj.setAccessible(true); } catch(AccessControlException error){ setAccessibleEnable = false; } }
Method mtd= itr.getClass().getMethod("hasNext"); if(!mtd.isAccessible()) { mtd.setAccessible(true); }
/** * Sets this accessible object to be accessible using the permissions of * the hk2-locator bundle (which will need the required grant) * * @param ao The object to change */ private static void setAccessible(final AccessibleObject ao) { if (ao.isAccessible()) { return; } AccessController.doPrivileged((PrivilegedAction<Object>) () -> { ao.setAccessible(true); return null; }); } }
private static void setAccessible(AccessibleObject accessible) { if (!accessible.isAccessible()) { AccessController.doPrivileged(new SetAccessibleAction(accessible)); } }
@Override public T run() throws Exception { boolean previous = this.accessible.isAccessible(); accessible.setAccessible(true); T output = run(accessible); accessible.setAccessible(previous); return output; }
/** * XXX Default access superclass workaround. * * When a {@code public} class has a default access superclass with {@code public} members, * these members are accessible. Calling them from compiled code works fine. * Unfortunately, on some JVMs, using reflection to invoke these members * seems to (wrongly) prevent access even when the modifier is {@code public}. * Calling {@code setAccessible(true)} solves the problem but will only work from * sufficiently privileged code. Better workarounds would be gratefully * accepted. * @param o the AccessibleObject to set as accessible * @return a boolean indicating whether the accessibility of the object was set to true. */ static boolean setAccessibleWorkaround(final AccessibleObject o) { if (o == null || o.isAccessible()) { return false; } final Member m = (Member) o; if (!o.isAccessible() && Modifier.isPublic(m.getModifiers()) && isPackageAccess(m.getDeclaringClass().getModifiers())) { try { o.setAccessible(true); return true; } catch (final SecurityException e) { // NOPMD // ignore in favor of subsequent IllegalAccessException } } return false; }
/** * Indicates whether the given {@code member} is accessible. It does so by checking whether the member is * non-final and public, or made accessible via reflection. * * @param member The member (field, method, constructor, etc) to check for accessibility * @return {@code true} if the member is accessible, otherwise {@code false}. */ public static boolean isAccessible(AccessibleObject member) { return member.isAccessible() || (member instanceof Member && isNonFinalPublicMember((Member) member)); }
/** * XXX Default access superclass workaround * * When a public class has a default access superclass with public members, * these members are accessible. Calling them from compiled code works fine. * Unfortunately, on some JVMs, using reflection to invoke these members * seems to (wrongly) to prevent access even when the modifer is public. * Calling setAccessible(true) solves the problem but will only work from * sufficiently privileged code. Better workarounds would be gratefully * accepted. * @param o the AccessibleObject to set as accessible */ static void setAccessibleWorkaround(AccessibleObject o) { if (o == null || o.isAccessible()) { return; } Member m = (Member) o; if (Modifier.isPublic(m.getModifiers()) && isPackageAccess(m.getDeclaringClass().getModifiers())) { try { o.setAccessible(true); } catch (SecurityException e) { // ignore in favor of subsequent IllegalAccessException } } }
@Override public Object run() throws Exception { boolean accessible = AbstractAttribute.this.accessible.isAccessible(); if (!accessible) { AbstractAttribute.this.accessible.setAccessible(true); } try { return AbstractAttribute.this.get(object); } finally { if (!accessible) { AbstractAttribute.this.accessible.setAccessible(false); } } } };