private void addCreateFromParcel(JDefinedClass jclass, JDefinedClass creatorClass) {
JMethod createFromParcel = creatorClass.method(JMod.PUBLIC, jclass, "createFromParcel");
JVar in = createFromParcel.param(Parcel.class, "in");
JVar instance = createFromParcel.body().decl(jclass, "instance", JExpr._new(jclass));
suppressWarnings(createFromParcel, "unchecked");
for (JFieldVar f : jclass.fields().values()) {
if ((f.mods().getValue() & JMod.STATIC) == JMod.STATIC) {
continue;
}
if (f.type().erasure().name().equals("List")) {
createFromParcel
.body()
.invoke(in, "readList")
.arg(instance.ref(f))
.arg(JExpr.direct(getGenericType(f.type()) + ".class.getClassLoader()"));
} else {
createFromParcel
.body()
.assign(
instance.ref(f),
JExpr.cast(
f.type(),
in.invoke("readValue")
.arg(JExpr.direct(f.type().erasure().name() + ".class.getClassLoader()"))));
}
}
createFromParcel.body()._return(instance);
}
protected HoldingContainer generateEvalBody(
ClassGenerator<?> g, HoldingContainer[] inputVariables, String body, JVar[] workspaceJVars) {
// g.getBlock().directStatement(String.format("//---- start of eval portion of %s function.
// ----//", functionName));
JBlock sub = new JBlock(true, true);
JBlock topSub = sub;
HoldingContainer out = null;
MajorType returnValueType = returnValue.type;
// add outside null handling if it is defined.
if (nullHandling == NullHandling.NULL_IF_NULL) {
JExpression e = null;
for (HoldingContainer v : inputVariables) {
if (v.isOptional()) {
if (e == null) {
e = v.getIsSet();
} else {
e = e.mul(v.getIsSet());
}
}
}
if (e != null) {
// if at least one expression must be checked, set up the conditional.
returnValueType = returnValue.type.toBuilder().setMode(DataMode.OPTIONAL).build();
out = g.declare(returnValueType);
e = e.eq(JExpr.lit(0));
JConditional jc = sub._if(e);
jc._then().assign(out.getIsSet(), JExpr.lit(0));
sub = jc._else();
}
}
if (out == null) out = g.declare(returnValueType);
// add the subblock after the out declaration.
g.getEvalBlock().add(topSub);
JVar internalOutput =
sub.decl(
JMod.FINAL,
g.getHolderType(returnValueType),
returnValue.name,
JExpr._new(g.getHolderType(returnValueType)));
addProtectedBlock(g, sub, body, inputVariables, workspaceJVars, false);
if (sub != topSub)
sub.assign(internalOutput.ref("isSet"), JExpr.lit(1)); // Assign null if NULL_IF_NULL mode
sub.assign(out.getHolder(), internalOutput);
if (sub != topSub)
sub.assign(internalOutput.ref("isSet"), JExpr.lit(1)); // Assign null if NULL_IF_NULL mode
return out;
}
private void addEquals(JDefinedClass jclass) {
Map<String, JFieldVar> fields = jclass.fields();
if (fields.isEmpty()) {
return;
}
JMethod equals = jclass.method(JMod.PUBLIC, boolean.class, "equals");
JVar otherObject = equals.param(Object.class, "other");
Class<?> equalsBuilder =
ruleFactory.getGenerationConfig().isUseCommonsLang3()
? org.apache.commons.lang3.builder.EqualsBuilder.class
: org.apache.commons.lang.builder.EqualsBuilder.class;
JBlock body = equals.body();
body._if(otherObject.eq(JExpr._this()))._then()._return(JExpr.TRUE);
body._if(otherObject._instanceof(jclass).eq(JExpr.FALSE))._then()._return(JExpr.FALSE);
JVar rhsVar = body.decl(jclass, "rhs").init(JExpr.cast(jclass, otherObject));
JClass equalsBuilderClass = jclass.owner().ref(equalsBuilder);
JInvocation equalsBuilderInvocation = JExpr._new(equalsBuilderClass);
if (!jclass._extends().name().equals("Object")) {
equalsBuilderInvocation =
equalsBuilderInvocation
.invoke("appendSuper")
.arg(JExpr._super().invoke("equals").arg(otherObject));
}
for (JFieldVar fieldVar : fields.values()) {
equalsBuilderInvocation =
equalsBuilderInvocation.invoke("append").arg(fieldVar).arg(rhsVar.ref(fieldVar.name()));
}
JInvocation reflectionEquals =
jclass.owner().ref(equalsBuilder).staticInvoke("reflectionEquals");
reflectionEquals.arg(JExpr._this());
reflectionEquals.arg(otherObject);
body._return(equalsBuilderInvocation.invoke("isEquals"));
equals.annotate(Override.class);
}