private <T> CachedRuleSource doExtract(final Class<T> source) {
final ModelType<T> type = ModelType.of(source);
DefaultMethodModelRuleExtractionContext context =
new DefaultMethodModelRuleExtractionContext(type, this);
// TODO - exceptions thrown here should point to some extensive documentation on the concept of
// class rule sources
StructSchema<T> schema = getSchema(source, context);
if (schema == null) {
throw new InvalidModelRuleDeclarationException(context.problems.format());
}
// sort for determinism
Set<Method> methods = new TreeSet<Method>(Ordering.usingToString());
methods.addAll(Arrays.asList(source.getDeclaredMethods()));
ImmutableList.Builder<ModelProperty<?>> implicitInputs = ImmutableList.builder();
ModelProperty<?> target = null;
for (ModelProperty<?> property : schema.getProperties()) {
if (property.isAnnotationPresent(RuleTarget.class)) {
target = property;
} else if (property.isAnnotationPresent(RuleInput.class)
&& !(property.getSchema() instanceof ScalarValueSchema)) {
implicitInputs.add(property);
}
for (WeaklyTypeReferencingMethod<?, ?> method : property.getAccessors()) {
methods.remove(method.getMethod());
}
}
ImmutableList.Builder<ExtractedRuleDetails> rules = ImmutableList.builder();
for (Method method : methods) {
MethodRuleDefinition<?, ?> ruleDefinition =
DefaultMethodRuleDefinition.create(source, method);
ExtractedModelRule rule = getMethodHandler(ruleDefinition, method, context);
if (rule != null) {
rules.add(new ExtractedRuleDetails(ruleDefinition, rule));
}
}
if (context.hasProblems()) {
throw new InvalidModelRuleDeclarationException(context.problems.format());
}
StructBindings<T> bindings = structBindingsStore.getBindings(schema);
if (schema.getProperties().isEmpty()) {
return new StatelessRuleSource(
rules.build(),
Modifier.isAbstract(source.getModifiers())
? new AbstractRuleSourceFactory<T>(schema, bindings, proxyFactory)
: new ConcreteRuleSourceFactory<T>(type));
} else {
return new ParameterizedRuleSource(
rules.build(), target, implicitInputs.build(), schema, bindings, proxyFactory);
}
}
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);
}
}
}