private static String getPrivateMemberName(final MetaClassMember member) { if (member instanceof MetaField) { return PrivateAccessUtil.getPrivateFieldAccessorName((MetaField) member); } else { return PrivateAccessUtil.getPrivateMethodName((MetaMethod) member); } }
private static String getPrivateMemberName(final MetaClassMember member) { if (member instanceof MetaField) { return PrivateAccessUtil.getPrivateFieldAccessorName((MetaField) member); } else { return PrivateAccessUtil.getPrivateMethodName((MetaMethod) member); } }
private static String getPrivateMemberName(final MetaClassMember member) { if (member instanceof MetaField) { return PrivateAccessUtil.getPrivateFieldAccessorName((MetaField) member); } else { return PrivateAccessUtil.getPrivateMethodName((MetaMethod) member); } }
/** * This should only be called for non-public constructors. This method forces a * private accessor to be generated for the constructor. * * @param constructor * A non-public constructor. * @return A statement for invoking the given constructor. */ public ContextualStatementBuilder exposedConstructorStmt(final MetaConstructor constructor, final Statement... params) { addExposedConstructor(constructor); return invokeStatic(factory, getPrivateMethodName(constructor), (Object[]) params); }
@Override protected List<Statement> generateInvokePostConstructsStatements(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final DependencyGraph graph, final InjectionContext injectionContext) { final List<Statement> stmts = new ArrayList<>(); final Queue<MetaMethod> postConstructMethods = gatherPostConstructs(injectable); for (final MetaMethod postConstruct : postConstructMethods) { if (postConstruct.isPublic()) { stmts.add(loadVariable("instance").invoke(postConstruct)); } else { controller.ensureMemberExposed(postConstruct); final String accessorName = getPrivateMethodName(postConstruct); stmts.add(invokePrivateAccessorWithNoParams(accessorName)); } } return stmts; }
private void maybeInvokePreDestroys(final Injectable injectable, final List<Statement> destructionStmts, final ClassStructureBuilder<?> bodyBlockBuilder) { final Queue<MetaMethod> preDestroyMethods = gatherPreDestroys(injectable); for (final MetaMethod preDestroy : preDestroyMethods) { if (preDestroy.isPublic()) { destructionStmts.add(loadVariable("instance").invoke(preDestroy)); } else { controller.ensureMemberExposed(preDestroy); final String accessorName = getPrivateMethodName(preDestroy); destructionStmts.add(invokePrivateAccessorWithNoParams(accessorName)); } } }
@Override public ContextualStatementBuilder call(final Statement instance, final HasAnnotations annotated, final BuildMetaClass factory, final Statement... statement) { final MetaMethod method = (MetaMethod) annotated; if (method.isPublic()) { if (method.isStatic()) { return invokeStatic(method.getDeclaringClass(), method.getName(), (Object[]) statement); } else { return nestedCall(instance).invoke(method, (Object[]) statement); } } else { final Object[] params = getParams(method.isStatic(), instance, statement); return invokeStatic(notNull(factory), getPrivateMethodName(method), params); } }
private ContextualStatementBuilder proxyHelperInvocation(final MetaMethod method, final BuildMetaClass factoryClass) { if (method.isPublic()) { return loadVariable("proxiedInstance").invoke(method.getName(), getParametersForInvocation(method)); } else { controller.addExposedMethod(method); return invokeStatic(factoryClass, getPrivateMethodName(method), getParametersForInvocation(method, loadVariable("proxiedInstance"))); } }
public static String initCachedMethod(final ClassStructureBuilder<?> classBuilder, final MetaConstructor c) { createJavaReflectionConstructorInitializerUtilMethod(classBuilder); final String fieldName = PrivateAccessUtil.getPrivateMethodName(c) + "_meth"; classBuilder.privateField(fieldName, Constructor.class).modifiers(Modifier.Static) .initializesWith(Stmt.invokeStatic(classBuilder.getClassDefinition(), JAVA_REFL_CONSTRUCTOR_UTIL_METH, c.getDeclaringClass(), MetaClassFactory.asClassArray(c.getParameters()))).finish(); return fieldName; }
public static String initCachedMethod(final ClassStructureBuilder<?> classBuilder, final MetaConstructor c) { createJavaReflectionConstructorInitializerUtilMethod(classBuilder); final String fieldName = PrivateAccessUtil.getPrivateMethodName(c) + "_meth"; classBuilder.privateField(fieldName, Constructor.class).modifiers(Modifier.Static) .initializesWith(Stmt.invokeStatic(classBuilder.getClassDefinition(), JAVA_REFL_CONSTRUCTOR_UTIL_METH, c.getDeclaringClass(), MetaClassFactory.asClassArray(c.getParameters()))).finish(); return fieldName; }
public static String initCachedMethod(final ClassStructureBuilder<?> classBuilder, final MetaMethod m) { createJavaReflectionMethodInitializerUtilMethod(classBuilder); final String fieldName = PrivateAccessUtil.getPrivateMethodName(m) + "_meth"; classBuilder.privateField(fieldName, Method.class).modifiers(Modifier.Static) .initializesWith(Stmt.invokeStatic(classBuilder.getClassDefinition(), JAVA_REFL_METH_UTIL_METH, m.getDeclaringClass(), m.getName(), MetaClassFactory.asClassArray(m.getParameters()))).finish(); return fieldName; }
public static String initCachedMethod(final ClassStructureBuilder<?> classBuilder, final MetaMethod m) { createJavaReflectionMethodInitializerUtilMethod(classBuilder); final String fieldName = PrivateAccessUtil.getPrivateMethodName(m) + "_meth"; classBuilder.privateField(fieldName, Method.class).modifiers(Modifier.Static) .initializesWith(Stmt.invokeStatic(classBuilder.getClassDefinition(), JAVA_REFL_METH_UTIL_METH, m.getDeclaringClass(), m.getName(), MetaClassFactory.asClassArray(m.getParameters()))).finish(); return fieldName; }
@Override public void makeConstructorAccessible(final ClassStructureBuilder<?> classBuilder, final MetaConstructor constructor) { final DefParameters methodDefParms = DefParameters.from(constructor); Annotation[] annotations = NO_ANNOTATIONS; for (MetaParameter p : constructor.getParameters()) { if (p.getType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } } classBuilder.publicMethod(constructor.getReturnType(), PrivateAccessUtil.getPrivateMethodName(constructor)) .annotatedWith(annotations) .parameters(methodDefParms) .modifiers(Modifier.Static, Modifier.JSNI) .body() ._(StringStatement.of(JSNIUtil.methodAccess(constructor))) .finish(); }
@Override public void makeConstructorAccessible(final ClassStructureBuilder<?> classBuilder, final MetaConstructor constructor) { final DefParameters methodDefParms = DefParameters.from(constructor); Annotation[] annotations = NO_ANNOTATIONS; for (MetaParameter p : constructor.getParameters()) { if (p.getType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } } classBuilder.publicMethod(constructor.getReturnType(), PrivateAccessUtil.getPrivateMethodName(constructor)) .annotatedWith(annotations) .parameters(methodDefParms) .modifiers(Modifier.Static, Modifier.JSNI) .body() ._(StringStatement.of(JSNIUtil.methodAccess(constructor))) .finish(); }
@Override public void makeMethodAccessible(final ClassStructureBuilder<?> classBuilder, final MetaMethod method, final Modifier[] modifiers) { final MetaMethod erasedMethod = method.getDeclaringClass().getErased().getDeclaredMethod(method.getName(), getErasedParamterTypes(method)); final List<Parameter> wrapperDefParms = new ArrayList<Parameter>(); if (!erasedMethod.isStatic()) { wrapperDefParms.add(Parameter.of(erasedMethod.getDeclaringClass().getErased(), "instance")); } final List<Parameter> methodDefParms = DefParameters.from(erasedMethod).getParameters(); wrapperDefParms.addAll(methodDefParms); Annotation[] annotations = NO_ANNOTATIONS; for (MetaParameter p : erasedMethod.getParameters()) { if (p.getType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } } if (erasedMethod.getReturnType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } classBuilder.publicMethod(erasedMethod.getReturnType(), PrivateAccessUtil.getPrivateMethodName(method)) .annotatedWith(annotations) .parameters(DefParameters.fromParameters(wrapperDefParms)) .modifiers(appendJsni(modifiers)) .body() ._(StringStatement.of(JSNIUtil.methodAccess(erasedMethod))) .finish(); }
@Override public void makeMethodAccessible(final ClassStructureBuilder<?> classBuilder, final MetaMethod method, final Modifier[] modifiers) { final MetaMethod erasedMethod = method.getDeclaringClass().getErased().getDeclaredMethod(method.getName(), getErasedParamterTypes(method)); final List<Parameter> wrapperDefParms = new ArrayList<Parameter>(); if (!erasedMethod.isStatic()) { wrapperDefParms.add(Parameter.of(erasedMethod.getDeclaringClass().getErased(), "instance")); } final List<Parameter> methodDefParms = DefParameters.from(erasedMethod).getParameters(); wrapperDefParms.addAll(methodDefParms); Annotation[] annotations = NO_ANNOTATIONS; for (MetaParameter p : erasedMethod.getParameters()) { if (p.getType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } } if (erasedMethod.getReturnType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } classBuilder.publicMethod(erasedMethod.getReturnType(), PrivateAccessUtil.getPrivateMethodName(method)) .annotatedWith(annotations) .parameters(DefParameters.fromParameters(wrapperDefParms)) .modifiers(appendJsni(modifiers)) .body() ._(StringStatement.of(JSNIUtil.methodAccess(erasedMethod))) .finish(); }
final String privateFieldInjectorName = getPrivateMethodName(setter); createInstanceStatements.add(loadVariable("this").invoke(privateFieldInjectorName, loadVariable("instance"), loadVariable(paramLocalVarName))); } else {
@Override public void makeConstructorAccessible(final ClassStructureBuilder<?> classBuilder, final MetaConstructor constructor) { final DefParameters methodDefParms = DefParameters.from(constructor); final String cachedMethod = initCachedMethod(classBuilder, constructor); final Object[] args = new Object[methodDefParms.getParameters().size()]; int i = 0; for (final Parameter p : methodDefParms.getParameters()) { args[i++] = Refs.get(p.getName()); } final BlockBuilder<? extends ClassStructureBuilder> body = classBuilder.publicMethod(constructor.getReturnType(), PrivateAccessUtil.getPrivateMethodName(constructor)) .parameters(methodDefParms) .modifiers(Modifier.Static) .body(); final Statement tryBuilder = Stmt.try_() .append( Stmt.nestedCall( Stmt.castTo(constructor.getReturnType(), Stmt.loadVariable(cachedMethod).invoke("newInstance", (Object) args))).returnValue()) .finish() .catch_(Throwable.class, "e") .append(Stmt.loadVariable("e").invoke("printStackTrace")) .append(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish(); body.append(tryBuilder).finish(); }
@Override public void makeConstructorAccessible(final ClassStructureBuilder<?> classBuilder, final MetaConstructor constructor) { final DefParameters methodDefParms = DefParameters.from(constructor); final String cachedMethod = initCachedMethod(classBuilder, constructor); final Object[] args = new Object[methodDefParms.getParameters().size()]; int i = 0; for (final Parameter p : methodDefParms.getParameters()) { args[i++] = Refs.get(p.getName()); } final BlockBuilder<? extends ClassStructureBuilder> body = classBuilder.publicMethod(constructor.getReturnType(), PrivateAccessUtil.getPrivateMethodName(constructor)) .parameters(methodDefParms) .modifiers(Modifier.Static) .body(); final Statement tryBuilder = Stmt.try_() .append( Stmt.nestedCall( Stmt.castTo(constructor.getReturnType(), Stmt.loadVariable(cachedMethod).invoke("newInstance", (Object) args))).returnValue()) .finish() .catch_(Throwable.class, "e") .append(Stmt.loadVariable("e").invoke("printStackTrace")) .append(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish(); body.append(tryBuilder).finish(); }
PrivateAccessUtil.getPrivateMethodName(method), loadVariable("a0"));