private final void addToLists(
DefinedParamType type,
Map<Type, List<DefinedParamType>> assignmentMap,
List<DefinedParamType> assignmentList) {
assignmentMap.putIfAbsent(type.getType(), new ArrayList<>()); // Will return null if new
assignmentMap.get(type.getType()).add(type);
if (!assignmentList.contains(type)) {
assignmentList.add(type);
}
}
private BlockStmt getInputOrOutputSocketBody(
List<DefinedParamType> paramTypes,
ClassOrInterfaceType socketType,
String inputOrOutputPostfix) {
List<Expression> passedExpressions = new ArrayList<>();
for (DefinedParamType inputParam : paramTypes) {
if (inputParam.isIgnored()) continue;
passedExpressions.add(getSocketListParam(inputParam, socketType, inputOrOutputPostfix));
}
BlockStmt returnStatement =
new BlockStmt(
Arrays.asList(
new ReturnStmt(
new ArrayCreationExpr(
socketType, 1, new ArrayInitializerExpr(passedExpressions)))));
return returnStatement;
}
public List<SocketHintDeclaration> getAllSocketHints() {
List<SocketHintDeclaration> socketHintDeclarations = new ArrayList<>();
for (Type type : inputHintsMap.keySet()) {
socketHintDeclarations.add(
new SocketHintDeclaration(
collector,
type,
inputHintsMap.get(type),
DefinedParamType.DefinedParamDirection.INPUT));
}
for (Type type : outputHintsMap.keySet()) {
socketHintDeclarations.add(
new SocketHintDeclaration(
collector,
type,
outputHintsMap.get(type),
DefinedParamType.DefinedParamDirection.OUTPUT));
}
return socketHintDeclarations;
}
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;
}