@Override
public Collection<MetaClass> provideTypesToExpose() {
final Set<MetaClass> types = new HashSet<MetaClass>();
for (final MetaClass metaClass : ClassScanner.getTypesAnnotatedWith(Remote.class)) {
for (final MetaMethod method : metaClass.getDeclaredMethods()) {
if (!method.getReturnType().isVoid()) {
types.add(method.getReturnType().getErased());
}
for (final MetaParameter parameter : method.getParameters()) {
final MetaClass type = parameter.getType();
types.add(type.getErased());
final MetaParameterizedType parameterizedType = type.getParameterizedType();
if (parameterizedType != null) {
for (final MetaType tp : parameterizedType.getTypeParameters()) {
if (tp instanceof MetaClass) {
types.add(((MetaClass) tp).getErased());
}
}
}
}
}
}
return types;
}
BuildMetaClass make(final String proxyClassName,
final MetaClass toProxy,
final String privateAccessorType) {
final ClassStructureBuilder builder;
final boolean renderEqualsAndHash;
if (!toProxy.isInterface()) {
renderEqualsAndHash = true;
if (toProxy.isFinal()) {
throw new UnproxyableClassException(toProxy, toProxy.getFullyQualifiedName()
+ " is an unproxiable class because it is final");
}
if (!toProxy.isDefaultInstantiable()) {
throw new UnproxyableClassException(toProxy, toProxy.getFullyQualifiedName() + " must have a default " +
"no-arg constructor");
}
builder = ClassBuilder.define(proxyClassName, toProxy).publicScope().body();
}
else {
renderEqualsAndHash = false;
builder = ClassBuilder.define(proxyClassName).publicScope().implementsInterface(toProxy).body();
}
final String proxyVar = "$$_proxy_$$";
final Set<String> renderedMethods = new HashSet<String>();
final Map<String, MetaType> typeVariableMap = new HashMap<String, MetaType>();
final MetaParameterizedType metaParameterizedType = toProxy.getParameterizedType();
if (metaParameterizedType != null) {
int i = 0;
for (final MetaTypeVariable metaTypeVariable : toProxy.getTypeParameters()) {
typeVariableMap.put(metaTypeVariable.getName(), metaParameterizedType.getTypeParameters()[i++]);
}
}
builder.privateField(proxyVar, toProxy).finish();
final Set<Map.Entry<String, ProxyProperty>> entries = proxyProperties.entrySet();
for (final Map.Entry<String, ProxyProperty> entry : entries) {
builder.privateField(entry.getValue().getEncodedProperty(), entry.getValue().getType()).finish();
builder.packageMethod(void.class, "$set_" + entry.getKey(), Parameter.of(entry.getValue().getType(), "o"))
.append(Stmt.loadVariable(entry.getValue().getEncodedProperty()).assignValue(Refs.get("o")))
.finish();
}
for (final MetaMethod method : toProxy.getMethods()) {
final String methodString = GenUtil.getMethodString(method);
if (renderedMethods.contains(methodString) || method.getName().equals("hashCode")
|| (method.getName().equals("equals") && method.getParameters().length == 1
&& method.getParameters()[0].getType().getFullyQualifiedName().equals(Object.class.getName()))) continue;
renderedMethods.add(methodString);
if ((!method.isPublic() && !method.isProtected()) ||
method.isSynthetic() ||
method.isFinal() ||
method.isStatic() ||
method.getDeclaringClass().getFullyQualifiedName().equals(Object.class.getName()))
continue;
final List<Parameter> methodParms = new ArrayList<Parameter>();
final MetaParameter[] parameters = method.getParameters();
for (int i = 0; i < parameters.length; i++) {
methodParms.add(Parameter.of(parameters[i].getType().getErased(), "a" + i));
}
final DefParameters defParameters = DefParameters.fromParameters(methodParms);
final BlockBuilder methBody = builder.publicMethod(method.getReturnType(), method.getName())
.annotatedWith(OVERRIDE_ANNOTATION)
.parameters(defParameters)
.throws_(method.getCheckedExceptions());
methBody.appendAll(getAroundInvokeStatements(method));
methBody.appendAll(getBeforeStatements(method));
final List<Parameter> parms = defParameters.getParameters();
final Statement[] statementVars = new Statement[parms.size()];
for (int i = 0; i < parms.size(); i++) {
statementVars[i] = loadVariable(parms.get(i).getName());
}
if (!method.isPublic()) {
PrivateAccessUtil.addPrivateAccessStubs(privateAccessorType, builder, method, new Modifier[0]);
final Statement[] privateAccessStmts = new Statement[statementVars.length + 1];
privateAccessStmts[0] = Refs.get(proxyVar);
System.arraycopy(statementVars, 0, privateAccessStmts, 1, statementVars.length);
if (method.getReturnType().isVoid()) {
methBody._(loadVariable("this").invoke(PrivateAccessUtil.getPrivateMethodName(method), privateAccessStmts));
}
else {
methBody._(loadVariable("this").invoke(PrivateAccessUtil.getPrivateMethodName(method), privateAccessStmts).returnValue());
}
}
else {
if (method.getReturnType().isVoid()) {
methBody._(loadVariable(proxyVar).invoke(method, statementVars));
}
else {
methBody._(loadVariable(proxyVar).invoke(method, statementVars).returnValue());
}
}
methBody.appendAll(getAfterStatements(method));
methBody.appendAll(getAroundInvokeStatements(method));
methBody.finish();
}
if (renderEqualsAndHash) {
// implement hashCode()
builder.publicMethod(int.class, "hashCode")
.annotatedWith(OVERRIDE_ANNOTATION)
.body()
._(
If.isNull(loadVariable(proxyVar))
._(throw_(IllegalStateException.class, "call to hashCode() on an unclosed proxy."))
.finish()
.else_()
._(Stmt.loadVariable(proxyVar).invoke("hashCode").returnValue())
.finish()
)
.finish();
// implements equals()
builder.publicMethod(boolean.class, "equals", Parameter.of(Object.class, "o"))
.annotatedWith(OVERRIDE_ANNOTATION)
.body()
._(
If.isNull(loadVariable(proxyVar))
._(throw_(IllegalStateException.class, "call to equals() on an unclosed proxy."))
.finish()
.else_()
._(Stmt.loadVariable(proxyVar).invoke("equals", Refs.get("o")).returnValue())
.finish()
)
.finish();
}
builder.publicMethod(void.class, PROXY_BIND_METHOD).parameters(DefParameters.of(Parameter.of(toProxy, "proxy")))
._(loadVariable(proxyVar).assignValue(loadVariable("proxy"))).finish();
return builder.getClassDefinition();
}
@Override
public Statement getBeanInstance(final InjectableInstance injectableInstance) {
final MetaClass type;
final MetaParameterizedType pType;
switch (injectableInstance.getTaskType()) {
case Type:
return null;
case PrivateField:
case Field:
final MetaField field = injectableInstance.getField();
type = field.getType();
pType = type.getParameterizedType();
break;
case Parameter:
final MetaParameter parm = injectableInstance.getParm();
type = parm.getType();
pType = type.getParameterizedType();
break;
default:
throw new RuntimeException("illegal task type: " + injectableInstance.getEnclosingType());
}
final MetaType[] typeArgs = pType.getTypeParameters();
final MetaClass[] typeArgsClasses = new MetaClass[typeArgs.length];
for (int i = 0; i < typeArgs.length; i++) {
final MetaType argType = typeArgs[i];
if (argType instanceof MetaClass) {
typeArgsClasses[i] = (MetaClass) argType;
} else if (argType instanceof MetaParameterizedType) {
typeArgsClasses[i] = (MetaClass) ((MetaParameterizedType) argType).getRawType();
}
}
final Annotation[] qualifiers = injectableInstance.getQualifiers();
final BlockBuilder<?> block =
injectableInstance.getInjectionContext().getProcessingContext().getBlockBuilder();
final MetaClass providerCreationalCallback =
MetaClassFactory.parameterizedAs(
CreationalCallback.class,
MetaClassFactory.typeParametersOf(providerInjector.getInjectedType()));
final String varName =
InjectUtil.getVarNameFromType(
providerInjector.getConcreteInjectedType(), injectableInstance);
final Statement valueRef;
if (providerInjector.isSingleton() && providerInjector.isRendered()) {
valueRef =
Stmt.loadVariable("beanInstance")
.invoke("provide", typeArgsClasses, qualifiers.length != 0 ? qualifiers : null);
} else {
valueRef = Stmt.load(null);
}
block.append(
Stmt.declareFinalVariable(
varName,
providerCreationalCallback,
Stmt.newObject(providerCreationalCallback)
.extend()
.publicOverridesMethod(
"callback", Parameter.of(providerInjector.getInjectedType(), "beanInstance"))
.append(
Stmt.loadVariable(InjectUtil.getVarNameFromType(type, injectableInstance))
.invoke("callback", valueRef))
.append(Stmt.loadVariable("async").invoke("finish", Refs.get("this")))
.finish()
.publicOverridesMethod("toString")
.append(
Stmt.load(providerInjector.getInjectedType()).invoke("getName").returnValue())
.finish()
.finish()));
block.append(Stmt.loadVariable("async").invoke("wait", Refs.get(varName)));
block.append(
Stmt.loadVariable(providerInjector.getCreationalCallbackVarName())
.invoke("getInstance", Refs.get(varName), Refs.get("context")));
return null;
}