public CtConstructor[] getConstructors() { try { return getSuperclass().getConstructors(); } catch (NotFoundException e) { return super.getConstructors(); } } }
@Override public CtConstructor[] getConstructors() { try { return getSuperclass().getConstructors(); } catch (NotFoundException e) { return super.getConstructors(); } } }
CtConstructor[] implConstructors = classPool.get(implClass).getConstructors(); if (implConstructors != null) { for (CtConstructor cons : implConstructors) {
import java.lang.instrument.*; import javassist.*; import java.io.*; import java.security.*; public class InitializerLoggingAgent implements ClassFileTransformer { public static void premain(String agentArgs, Instrumentation inst) { inst.addTransformer(new InitializerLoggingAgent(), true); } private final ClassPool pool = new ClassPool(true); public byte[] transform(ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) { try { if (className.equals("java/lang/ExceptionInInitializerError")) { CtClass klass = pool.makeClass(new ByteArrayInputStream(classfileBuffer)); CtConstructor[] ctors = klass.getConstructors(); for (int i = 0; i < ctors.length; i++) { ctors[i].insertAfter("this.printStackTrace();"); } return klass.toBytecode(); } else { return null; } } catch (Throwable t) { return null; } } }
public CtConstructor[] getConstructors() { try { return getSuperclass().getConstructors(); } catch (NotFoundException e) { return super.getConstructors(); } } }
public CtConstructor[] getConstructors() { try { return getSuperclass().getConstructors(); } catch (NotFoundException e) { return super.getConstructors(); } } }
public CtConstructor[] getConstructors() { try { return getSuperclass().getConstructors(); } catch (NotFoundException e) { return super.getConstructors(); } } }
public CtConstructor[] getConstructors() { try { return getSuperclass().getConstructors(); } catch (NotFoundException e) { return super.getConstructors(); } } }
public CtConstructor[] getConstructors() { try { return getSuperclass().getConstructors(); } catch (NotFoundException e) { return super.getConstructors(); } } }
boolean canInstantiate(CtClass classReference) { for (CtConstructor ctConstructor : classReference.getConstructors()) { if (isValidConstructor(classReference, ctConstructor)) { return true; } } return false; }
private boolean modifyClassConstructors(CtClass ctClass) throws ClassNotFoundException, CannotCompileException { CtConstructor[] constructors = ctClass.getConstructors(); boolean workDone = false; for (CtConstructor c : constructors) { workDone |= instrumentConstructor(c); } return workDone; }
@Override public List<InternalConstructorDefinition> getConstructors() { return Arrays.stream(ctClass.getConstructors()) .map((c) -> toInternalConstructorDefinition(c, resolver)) .collect(Collectors.toList()); }
@Override public Optional<InternalConstructorDefinition> findConstructor(List<ActualParam> actualParams) { // if this is the compiled version of a turin type we have to handle default parameters if (ctClass.getConstructors().length == 1 && hasDefaultParamAnnotation(ctClass.getConstructors()[0])) { return Optional.of(toInternalConstructorDefinition(ctClass.getConstructors()[0], resolver)); } CtConstructor constructor = JavassistBasedMethodResolution.findConstructorAmongActualParams( actualParams, resolver, Arrays.asList(ctClass.getConstructors())); return Optional.of(toInternalConstructorDefinition(constructor, resolver)); }
public List<ResolvedConstructorDeclaration> getConstructors() { return Arrays.stream(ctClass.getConstructors()) .map(m -> new JavassistConstructorDeclaration(m, typeSolver)).collect(Collectors.toList()); }
public List<ResolvedConstructorDeclaration> getConstructors() { return Arrays.stream(ctClass.getConstructors()) .map(m -> new JavassistConstructorDeclaration(m, typeSolver)).collect(Collectors.toList()); }
public List<ResolvedConstructorDeclaration> getConstructors() { return Arrays.stream(ctClass.getConstructors()) .map(m -> new JavassistConstructorDeclaration(m, typeSolver)).collect(Collectors.toList()); }
public static void disassemble(CtClass clazz, PrintStream out, boolean evenSuperclassMethods) { out.println("Class " + clazz.getName()); for (CtConstructor ctor : clazz.getConstructors()) try { disassemble(ctor.toMethod(ctor.getName(), clazz), out); } catch (CannotCompileException e) { e.printStackTrace(out); } for (CtMethod method : clazz.getDeclaredMethods()) if (evenSuperclassMethods || method.getDeclaringClass().equals(clazz)) disassemble(method, out); }
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. */ } } } }
/** * Disassembles all methods of a class, optionally including superclass * methods. * * @param fullName the class name * @param out the output stream * @param evenSuperclassMethods whether to disassemble methods defined in * superclasses */ public void disassemble(final String fullName, final PrintStream out, final boolean evenSuperclassMethods) { final CtClass clazz = getClass(fullName); out.println("Class " + clazz.getName()); for (final CtConstructor ctor : clazz.getConstructors()) { disassemble(ctor, out); } for (final CtMethod method : clazz.getDeclaredMethods()) if (evenSuperclassMethods || method.getDeclaringClass().equals(clazz)) disassemble( method, out); }
private List<? extends FormalParameter> formalParameters(CtConstructor constructor, SymbolResolver resolver) { if (hasDefaultParamAnnotation(constructor)) { return getFormalParametersConsideringDefaultParams(ctClass.getConstructors()[0], resolver); } try { List<FormalParameterSymbol> formalParameters = new ArrayList<>(); MethodInfo methodInfo = constructor.getMethodInfo(); CodeAttribute codeAttribute = methodInfo.getCodeAttribute(); LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag); int i=0; for (CtClass type : constructor.getParameterTypes()) { formalParameters.add(new FormalParameterSymbol(toTypeUsage(type, resolver), attr.variableName(i))); i++; } return formalParameters; } catch (NotFoundException e) { throw new RuntimeException(e); } }