protected void generateSetObjectKeyMethod(SourcePrinter srcWriter) {
srcWriter.println(
"protected void setObjectKey("
+ getTargetObjectClassName()
+ " object, "
+ getKeyTypeName()
+ " key){");
if (hasCompositeKey()) {
for (int i = 0; i < keyPath.length; i++) {
String k = keyPath[i];
JType jType = JClassUtils.getTypeForProperty(k, targetObjectType);
String setterMethod = JClassUtils.getSetterMethod(k, targetObjectType, jType);
srcWriter.println(
"object."
+ setterMethod
+ "((key==null?null:("
+ jType.getParameterizedQualifiedSourceName()
+ ")key["
+ i
+ "]));");
}
} else {
String k = keyPath[0];
JType jType = JClassUtils.getTypeForProperty(k, targetObjectType);
String setterMethod = JClassUtils.getSetterMethod(k, targetObjectType, jType);
srcWriter.println("object." + setterMethod + "(key);");
}
srcWriter.println("}");
srcWriter.println();
}
/**
* @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 String getFormString(RestMethodInfo methodInfo) {
StringBuilder str = new StringBuilder();
boolean first = true;
JParameter[] parameters = methodInfo.method.getParameters();
try {
for (int i = 0; i < methodInfo.parameterAnnotations.length; i++) {
Annotation[] annotations = methodInfo.parameterAnnotations[i];
for (Annotation annotation : annotations) {
if (annotation instanceof FormParam) {
if (!first) {
str.append("&");
}
first = false;
if (JClassUtils.isSimpleType(parameters[i].getType())) {
buildFormStringForSimpleType(str, ((FormParam) annotation).value());
} else {
buildFormStringForComplexType(
str, parameters[i].getType(), ((FormParam) annotation).value());
}
}
}
}
} catch (UnsupportedEncodingException e) {
throw new CruxGeneratorException(
"Unsupported encoding for parameter name on method ["
+ methodInfo.method.toString()
+ "]");
}
return str.toString();
}
protected void generateDeriveKeyMethod(SourcePrinter srcWriter) {
srcWriter.println(
"protected " + getKeyTypeName() + " getKey(" + getTargetObjectClassName() + " object){");
srcWriter.print("boolean hasKey = ");
boolean first = true;
for (String k : keyPath) {
if (!first) {
srcWriter.print(" || ");
}
String getterMethod = JClassUtils.getGetterMethod(k, targetObjectType);
srcWriter.print("object." + getterMethod + "() != null");
first = false;
}
srcWriter.println(";");
srcWriter.println("if (hasKey){");
srcWriter.print(getKeyTypeName() + " key");
if (hasCompositeKey()) {
srcWriter.println(" = new Object[" + keyPath.length + "];");
int i = 0;
for (String k : keyPath) {
String getterMethod = JClassUtils.getGetterMethod(k, targetObjectType);
srcWriter.print("key [" + i + "] = object." + getterMethod + "();");
i++;
}
} else {
srcWriter.println(
" = object." + JClassUtils.getGetterMethod(keyPath[0], targetObjectType) + "();");
}
srcWriter.println("return key;");
if (autoIncrement) {
if (!getKeyTypeName().equals("Integer")) {
throw new CruxGeneratorException("Auto increment keys can only be used on integer keys");
}
srcWriter.println("} else {");
srcWriter.println("return null;");
} else {
srcWriter.println("} else {");
srcWriter.println("reportError(db.messages.objectStoreDeriveKeyError(name));");
srcWriter.println("return null;");
}
srcWriter.println("}");
srcWriter.println("}");
srcWriter.println();
}
private void generateMethodParamToHeaderCodeForComplexType(
SourcePrinter srcWriter,
String builder,
String headerName,
JType parameterType,
String parameterExpression,
String parameterCheckExpression) {
PropertyInfo[] propertiesInfo =
JClassUtils.extractBeanPropertiesInfo(parameterType.isClassOrInterface());
for (PropertyInfo propertyInfo : propertiesInfo) {
if (JClassUtils.isSimpleType(propertyInfo.getType())) {
generateMethodParamToHeaderCodeForSimpleType(
srcWriter,
builder,
headerName + "." + propertyInfo.getName(),
propertyInfo.getType(),
parameterExpression + "." + propertyInfo.getReadMethod().getName() + "()",
(propertyInfo.getType().isPrimitive() != null
? parameterCheckExpression
: parameterCheckExpression
+ " && "
+ parameterExpression
+ "."
+ propertyInfo.getReadMethod().getName()
+ "()!=null"));
} else {
generateMethodParamToHeaderCodeForComplexType(
srcWriter,
builder,
headerName + "." + propertyInfo.getName(),
propertyInfo.getType(),
parameterExpression + "." + propertyInfo.getReadMethod().getName() + "()",
parameterCheckExpression
+ " && "
+ parameterExpression
+ "."
+ propertyInfo.getReadMethod().getName()
+ "()!=null");
}
}
}
private void buildFormStringForComplexType(StringBuilder str, JType parameterType, String value)
throws UnsupportedEncodingException {
PropertyInfo[] propertiesInfo =
JClassUtils.extractBeanPropertiesInfo(parameterType.isClassOrInterface());
boolean first = true;
for (PropertyInfo propertyInfo : propertiesInfo) {
if (!first) {
str.append("&");
}
first = false;
String parameterName =
(StringUtils.isEmpty(value)
? propertyInfo.getName()
: value + "." + propertyInfo.getName());
if (JClassUtils.isSimpleType(propertyInfo.getType())) {
buildFormStringForSimpleType(str, parameterName);
} else {
buildFormStringForComplexType(str, propertyInfo.getType(), parameterName);
}
}
}
protected String getDataObjectWriteExpression(
JClassType dataObjectType, String bindPath, String value) throws NoSuchFieldException {
StringBuilder writeExpression = new StringBuilder();
String converterVariable = getConverterVariable();
if (converterVariable != null) {
value = converterVariable + ".from(" + value + ")";
}
JClassUtils.buildSetValueExpression(
writeExpression, dataObjectType, bindPath, DATA_OBJECT_VAR_REF, value);
// TODO validate conveter type and expression type here
return writeExpression.toString();
}
protected String getDataObjectReadExpression(JClassType dataObjectType, String bindPath)
throws NoSuchFieldException {
StringBuilder getExpression = new StringBuilder();
bindPathType =
JClassUtils.buildGetValueExpression(
getExpression, dataObjectType, bindPath, DATA_OBJECT_VAR_REF, false, true);
String converterVariable = getConverterVariable();
if (converterVariable != null) {
getExpression.insert(0, converterVariable + ".to(").append(")");
JClassType typeConverterType =
converterType.getOracle().findType(TypeConverter.class.getCanonicalName());
JClassType[] types = JClassUtils.getActualParameterTypes(converterType, typeConverterType);
bindInfoType = types[1];
} else {
bindInfoType = bindPathType;
}
// TODO validate conveter type and expression type here
return "(" + getExpression.toString() + ")";
}
/**
* @param srcWriter
* @param className
*/
private void generateContainerInstatiationMethod(SourcePrinter srcWriter, String className) {
try {
srcWriter.println(
"public "
+ className
+ " get"
+ className.replace('.', '_')
+ "("
+ Scope.class.getCanonicalName()
+ " scope, String subscope){");
JClassType type =
JClassUtils.getType(context.getGeneratorContext().getTypeOracle(), className);
IocConfigImpl<?> iocConfig = (IocConfigImpl<?>) configurations.get(className);
Class<?> providerClass = iocConfig.getProviderClass();
if (providerClass != null) {
srcWriter.println(
className
+ " result = _getScope(scope).getValue(GWT.create("
+ providerClass.getCanonicalName()
+ ".class), "
+ EscapeUtils.quote(className)
+ ", subscope, ");
generateFieldsPopulationCallback(srcWriter, type);
srcWriter.println(");");
} else if (iocConfig.getToClass() != null) {
srcWriter.println(
className
+ " result = _getScope(scope).getValue(new "
+ IocProvider.class.getCanonicalName()
+ "<"
+ className
+ ">(){");
srcWriter.println("public " + className + " get(){");
srcWriter.println(
"return GWT.create(" + iocConfig.getToClass().getCanonicalName() + ".class);");
srcWriter.println("}");
srcWriter.println("}, " + EscapeUtils.quote(className) + ", subscope, ");
generateFieldsPopulationCallback(srcWriter, type);
srcWriter.println(");");
} else {
srcWriter.println(
className
+ " result = _getScope(scope).getValue(new "
+ IocProvider.class.getCanonicalName()
+ "<"
+ className
+ ">(){");
srcWriter.println("public " + className + " get(){");
String instantiationClass = getInstantiationClass(className);
JClassType instantiationType =
context.getGeneratorContext().getTypeOracle().findType(instantiationClass);
if (instantiationType == null) {
throw new CruxGeneratorException("Can not found type: " + instantiationClass);
}
if (instantiationType.isAssignableTo(remoteServiceType)
&& ConfigurationFactory.getConfigurations()
.sendCruxViewNameOnClientRequests()
.equals("true")) {
srcWriter.println(className + " ret = GWT.create(" + instantiationClass + ".class);");
srcWriter.println(
"(("
+ ServiceDefTarget.class.getCanonicalName()
+ ")ret).setRpcRequestBuilder(new "
+ CruxRpcRequestBuilder.class.getCanonicalName()
+ "(getBoundCruxViewId()));");
srcWriter.println("return ret;");
} else {
srcWriter.println("return GWT.create(" + instantiationClass + ".class);");
}
srcWriter.println("}");
srcWriter.println("}, " + EscapeUtils.quote(className) + ", subscope, ");
generateFieldsPopulationCallback(srcWriter, type);
srcWriter.println(");");
}
if (type.isAssignableTo(viewBindableType)) {
srcWriter.println(
"if (scope != "
+ Scope.class.getCanonicalName()
+ "."
+ Scope.SINGLETON.name()
+ " && result.getBoundCruxViewId() == null){");
srcWriter.println("result.bindCruxView(this.getBoundCruxViewId());");
srcWriter.println("}");
}
srcWriter.println("return result;");
srcWriter.println("}");
} catch (NotFoundException e) {
throw new IoCException("IoC Error Class [" + className + "] not found.", e);
}
}
private boolean generateMethodParamToBodyCodeForAnnotatedParameter(
SourcePrinter srcWriter,
String builder,
JParameter[] parameters,
boolean formEncoded,
int i,
Annotation annotation,
JType parameterType,
String parameterName) {
if (annotation instanceof FormParam) {
if (!formEncoded) {
srcWriter.println(
builder
+ ".setHeader(\""
+ HttpHeaderNames.CONTENT_TYPE
+ "\", \"application/x-www-form-urlencoded\");");
formEncoded = true;
}
}
if (JClassUtils.isSimpleType(parameterType)) {
if (annotation instanceof FormParam) {
generateMethodParamToCodeForSimpleType(
srcWriter,
"requestData",
parameterType,
((FormParam) annotation).value(),
parameterName,
(parameterType.isPrimitive() != null ? "true" : parameterName + "!=null"),
annotation);
}
if (annotation instanceof HeaderParam) {
generateMethodParamToHeaderCodeForSimpleType(
srcWriter,
builder,
((HeaderParam) annotation).value(),
parameterType,
parameterName,
(parameterType.isPrimitive() != null ? "true" : parameterName + "!=null"));
}
if (annotation instanceof CookieParam) {
generateMethodParamToCookieCodeForSimpleType(
srcWriter,
((CookieParam) annotation).value(),
parameterType,
parameterName,
(parameterType.isPrimitive() != null ? "true" : parameterName + "!=null"));
}
} else {
if (annotation instanceof FormParam) {
generateMethodParamToCodeForComplexType(
srcWriter,
"requestData",
parameterType,
((FormParam) annotation).value(),
parameterName,
parameterName + "!=null",
annotation);
}
if (annotation instanceof HeaderParam) {
generateMethodParamToHeaderCodeForComplexType(
srcWriter,
builder,
((HeaderParam) annotation).value(),
parameterType,
parameterName,
parameterName + "!=null");
}
if (annotation instanceof CookieParam) {
generateMethodParamToCookieCodeForComplexType(
srcWriter,
((CookieParam) annotation).value(),
parameterType,
parameterName,
parameterName + "!=null");
}
}
return formEncoded;
}