private void writeDelegateMethods(
final ClassVisitor visitor,
final Type generatedType,
StructSchema<?> delegateSchema,
Set<Class<?>> typesToDelegate) {
Class<?> delegateClass = delegateSchema.getType().getConcreteClass();
Type delegateType = Type.getType(delegateClass);
Map<Equivalence.Wrapper<Method>, Map<Class<?>, Method>> methodsToDelegate = Maps.newHashMap();
for (Class<?> typeToDelegate : typesToDelegate) {
for (Method methodToDelegate : typeToDelegate.getMethods()) {
if (ModelSchemaUtils.isIgnoredMethod(methodToDelegate)) {
continue;
}
Equivalence.Wrapper<Method> methodKey = METHOD_EQUIVALENCE.wrap(methodToDelegate);
Map<Class<?>, Method> methodsByReturnType = methodsToDelegate.get(methodKey);
if (methodsByReturnType == null) {
methodsByReturnType = Maps.newHashMap();
methodsToDelegate.put(methodKey, methodsByReturnType);
}
methodsByReturnType.put(methodToDelegate.getReturnType(), methodToDelegate);
}
}
Set<Equivalence.Wrapper<Method>> delegateMethodKeys =
ImmutableSet.copyOf(
Iterables.transform(
Arrays.asList(delegateClass.getMethods()),
new Function<Method, Equivalence.Wrapper<Method>>() {
@Override
public Equivalence.Wrapper<Method> apply(Method method) {
return METHOD_EQUIVALENCE.wrap(method);
}
}));
for (Map.Entry<Equivalence.Wrapper<Method>, Map<Class<?>, Method>> entry :
methodsToDelegate.entrySet()) {
Equivalence.Wrapper<Method> methodKey = entry.getKey();
if (!delegateMethodKeys.contains(methodKey)) {
continue;
}
Map<Class<?>, Method> methodsByReturnType = entry.getValue();
for (Method methodToDelegate : methodsByReturnType.values()) {
writeDelegatedMethod(visitor, generatedType, delegateType, methodToDelegate);
}
}
}
/**
* Generates an implementation of the given managed type.
*
* <p>The generated class will implement/extend the managed type and will:
*
* <ul>
* <li>provide implementations for abstract getters and setters that delegate to model nodes
* <li>provide a `toString()` implementation
* <li>mix-in implementation of {@link ManagedInstance}
* <li>provide a constructor that accepts a {@link ModelElementState}, which will be used to
* implement the above.
* </ul>
*
* In case a delegate schema is supplied, the generated class will also have:
*
* <ul>
* <li>a constructor that also takes a delegate instance
* <li>methods that call through to the delegate instance
* </ul>
*/
public <T, M extends T, D extends T> Class<? extends M> generate(
StructSchema<M> viewSchema, @Nullable StructSchema<D> delegateSchema) {
if (delegateSchema != null
&& Modifier.isAbstract(delegateSchema.getType().getConcreteClass().getModifiers())) {
throw new IllegalArgumentException("Delegate type must be null or a non-abstract type");
}
ClassWriter visitor = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
ModelType<M> viewType = viewSchema.getType();
StringBuilder generatedTypeNameBuilder = new StringBuilder(viewType.getName());
if (delegateSchema != null) {
generatedTypeNameBuilder
.append("$BackedBy_")
.append(delegateSchema.getType().getName().replaceAll("\\.", "_"));
} else {
generatedTypeNameBuilder.append("$Impl");
}
String generatedTypeName = generatedTypeNameBuilder.toString();
Type generatedType = Type.getType("L" + generatedTypeName.replaceAll("\\.", "/") + ";");
Class<M> viewClass = viewType.getConcreteClass();
Class<?> superclass;
final ImmutableSet.Builder<String> interfacesToImplement = ImmutableSet.builder();
final ImmutableSet.Builder<Class<?>> typesToDelegate = ImmutableSet.builder();
typesToDelegate.add(viewClass);
interfacesToImplement.add(MANAGED_INSTANCE_TYPE);
if (viewClass.isInterface()) {
superclass = Object.class;
interfacesToImplement.add(Type.getInternalName(viewClass));
} else {
superclass = viewClass;
}
// TODO:LPTR This should be removed once BinaryContainer is a ModelMap
// We need to also implement all the interfaces of the delegate type because otherwise
// BinaryContainer won't recognize managed binaries as BinarySpecInternal
if (delegateSchema != null) {
ModelSchemaUtils.walkTypeHierarchy(
delegateSchema.getType().getConcreteClass(),
new ModelSchemaUtils.TypeVisitor<D>() {
@Override
public void visitType(Class<? super D> type) {
if (type.isInterface()) {
typesToDelegate.add(type);
interfacesToImplement.add(Type.getInternalName(type));
}
}
});
}
generateProxyClass(
visitor,
viewSchema,
delegateSchema,
interfacesToImplement.build(),
typesToDelegate.build(),
generatedType,
Type.getType(superclass));
ClassLoader targetClassLoader = viewClass.getClassLoader();
if (delegateSchema != null) {
// TODO - remove this once the above is removed
try {
viewClass.getClassLoader().loadClass(delegateSchema.getType().getConcreteClass().getName());
} catch (ClassNotFoundException e) {
// Delegate class is not visible to managed view type -> view type is more general than
// delegate type, so use the delegate classloader instead
targetClassLoader = delegateSchema.getType().getConcreteClass().getClassLoader();
}
}
return defineClass(visitor, targetClassLoader, generatedTypeName);
}
