proxy.addMethod(wmethod); else if (!Modifier.isProtected(mod) && !Modifier.isPrivate(mod))
/** * Returns true if this member is accessible from the given class. */ public boolean visibleFrom(CtClass clazz) { int mod = getModifiers(); if (Modifier.isPublic(mod)) return true; else if (Modifier.isPrivate(mod)) return clazz == declaringClass; else { // package or protected String declName = declaringClass.getPackageName(); String fromName = clazz.getPackageName(); boolean visible; if (declName == null) visible = fromName == null; else visible = declName.equals(fromName); if (!visible && Modifier.isProtected(mod)) return clazz.subclassOf(declaringClass); return visible; } }
proxy.addMethod(wmethod); else if (!Modifier.isProtected(mod) && !Modifier.isPrivate(mod))
/** * Returns true if this member is accessible from the given class. */ public boolean visibleFrom(CtClass clazz) { int mod = getModifiers(); if (Modifier.isPublic(mod)) return true; else if (Modifier.isPrivate(mod)) return clazz == declaringClass; else { // package or protected String declName = declaringClass.getPackageName(); String fromName = clazz.getPackageName(); boolean visible; if (declName == null) visible = fromName == null; else visible = declName.equals(fromName); if (!visible && Modifier.isProtected(mod)) return clazz.subclassOf(declaringClass); return visible; } }
continue; int modifiers = fi.getField().getModifiers(); if ( ! Modifier.isProtected(modifiers) && ! Modifier.isPublic(modifiers) ) throw new RuntimeException("all fields of a structable class must be public or protected. Field:"+fi.getName()+" in class "+fi.getField().getDeclaringClass().getName() );
continue; int modifiers = fi.getField().getModifiers(); if ( ! Modifier.isProtected(modifiers) && ! Modifier.isPublic(modifiers) ) throw new RuntimeException("all fields of a structable class must be public or protected. Field:"+fi.getName()+" in class "+fi.getField().getDeclaringClass().getName() );
public void addMethod(CtMethod m) throws CannotCompileException { checkModify(); if (m.getDeclaringClass() != this) throw new CannotCompileException("bad declaring class"); int mod = m.getModifiers(); if ((getModifiers() & Modifier.INTERFACE) != 0) { if (Modifier.isProtected(mod) || Modifier.isPrivate(mod)) throw new CannotCompileException( "an interface method must be public: " + m.toString()); m.setModifiers(mod | Modifier.PUBLIC); } getMembers().addMethod(m); getClassFile2().addMethod(m.getMethodInfo2()); if ((mod & Modifier.ABSTRACT) != 0) setModifiers(getModifiers() | Modifier.ABSTRACT); }
@Override public void addMethod(CtMethod m) throws CannotCompileException { checkModify(); if (m.getDeclaringClass() != this) throw new CannotCompileException("bad declaring class"); int mod = m.getModifiers(); if ((getModifiers() & Modifier.INTERFACE) != 0) { if (Modifier.isProtected(mod) || Modifier.isPrivate(mod)) throw new CannotCompileException( "an interface method must be public: " + m.toString()); m.setModifiers(mod | Modifier.PUBLIC); } getMembers().addMethod(m); getClassFile2().addMethod(m.getMethodInfo2()); if ((mod & Modifier.ABSTRACT) != 0) setModifiers(getModifiers() | Modifier.ABSTRACT); }
} else { CtMethod newMethod; if (Modifier.isProtected(modifiers) || Modifier.isPublic(modifiers)) { newMethod = CtNewMethod.copy(method, target, classMap); newMethod.instrument(conv);
private AccessModifier translateAccess(int modifiers) { if (Modifier.isPublic(modifiers)) { return AccessModifier.PUBLIC; } if (Modifier.isProtected(modifiers)) { return AccessModifier.PROTECTED; } if (Modifier.isPrivate(modifiers)) { return AccessModifier.PRIVATE; } return AccessModifier.PACKAGE; }
public static Visibility fromModifiers(int modifiers) { if (Modifier.isPublic(modifiers)) { return Public; } else if (Modifier.isProtected(modifiers)) { return Protected; } else if (Modifier.isPackage(modifiers)) { return Package; } else if (Modifier.isPrivate(modifiers)) { return Private; } else { throw new IllegalArgumentException("Unknown access modifiers?!"); } }
public boolean isAPIModifier(int mod) { if (Modifier.isPublic(mod)) { return (level >= PUBLIC); } else if (Modifier.isProtected(mod)) { return (level >= PROTECTED); } else if (Modifier.isPackage(mod)) { return (level >= PACKAGE); } else if (Modifier.isPrivate(mod)) { return (level >= PRIVATE); } return true; }
private boolean isPublicOrPackageProtectedClass(@Nonnull CtClass clazz) { int modifiers = clazz.getModifiers(); return !Modifier.isAbstract(modifiers) && !Modifier.isAnnotation(modifiers) && !Modifier.isEnum(modifiers) && !Modifier.isPrivate(modifiers) && !Modifier.isProtected(modifiers); }
/** * Returns true if this member is accessible from the given class. */ public boolean visibleFrom(CtClass clazz) { int mod = getModifiers(); if (Modifier.isPublic(mod)) return true; else if (Modifier.isPrivate(mod)) return clazz == declaringClass; else { // package or protected String declName = declaringClass.getPackageName(); String fromName = clazz.getPackageName(); boolean visible; if (declName == null) visible = fromName == null; else visible = declName.equals(fromName); if (!visible && Modifier.isProtected(mod)) return clazz.subclassOf(declaringClass); return visible; } }
private void restoreOriginalConstructorsAccesses(CtClass clazz) throws Exception { Class<?> originalClass = getTestClass().getName().equals(clazz.getName()) ? getTestClass() : Class.forName(clazz.getName(), true, getTestClass().getClassLoader()); for (final CtConstructor ctConstr : clazz.getConstructors()) { int ctModifiers = ctConstr.getModifiers(); if (!Modifier.isPublic(ctModifiers)) { /* Probably a defer-constructor */ continue; } int desiredAccessModifiers = originalClass.getDeclaredConstructor( asOriginalClassParams(ctConstr.getParameterTypes())).getModifiers(); if (Modifier.isPrivate(desiredAccessModifiers)) { ctConstr.setModifiers(Modifier.setPrivate(ctModifiers)); } else if (Modifier.isProtected(desiredAccessModifiers)) { ctConstr.setModifiers(Modifier.setProtected(ctModifiers)); } else if (!Modifier.isPublic(desiredAccessModifiers)) { ctConstr.setModifiers(Modifier.setPackage(ctModifiers)); } else { /* ctConstr remains public */ } } }
/** * Returns true if this member is accessible from the given class. */ public boolean visibleFrom(CtClass clazz) { int mod = getModifiers(); if (Modifier.isPublic(mod)) return true; else if (Modifier.isPrivate(mod)) return clazz == declaringClass; else { // package or protected String declName = declaringClass.getPackageName(); String fromName = clazz.getPackageName(); boolean visible; if (declName == null) visible = fromName == null; else visible = declName.equals(fromName); if (!visible && Modifier.isProtected(mod)) return clazz.subclassOf(declaringClass); return visible; } }
/** * Returns true if this member is accessible from the given class. */ public boolean visibleFrom(CtClass clazz) { int mod = getModifiers(); if (Modifier.isPublic(mod)) return true; else if (Modifier.isPrivate(mod)) return clazz == declaringClass; else { // package or protected String declName = declaringClass.getPackageName(); String fromName = clazz.getPackageName(); boolean visible; if (declName == null) visible = fromName == null; else visible = declName.equals(fromName); if (!visible && Modifier.isProtected(mod)) return clazz.subclassOf(declaringClass); return visible; } }
/** * Returns true if this member is accessible from the given class. */ public boolean visibleFrom(CtClass clazz) { int mod = getModifiers(); if (Modifier.isPublic(mod)) return true; else if (Modifier.isPrivate(mod)) return clazz == declaringClass; else { // package or protected String declName = declaringClass.getPackageName(); String fromName = clazz.getPackageName(); boolean visible; if (declName == null) visible = fromName == null; else visible = declName.equals(fromName); if (!visible && Modifier.isProtected(mod)) return clazz.subclassOf(declaringClass); return visible; } }
/** * Returns true if this member is accessible from the given class. */ public boolean visibleFrom(CtClass clazz) { int mod = getModifiers(); if (Modifier.isPublic(mod)) return true; else if (Modifier.isPrivate(mod)) return clazz == declaringClass; else { // package or protected String declName = declaringClass.getPackageName(); String fromName = clazz.getPackageName(); boolean visible; if (declName == null) visible = fromName == null; else visible = declName.equals(fromName); if (!visible && Modifier.isProtected(mod)) return clazz.subclassOf(declaringClass); return visible; } }
public int mergedModifiers() { int modifiers = getModifiers(versions.lastEntry().getValue()); int andFlags = -1; int orFlags = 0; for (T v : versions.values()) { int x = getModifiers(v); andFlags &= x; orFlags |= x; } //Least-acessible mode between all versions if (Modifier.isPrivate(orFlags)) { modifiers = Modifier.setPrivate(modifiers); } else if (Modifier.isPackage(orFlags)) { modifiers = Modifier.setPackage(modifiers); } else if (Modifier.isProtected(orFlags)) { modifiers = Modifier.setProtected(modifiers); } else { modifiers = Modifier.setPublic(modifiers); } // If we mix-up static and non-static versions of the same method (PackageParser.collectCertificates), // we mark it as non-topublic, non-static to force the use of reflection if ( (andFlags & Modifier.STATIC) != (orFlags & Modifier.STATIC) ) { modifiers &= ~Modifier.STATIC; if (Modifier.isPublic(modifiers)) { modifiers = Modifier.setProtected(modifiers); } } return modifiers; }