void changeTypeContext(ResolutionContext old, ResolutionContext new_, MethodDeclaration m) {
m.setType(changeTypeContext(old, new_, m.getType()));
m.setBody(
new BlockStmt(
Collections.singletonList(
new ThrowStmt(
new ObjectCreationExpr(
null,
new ClassOrInterfaceType("UnsupportedOperationException"),
Collections.emptyList())))));
NodeUtil.forChildren(
m,
node -> {
Expression scope = node.getScope();
// TODO: Currently guesses that it's a type name if first character is uppercase.
// Should check for fields/variables which match instead
if (scope instanceof NameExpr
&& Character.isUpperCase(((NameExpr) scope).getName().charAt(0))) {
String name = ((NameExpr) scope).getName();
node.setScope(ASTHelper.createNameExpr(new_.typeToString(old.resolve(name))));
}
},
MethodCallExpr.class);
NodeUtil.forChildren(
m,
node -> node.setType(changeTypeContext(old, new_, node.getType())),
VariableDeclarationExpr.class);
NodeUtil.forChildren(
m, node -> node.setType(changeTypeContext(old, new_, node.getType())), TypeExpr.class);
NodeUtil.forChildren(
m,
node -> node.setType(changeTypeContext(old, new_, node.getType())),
com.github.javaparser.ast.body.Parameter.class);
}
private Expression generateCopyExpression(
DefinedParamType type,
String inputParmId,
int inputIndex,
String outputParamId,
int outputIndex) {
// GOAL: ((InputSocket<Mat>) inputs[0]).getValue().assignTo(((OutputSocket<Mat>)
// outputs[0]).getValue());
final ClassOrInterfaceType outputType = new ClassOrInterfaceType("OutputSocket");
final ClassOrInterfaceType inputType = new ClassOrInterfaceType("InputSocket");
outputType.setTypeArgs(Collections.singletonList(type.getType()));
inputType.setTypeArgs(Collections.singletonList(type.getType()));
final MethodCallExpr copyExpression =
new MethodCallExpr(
getOrSetValueExpression(
new EnclosedExpr(new CastExpr(inputType, arrayAccessExpr(inputParmId, inputIndex))),
null),
"assignTo",
Collections.singletonList(
getOrSetValueExpression(
new EnclosedExpr(
new CastExpr(outputType, arrayAccessExpr(outputParamId, outputIndex))),
null)));
copyExpression.setComment(
new BlockComment(
" Sets the value of the input Mat to the output because this operation does not have a destination Mat. "));
return copyExpression;
}
private MethodCallExpr getOrSetValueExpression(Expression scope, Expression setExpression) {
return new MethodCallExpr(
scope,
(setExpression == null ? "getValue" : "setValue"),
(setExpression == null
? Collections.emptyList()
: Collections.singletonList(setExpression)));
}
@Override
public void add(MethodInfo method) {
MethodDeclaration methodDeclaration;
if (method instanceof MethodDeclarationWrapper) {
val wrapper = (MethodDeclarationWrapper) method;
methodDeclaration = (MethodDeclaration) wrapper.declaration.clone();
methodDeclaration.setAnnotations(Collections.emptyList());
wrapper
.getClassInfo()
.changeTypeContext(wrapper.getContext(), getContext(), methodDeclaration);
} else {
methodDeclaration = new MethodDeclaration();
new MethodDeclarationWrapper(methodDeclaration).setAll(method);
}
addMember(methodDeclaration);
}
@Override
public void add(FieldInfo field) {
FieldDeclaration fieldDeclaration;
if (field instanceof FieldDeclarationWrapper) {
val wrapper = (FieldDeclarationWrapper) field;
fieldDeclaration = (FieldDeclaration) wrapper.declaration.clone();
fieldDeclaration.setAnnotations(Collections.emptyList());
changeTypeContext(wrapper.getContext(), getContext(), fieldDeclaration);
} else {
fieldDeclaration = new FieldDeclaration();
val vars = new ArrayList<VariableDeclarator>();
vars.add(new VariableDeclarator(new VariableDeclaratorId("unknown")));
fieldDeclaration.setVariables(vars);
new FieldDeclarationWrapper(fieldDeclaration).setAll(field);
}
addMember(fieldDeclaration);
val result = new FieldDeclarationWrapper(fieldDeclaration);
if (!field.similar(result))
throw new TransformationException(
"After adding to class, didn't match. added: " + field + " result: " + result);
}
@Override
public List<TypeVariable> getTypeVariables() {
return Collections.emptyList();
}
public List<Expression> getSocketAssignments(String inputParamId, String outputParamId) {
List<Expression> assignments = new ArrayList<>();
int inputIndex = 0;
int outputIndex = 0;
for (DefinedParamType paramType : paramTypes) {
// We still need to increment the values if the param is ignored
if (paramType.isIgnored()) continue;
int index;
String paramId;
if (inputParamTypes.contains(paramType) && outputParamTypes.contains(paramType)) {
if (paramType.getType().toStringWithoutComments().contains("Mat")) {
assignments.add(
generateCopyExpression(
paramType,
inputParamId,
inputParamTypes.indexOf(paramType),
outputParamId,
outputParamTypes.indexOf(paramType)));
} else {
throw new IllegalStateException(
"Can not generate Input/Output Socket for type: " + paramType.getType().toString());
}
// We have used the input socket
inputIndex++;
}
// Generate the output socket event if this is an input/output socket
if (outputParamTypes.contains(paramType)) {
paramId = outputParamId;
index = outputIndex;
outputIndex++;
} else if (inputParamTypes.contains(paramType)) {
paramId = inputParamId;
index = inputIndex;
inputIndex++;
} else {
assert false : "The paramType was not in either the input or output list";
return null;
}
final MethodCallExpr getValueExpression = getValueExpression(paramId, index);
final Expression assignExpression;
if (paramType.getType() instanceof PrimitiveType
&& (!((PrimitiveType) paramType.getType())
.getType()
.equals(PrimitiveType.Primitive.Boolean))) {
final String numberConversionFunction;
switch (((PrimitiveType) paramType.getType()).getType()) {
case Int:
numberConversionFunction = "intValue";
break;
case Short:
case Char:
numberConversionFunction = "shortValue";
break;
case Float:
numberConversionFunction = "floatValue";
break;
case Double:
numberConversionFunction = "doubleValue";
break;
case Byte:
numberConversionFunction = "byteValue";
break;
case Long:
numberConversionFunction = "longValue";
break;
default:
throw new IllegalStateException(
"Conversion for type " + paramType.getType() + " is not defined");
}
assignExpression =
new MethodCallExpr(
new EnclosedExpr(
new CastExpr(ASTHelper.createReferenceType("Number", 0), getValueExpression)),
numberConversionFunction);
} else {
assignExpression = new CastExpr(paramType.getTypeBoxedIfPossible(), getValueExpression);
}
assignments.add(
new VariableDeclarationExpr(
ModifierSet.FINAL,
paramType.getType(),
Collections.singletonList(
new VariableDeclarator(
new VariableDeclaratorId(paramType.getName()), assignExpression))));
}
return assignments;
}
