public int toModifiers(int modifiers) { switch (this) { case Public: return Modifier.setPublic(modifiers); case Protected: return Modifier.setProtected(modifiers); case Package: return Modifier.setPackage(modifiers); case Private: return Modifier.setPrivate(modifiers); default: throw new IllegalArgumentException("Unknown Visibility?!?!"); } } }
public boolean instrumentMethod(CtClass clazz, CtMethod method) throws InterceptorException { // replace the body of the intercepted method with generated code block int mod = method.getModifiers(); if (Modifier.isPublic(mod)) { method.setModifiers(Modifier.setProtected(mod)); } return true; } }
private void makeDeferConstructorNonPublic(final CtClass clazz) { for (final CtConstructor constr : clazz.getConstructors()) { try { for (CtClass paramType : constr.getParameterTypes()) { if (IndicateReloadClass.class.getName() .equals(paramType.getName())) { /* Found defer constructor ... */ final int modifiers = constr.getModifiers(); if (Modifier.isPublic(modifiers)) { constr.setModifiers(Modifier.setProtected(modifiers)); } break; } } } catch (NotFoundException thereAreNoParameters) { /* ... but to get an exception here seems odd. */ } } } }
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 */ } } }
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; }
private void addMethodToGeneratedAdvisor(MethodTransformation trans, String methodInfoField, String body)throws CannotCompileException, NotFoundException { CtClass genadvisor = ((GeneratedAdvisorInstrumentor)trans.getInstrumentor()).getGenadvisor(); CtClass[] params = addTargetToParamsForNonStaticMethod(trans.getClazz(), trans.getWMethod()); String code = createAdvisorMethodBody(trans); try { CtMethod advisorMethod = CtNewMethod.make( Modifier.PROTECTED, trans.getWMethod().getReturnType(), getAdvisorMethodName(trans), params, trans.getWMethod().getExceptionTypes(), code, genadvisor); genadvisor.addMethod(advisorMethod); advisorMethod.setModifiers(Modifier.setProtected(advisorMethod.getModifiers())); } catch (CannotCompileException e) { throw new RuntimeException("code was: " + code + " for method " + getAdvisorMethodName(trans), e); } }