@SuppressWarnings("deprecation")
private static String getFieldInjectionExpression(
JField field, String iocContainerVariable, Map<String, IocConfig<?>> configurations) {
Inject inject = field.getAnnotation(Inject.class);
if (inject != null) {
JType fieldType = field.getType();
if (!field.isStatic()) {
if (fieldType.isClassOrInterface() != null) {
String fieldTypeName = fieldType.getQualifiedSourceName();
IocConfigImpl<?> iocConfig = (IocConfigImpl<?>) configurations.get(fieldTypeName);
if (iocConfig != null) {
if (inject
.scope()
.equals(org.cruxframework.crux.core.client.ioc.Inject.Scope.DEFAULT)) {
return iocContainerVariable
+ ".get"
+ fieldTypeName.replace('.', '_')
+ "("
+ Scope.class.getCanonicalName()
+ "."
+ iocConfig.getScope().name()
+ ", null)";
}
return iocContainerVariable
+ ".get"
+ fieldTypeName.replace('.', '_')
+ "("
+ Scope.class.getCanonicalName()
+ "."
+ getScopeName(inject.scope())
+ ", "
+ EscapeUtils.quote(inject.subscope())
+ ")";
} else {
return "GWT.create(" + fieldTypeName + ".class)";
}
} else {
throw new IoCException(
"Error injecting field ["
+ field.getName()
+ "] from type ["
+ field.getEnclosingType().getQualifiedSourceName()
+ "]. Primitive fields can not be handled by ioc container.");
}
} else {
throw new IoCException(
"Error injecting field ["
+ field.getName()
+ "] from type ["
+ field.getEnclosingType().getQualifiedSourceName()
+ "]. Static fields can not be handled by ioc container.");
}
}
return null;
}
/**
* @param srcWriter
* @param type
* @param parentVariable
* @param added
* @param iocContainerVariable
* @param configurations
*/
private static void injectFields(
SourcePrinter srcWriter,
JClassType type,
String parentVariable,
Set<String> added,
String iocContainerVariable,
Map<String, IocConfig<?>> configurations) {
for (JField field : type.getFields()) {
String fieldName = field.getName();
if (!added.contains(fieldName)) {
added.add(fieldName);
JType fieldType = field.getType();
if ((fieldType.isPrimitive() == null)) {
String injectionExpression =
getFieldInjectionExpression(field, iocContainerVariable, configurations);
if (injectionExpression != null) {
if (JClassUtils.isPropertyVisibleToWrite(type, field, false)) {
if (JClassUtils.hasSetMethod(field, type)) {
String setterMethodName =
"set" + Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1);
JMethod method = type.findMethod(setterMethodName, new JType[] {field.getType()});
if (method.getAnnotation(Inject.class)
== null) // Annotated methods are handled apart
{
srcWriter.println(
fieldType.getQualifiedSourceName()
+ " field_"
+ fieldName
+ " = "
+ injectionExpression
+ ";");
srcWriter.println(
parentVariable + "." + setterMethodName + "(field_" + fieldName + ");");
}
} else {
srcWriter.println(
parentVariable + "." + fieldName + " = " + injectionExpression + ";");
}
} else {
throw new IoCException(
"IoC Error Field ["
+ field.getName()
+ "] from class ["
+ type.getQualifiedSourceName()
+ "] is not a writeable property.");
}
}
}
}
}
}
/**
* @param dataClass
* @return
*/
private String[] extractIdentifiers(JClassType dataClass) {
List<String> ids = new ArrayList<String>();
JField[] fields = JClassUtils.getDeclaredFields(dataClass);
for (JField field : fields) {
if (field.getAnnotation(DataObjectIdentifier.class) != null) {
if (field.isPublic()) {
ids.add(field.getName());
} else {
ids.add(JClassUtils.getGetterMethod(field.getName(), dataClass) + "()");
}
}
}
return ids.toArray(new String[ids.size()]);
}
private Set<String> getEditorFieldCleanupExpressions() {
Set<String> result = new LinkedHashSet<>();
for (JClassType typeCandidate : model.getEditorType().getFlattenedSupertypeHierarchy()) {
JClassType classType = typeCandidate.isClass();
if (classType != null) {
for (JField field : classType.getFields()) {
JClassType fieldClassOrInterfaceType = field.getType().isClassOrInterface();
if (fieldClassOrInterfaceType != null
// field type assignable to HasCleanup ..
&& fieldClassOrInterfaceType.isAssignableTo(hasCleanupType)
// .. but not assignable to Model
&& !fieldClassOrInterfaceType.isAssignableTo(baseModelType)) {
result.add(
String.format(
"getEditor().%s", //$NON-NLS-1$
field.getName()));
}
}
}
}
return result;
}
public String init(
TypeOracle oracle,
JField targetWidgetField,
JType targetType,
JField targetEntityMember,
JField targetEntityField,
String variable,
List<JField> fields) {
JClassType widgetCollectionType = targetWidgetField.getType().isClassOrInterface();
JClassType entityCollectionType = targetEntityMember.getType().isClassOrInterface();
JParameterizedType paramaterizedType = widgetCollectionType.isParameterized();
if (paramaterizedType == null) {
throw new RuntimeException(
"cannot generateGetField mappers for collection of widgets (the collection is not properly parameterized: eg. List<Widget>)");
}
JClassType widgetType = paramaterizedType.getTypeArgs()[0];
varName =
targetEntityField.getType().isClassOrInterface().getName()
+ targetWidgetField.getName()
+ "Mapper";
if (compiledTemplate == null) {
InputStream istream = this.getClass().getResourceAsStream("CollectionFMGenerator.mv");
compiledTemplate = TemplateCompiler.compileTemplate(istream, null);
}
Map vars = new HashMap();
vars.put("typeOracle", oracle);
vars.put("targetWidgetField", targetWidgetField);
vars.put("targetEntityField", targetEntityField);
vars.put("targetEntityMember", targetEntityMember);
vars.put("widgetType", widgetType);
vars.put("entityCollectionType", entityCollectionType);
vars.put("widgetCollectionType", widgetCollectionType);
vars.put("varName", varName);
return String.valueOf(TemplateRuntime.execute(compiledTemplate, vars));
}
