@Override
public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
Type type = extractionContext.getType().getType();
if (!(type instanceof Class)) {
return;
}
Class<?> contractType = (Class<?>) type;
if (!contractType.isInterface()) {
return;
}
if (contractType.getGenericInterfaces().length != 1) {
return;
}
Type superType = contractType.getGenericInterfaces()[0];
if (!(superType instanceof ParameterizedType)) {
return;
}
ParameterizedType parameterizedSuperType = (ParameterizedType) superType;
if (!parameterizedSuperType.getRawType().equals(ModelMap.class)) {
return;
}
ModelType<?> elementType = ModelType.of(parameterizedSuperType.getActualTypeArguments()[0]);
Class<?> proxyImpl = generator.generate(ModelMapGroovyDecorator.Managed.class, contractType);
extractionContext.found(
new SpecializedMapSchema<T>(extractionContext.getType(), elementType, proxyImpl));
}
@Override
protected <R> ModelSchema<R> createSchema(
ModelSchemaExtractionContext<R> extractionContext,
Iterable<ModelProperty<?>> properties,
Set<WeaklyTypeReferencingMethod<?, ?>> nonPropertyMethods,
Iterable<ModelSchemaAspect> aspects) {
boolean annotated = extractionContext.getType().isAnnotationPresent(UnmanagedStruct.class);
return new UnmanagedImplStructSchema<R>(
extractionContext.getType(), properties, nonPropertyMethods, aspects, annotated);
}
private <T, E> ModelSchemaExtractionResult<T> gettModelSchemaExtractionResult(
ModelSchemaExtractionContext<T> extractionContext,
final ModelSchemaCache cache,
ModelType<E> elementType,
final ModelSchemaStore store) {
ModelCollectionSchema<T, E> schema =
ModelSchema.collection(
extractionContext.getType(),
elementType,
new Function<ModelCollectionSchema<T, E>, NodeInitializer>() {
@Override
public NodeInitializer apply(ModelCollectionSchema<T, E> input) {
final ManagedChildNodeCreatorStrategy<E> childCreator =
new ManagedChildNodeCreatorStrategy<E>(store);
return new ProjectionOnlyNodeInitializer(
ModelMapModelProjection.managed(input.getElementType(), childCreator));
}
});
ModelSchemaExtractionContext<?> typeParamExtractionContext =
extractionContext.child(
elementType,
"element type",
new Action<ModelSchemaExtractionContext<?>>() {
public void execute(ModelSchemaExtractionContext<?> context) {
ModelType<?> elementType = context.getType();
ModelSchema<?> typeParamSchema = cache.get(elementType);
if (!typeParamSchema.getKind().isManaged()) {
throw new InvalidManagedModelElementTypeException(
context.getParent(),
String.format(
"cannot create a model map of type %s as it is not a %s type.",
elementType, Managed.class.getName()));
}
}
});
return new ModelSchemaExtractionResult<T>(schema, ImmutableList.of(typeParamExtractionContext));
}
protected <R> ModelSchema<R> createSchema(
final ModelSchemaExtractionContext<R> extractionContext,
Iterable<ModelPropertyExtractionResult<?>> propertyResults,
Iterable<ModelSchemaAspect> aspects) {
Iterable<ModelProperty<?>> properties =
Iterables.transform(
propertyResults,
new Function<ModelPropertyExtractionResult<?>, ModelProperty<?>>() {
@Override
public ModelProperty<?> apply(ModelPropertyExtractionResult<?> propertyResult) {
return propertyResult.getProperty();
}
});
return new UnmanagedImplStructSchema<R>(extractionContext.getType(), properties, aspects);
}
public <T> ModelSchemaExtractionResult<T> extract(
ModelSchemaExtractionContext<T> extractionContext,
ModelSchemaStore store,
final ModelSchemaCache cache) {
ModelType<T> type = extractionContext.getType();
if (MODEL_MAP_MODEL_TYPE.isAssignableFrom(type)) {
if (!type.getRawClass().equals(ModelMap.class)) {
throw new InvalidManagedModelElementTypeException(
extractionContext,
String.format("subtyping %s is not supported.", ModelMap.class.getName()));
}
if (type.isHasWildcardTypeVariables()) {
throw new InvalidManagedModelElementTypeException(
extractionContext,
String.format("type parameter of %s cannot be a wildcard.", ModelMap.class.getName()));
}
List<ModelType<?>> typeVariables = type.getTypeVariables();
if (typeVariables.isEmpty()) {
throw new InvalidManagedModelElementTypeException(
extractionContext,
String.format("type parameter of %s has to be specified.", ModelMap.class.getName()));
}
ModelType<?> elementType = typeVariables.get(0);
if (MODEL_MAP_MODEL_TYPE.isAssignableFrom(elementType)) {
throw new InvalidManagedModelElementTypeException(
extractionContext,
String.format(
"%1$s cannot be used as type parameter of %1$s.", ModelMap.class.getName()));
}
return gettModelSchemaExtractionResult(extractionContext, cache, elementType, store);
} else {
return null;
}
}
