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);
}
}
// the overload of type Object for Groovy coercions: public void setFoo(Object foo)
private void createTypeConvertingSetter(
ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
if (!property.isWritable() || !(property.getSchema() instanceof ScalarValueSchema)) {
return;
}
Class<?> propertyClass = property.getType().getConcreteClass();
Type propertyType = Type.getType(propertyClass);
Class<?> boxedClass =
propertyClass.isPrimitive() ? BOXED_TYPES.get(propertyClass) : propertyClass;
Type boxedType = Type.getType(boxedClass);
Method setter = property.getSetter().getMethod();
MethodVisitor methodVisitor =
declareMethod(
visitor,
setter.getName(),
SET_OBJECT_PROPERTY_DESCRIPTOR,
SET_OBJECT_PROPERTY_DESCRIPTOR);
putThisOnStack(methodVisitor);
putTypeConverterFieldValueOnStack(methodVisitor, generatedType);
// Object converted = $typeConverter.convert(foo, Float.class, false);
methodVisitor.visitVarInsn(ALOAD, 1); // put var #1 ('foo') on the stack
methodVisitor.visitLdcInsn(boxedType); // push the constant Class onto the stack
methodVisitor.visitInsn(
propertyClass.isPrimitive()
? ICONST_1
: ICONST_0); // push int 1 or 0 (interpreted as true or false) onto the stack
methodVisitor.visitMethodInsn(
INVOKEINTERFACE,
TYPE_CONVERTER_TYPE.getInternalName(),
"convert",
COERCE_TO_SCALAR_DESCRIPTOR,
true);
methodVisitor.visitTypeInsn(CHECKCAST, boxedType.getInternalName());
if (propertyClass.isPrimitive()) {
unboxType(methodVisitor, propertyClass);
}
// invoke the typed setter, popping 'this' and 'converted' from the stack
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
setter.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, propertyType),
false);
finishVisitingMethod(methodVisitor);
}
private void writeSetMethod(ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
if (property.isWritable() && property.getSchema() instanceof ScalarValueSchema) {
// TODO - should we support this?
// Adds a void $propName(Object value) method that sets the value
MethodVisitor methodVisitor =
declareMethod(
visitor,
property.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE),
null);
putThisOnStack(methodVisitor);
putFirstMethodArgumentOnStack(methodVisitor);
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
property.getSetter().getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE),
false);
finishVisitingMethod(methodVisitor);
}
}
private void writeConfigureMethod(
ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
if (!property.isWritable() && property.getSchema() instanceof CompositeSchema) {
// Adds a void $propName(Closure<?> cl) method that delegates to model state
MethodVisitor methodVisitor =
declareMethod(
visitor,
property.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, CLOSURE_TYPE),
null);
putStateFieldValueOnStack(methodVisitor, generatedType);
putConstantOnStack(methodVisitor, property.getName());
putFirstMethodArgumentOnStack(methodVisitor);
methodVisitor.visitMethodInsn(
INVOKEINTERFACE,
MODEL_ELEMENT_STATE_TYPE_INTERNAL_NAME,
"apply",
STATE_APPLY_METHOD_DESCRIPTOR,
true);
finishVisitingMethod(methodVisitor);
return;
}
if (!property.isWritable() && property.getSchema() instanceof UnmanagedImplStructSchema) {
UnmanagedImplStructSchema<?> structSchema =
(UnmanagedImplStructSchema<?>) property.getSchema();
if (!structSchema.isAnnotated()) {
return;
}
// Adds a void $propName(Closure<?> cl) method that executes the closure
MethodVisitor methodVisitor =
declareMethod(
visitor,
property.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, CLOSURE_TYPE),
null);
putThisOnStack(methodVisitor);
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
property.getGetters().get(0).getName(),
Type.getMethodDescriptor(Type.getType(property.getType().getConcreteClass())),
false);
putFirstMethodArgumentOnStack(methodVisitor);
methodVisitor.visitMethodInsn(
INVOKESTATIC,
Type.getInternalName(ClosureBackedAction.class),
"execute",
Type.getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE, CLOSURE_TYPE),
false);
finishVisitingMethod(methodVisitor);
return;
}
// Adds a void $propName(Closure<?> cl) method that throws MME, to avoid attempts to convert
// closure to something else
MethodVisitor methodVisitor =
declareMethod(
visitor,
property.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, CLOSURE_TYPE),
null);
putThisOnStack(methodVisitor);
putConstantOnStack(methodVisitor, property.getName());
methodVisitor.visitInsn(Opcodes.ICONST_1);
methodVisitor.visitTypeInsn(Opcodes.ANEWARRAY, OBJECT_TYPE.getInternalName());
methodVisitor.visitInsn(Opcodes.DUP);
methodVisitor.visitInsn(Opcodes.ICONST_0);
putFirstMethodArgumentOnStack(methodVisitor);
methodVisitor.visitInsn(Opcodes.AASTORE);
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
"methodMissing",
METHOD_MISSING_METHOD_DESCRIPTOR,
false);
finishVisitingMethod(methodVisitor);
}