/** * This should only be called for non-public methods. This method forces a * private accessor to be generated for the method. Dispatches to variable * {@code instance}. * * @param method * A method, static or non-static. * @param params * Statements for the values to be passed in as parameters. * @return A statement for accessing invoking the given method. */ public ContextualStatementBuilder exposedMethodStmt(final MetaMethod method, final Statement... params) { if (!method.isPublic()) { addExposedMethod(method); } return DecorableType.METHOD.getAccessStatement(method, factory, params); }
/** * This should only be called for non-public methods. This method forces a * private accessor to be generated for the method. * * @param instance * A statement for the instance on which this method will be called. * @param method * A non-static method. * @param params * Statements for the values to be passed in as parameters. * @return A statement for accessing invoking the given method. */ public ContextualStatementBuilder exposedMethodStmt(final Statement instance, final MetaMethod method, final Statement... params) { if (!method.isPublic()) { addExposedMethod(method); } return DecorableType.METHOD.call(instance, method, factory, params); }
private void runDecorators(final Injectable injectable, final InjectionContext injectionContext, final ClassStructureBuilder<?> bodyBlockBuilder) { final MetaClass type = injectable.getInjectedType(); final Set<HasAnnotations> privateAccessors = new HashSet<>(); final List<DecoratorRunnable> decoratorRunnables = new ArrayList<>(); decoratorRunnables.addAll(generateDecoratorRunnablesForType(injectionContext, type, ElementType.FIELD, bodyBlockBuilder, privateAccessors, injectable)); decoratorRunnables.addAll(generateDecoratorRunnablesForType(injectionContext, type, ElementType.PARAMETER, bodyBlockBuilder, privateAccessors, injectable)); decoratorRunnables.addAll(generateDecoratorRunnablesForType(injectionContext, type, ElementType.METHOD, bodyBlockBuilder, privateAccessors, injectable)); decoratorRunnables.addAll(generateDecoratorRunnablesForType(injectionContext, type, ElementType.TYPE, bodyBlockBuilder, privateAccessors, injectable)); decoratorRunnables.sort(null); for (final DecoratorRunnable runnable : decoratorRunnables) { runnable.run(); } for (final HasAnnotations annotated : privateAccessors) { if (annotated instanceof MetaField) { controller.addExposedField((MetaField) annotated); } else if (annotated instanceof MetaMethod) { controller.addExposedMethod((MetaMethod) annotated); } } }
/** * For public methods, fields, constructors, and parameters of public methods, * this method does nothing. Otherwise this method generates private * accessors/mutators. In the case of a parameter this method acts as if * called for the declaring method. * * This method is idempotent. * * @param annotated * A method, field, or parameter that may or may not be public. */ public void ensureMemberExposed(final HasAnnotations annotated) { final MetaClassMember member; if (annotated instanceof MetaParameter) { member = ((MetaParameter) annotated).getDeclaringMember(); } else { member = (MetaClassMember) annotated; } if (!member.isPublic()) { if (member instanceof MetaField) { addExposedField((MetaField) member); } else if (member instanceof MetaMethod) { addExposedMethod((MetaMethod) member); } else if (member instanceof MetaConstructor) { addExposedConstructor((MetaConstructor) member); } } }
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"))); } }
controller.addExposedMethod(setter); final String privateFieldInjectorName = getPrivateMethodName(setter); createInstanceStatements.add(loadVariable("this").invoke(privateFieldInjectorName, loadVariable("instance"), loadVariable(paramLocalVarName)));