+ /**
+ * HELPER: checkAndWriteEnumTypeJavaStub() writes the enum type (convert from enum to int)
+ */
+ private void checkAndWriteEnumTypeJavaStub(List<String> methParams, List<String> methPrmTypes) {
+
+ // Iterate and find enum declarations
+ for (int i = 0; i < methParams.size(); i++) {
+ String paramType = methPrmTypes.get(i);
+ String param = methParams.get(i);
+ String simpleType = getGenericType(paramType);
+ if (isEnumClass(simpleType)) {
+ // Check if this is enum type
+ if (isArray(param)) { // An array
+ println("int len" + i + " = " + getSimpleIdentifier(param) + ".length;");
+ println("int paramEnum" + i + "[] = new int[len" + i + "];");
+ println("for (int i = 0; i < len" + i + "; i++) {");
+ println("paramEnum" + i + "[i] = " + getSimpleIdentifier(param) + "[i].ordinal();");
+ println("}");
+ } else if (isList(paramType)) { // A list
+ println("int len" + i + " = " + getSimpleIdentifier(param) + ".size();");
+ println("int paramEnum" + i + "[] = new int[len" + i + "];");
+ println("for (int i = 0; i < len" + i + "; i++) {");
+ println("paramEnum" + i + "[i] = " + getSimpleIdentifier(param) + ".get(i).ordinal();");
+ println("}");
+ } else { // Just one element
+ println("int paramEnum" + i + "[] = new int[1];");
+ println("paramEnum" + i + "[0] = " + param + ".ordinal();");
+ }
+ }
+ }
+ }
+
+
+ /**
+ * HELPER: checkAndWriteEnumRetTypeJavaStub() writes the enum return type (convert from enum to int)
+ */
+ private void checkAndWriteEnumRetTypeJavaStub(String retType) {
+
+ // Strips off array "[]" for return type
+ String pureType = getSimpleArrayType(getGenericType(retType));
+ // Take the inner type of generic
+ if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES)
+ pureType = getGenericType(retType);
+ if (isEnumClass(pureType)) {
+ // Check if this is enum type
+ // Enum decoder
+ println("int[] retEnum = (int[]) retObj;");
+ println(pureType + "[] enumVals = " + pureType + ".values();");
+ if (isArray(retType)) { // An array
+ println("int retLen = retEnum.length;");
+ println(pureType + "[] enumRetVal = new " + pureType + "[retLen];");
+ println("for (int i = 0; i < retLen; i++) {");
+ println("enumRetVal[i] = enumVals[retEnum[i]];");
+ println("}");
+ } else if (isList(retType)) { // A list
+ println("int retLen = retEnum.length;");
+ println("List<" + pureType + "> enumRetVal = new ArrayList<" + pureType + ">();");
+ println("for (int i = 0; i < retLen; i++) {");
+ println("enumRetVal.add(enumVals[retEnum[i]]);");
+ println("}");
+ } else { // Just one element
+ println(pureType + " enumRetVal = enumVals[retEnum[0]];");
+ }
+ println("return enumRetVal;");
+ }
+ }
+
+
+ /**
+ * HELPER: checkAndWriteStructSetupJavaStub() writes the struct type setup
+ */
+ private void checkAndWriteStructSetupJavaStub(List<String> methParams, List<String> methPrmTypes,
+ InterfaceDecl intDecl, String method) {
+
+ // Iterate and find struct declarations
+ for (int i = 0; i < methParams.size(); i++) {
+ String paramType = methPrmTypes.get(i);
+ String param = methParams.get(i);
+ String simpleType = getGenericType(paramType);
+ if (isStructClass(simpleType)) {
+ // Check if this is enum type
+ int methodNumId = intDecl.getMethodNumId(method);
+ String helperMethod = methodNumId + "struct" + i;
+ println("int methodIdStruct" + i + " = " + intDecl.getHelperMethodNumId(helperMethod) + ";");
+ println("Class<?> retTypeStruct" + i + " = void.class;");
+ println("Class<?>[] paramClsStruct" + i + " = new Class<?>[] { int.class };");
+ if (isArray(param)) { // An array
+ println("Object[] paramObjStruct" + i + " = new Object[] { " + getSimpleArrayType(param) + ".length };");
+ } else if (isList(paramType)) { // A list
+ println("Object[] paramObjStruct" + i + " = new Object[] { " + getSimpleArrayType(param) + ".size() };");
+ } else { // Just one element
+ println("Object[] paramObjStruct" + i + " = new Object[] { new Integer(1) };");
+ }
+ println("rmiCall.remoteCall(objectId, methodIdStruct" + i +
+ ", retTypeStruct" + i + ", null, paramClsStruct" + i +
+ ", paramObjStruct" + i + ");\n");
+ }
+ }
+ }
+
+
+ /**
+ * HELPER: isStructPresent() checks presence of struct
+ */
+ private boolean isStructPresent(List<String> methParams, List<String> methPrmTypes) {
+
+ // Iterate and find enum declarations
+ for (int i = 0; i < methParams.size(); i++) {
+ String paramType = methPrmTypes.get(i);
+ String param = methParams.get(i);
+ String simpleType = getGenericType(paramType);
+ if (isStructClass(simpleType))
+ return true;
+ }
+ return false;
+ }
+
+
+ /**
+ * HELPER: writeLengthStructParamClassJavaStub() writes lengths of parameters
+ */
+ private void writeLengthStructParamClassJavaStub(List<String> methParams, List<String> methPrmTypes) {
+
+ // Iterate and find struct declarations - count number of params
+ for (int i = 0; i < methParams.size(); i++) {
+ String paramType = methPrmTypes.get(i);
+ String param = methParams.get(i);
+ String simpleType = getGenericType(paramType);
+ if (isStructClass(simpleType)) {
+ int members = getNumOfMembers(simpleType);
+ if (isArray(param)) { // An array
+ String structLen = getSimpleArrayType(param) + ".length";
+ print(members + "*" + structLen);
+ } else if (isList(paramType)) { // A list
+ String structLen = getSimpleArrayType(param) + ".size()";
+ print(members + "*" + structLen);
+ } else
+ print(Integer.toString(members));
+ } else
+ print("1");
+ if (i != methParams.size() - 1) {
+ print("+");
+ }
+ }
+ }
+
+
+ /**
+ * HELPER: writeStructMembersJavaStub() writes parameters of struct
+ */
+ private void writeStructMembersJavaStub(String simpleType, String paramType, String param) {
+
+ // Get the struct declaration for this struct and generate initialization code
+ StructDecl structDecl = getStructDecl(simpleType);
+ List<String> memTypes = structDecl.getMemberTypes(simpleType);
+ List<String> members = structDecl.getMembers(simpleType);
+ if (isArray(param)) { // An array
+ println("for(int i = 0; i < " + getSimpleIdentifier(param) + ".length; i++) {");
+ for (int i = 0; i < members.size(); i++) {
+ String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+ println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+ print("paramObj[pos++] = " + getSimpleIdentifier(param) + "[i].");
+ print(getSimpleIdentifier(members.get(i)));
+ println(";");
+ }
+ println("}");
+ } else if (isList(paramType)) { // A list
+ println("for(int i = 0; i < " + getSimpleIdentifier(param) + ".size(); i++) {");
+ for (int i = 0; i < members.size(); i++) {
+ String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+ println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+ print("paramObj[pos++] = " + getSimpleIdentifier(param) + ".get(i).");
+ print(getSimpleIdentifier(members.get(i)));
+ println(";");
+ }
+ println("}");
+ } else { // Just one struct element
+ for (int i = 0; i < members.size(); i++) {
+ String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+ println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+ print("paramObj[pos++] = " + getSimpleIdentifier(param) + ".");
+ print(getSimpleIdentifier(members.get(i)));
+ println(";");
+ }
+ }
+ }
+
+
+ /**
+ * HELPER: writeStructParamClassJavaStub() writes parameters if struct is present
+ */
+ private void writeStructParamClassJavaStub(List<String> methParams, List<String> methPrmTypes) {
+
+ print("int paramLen = ");
+ writeLengthStructParamClassJavaStub(methParams, methPrmTypes);
+ println(";");
+ println("Object[] paramObj = new Object[paramLen];");
+ println("Class<?>[] paramCls = new Class<?>[paramLen];");
+ println("int pos = 0;");
+ // Iterate again over the parameters
+ for (int i = 0; i < methParams.size(); i++) {
+ String paramType = methPrmTypes.get(i);
+ String param = methParams.get(i);
+ String simpleType = getGenericType(paramType);
+ if (isStructClass(simpleType)) {
+ writeStructMembersJavaStub(simpleType, paramType, param);
+ } else {
+ String prmType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
+ println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+ print("paramObj[pos++] = ");
+ print(getEnumParam(methPrmTypes.get(i), getSimpleIdentifier(methParams.get(i)), i));
+ println(";");
+ }
+ }
+
+ }
+
+
+ /**
+ * HELPER: writeStructRetMembersJavaStub() writes parameters of struct for return statement
+ */
+ private void writeStructRetMembersJavaStub(String simpleType, String retType) {
+
+ // Get the struct declaration for this struct and generate initialization code
+ StructDecl structDecl = getStructDecl(simpleType);
+ List<String> memTypes = structDecl.getMemberTypes(simpleType);
+ List<String> members = structDecl.getMembers(simpleType);
+ if (isArrayOrList(retType, retType)) { // An array or list
+ println("for(int i = 0; i < retLen; i++) {");
+ }
+ if (isArray(retType)) { // An array
+ for (int i = 0; i < members.size(); i++) {
+ String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+ print("structRet[i]." + getSimpleIdentifier(members.get(i)));
+ println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
+ }
+ println("}");
+ } else if (isList(retType)) { // A list
+ println(simpleType + " structRetMem = new " + simpleType + "();");
+ for (int i = 0; i < members.size(); i++) {
+ String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+ print("structRetMem." + getSimpleIdentifier(members.get(i)));
+ println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
+ }
+ println("structRet.add(structRetMem);");
+ println("}");
+ } else { // Just one struct element
+ for (int i = 0; i < members.size(); i++) {
+ String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+ print("structRet." + getSimpleIdentifier(members.get(i)));
+ println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
+ }
+ }
+ println("return structRet;");
+ }
+
+
+ /**
+ * HELPER: writeStructReturnJavaStub() writes parameters if struct is present for return statement
+ */
+ private void writeStructReturnJavaStub(String simpleType, String retType) {
+
+ // Handle the returned struct!!!
+ println("Object retLenObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
+ // Minimum retLen is 1 if this is a single struct object
+ println("int retLen = (int) retLenObj;");
+ int numMem = getNumOfMembers(simpleType);
+ println("Class<?>[] retCls = new Class<?>[" + numMem + "*retLen];");
+ println("Class<?>[] retClsVal = new Class<?>[" + numMem + "*retLen];");
+ println("int retPos = 0;");
+ // Get the struct declaration for this struct and generate initialization code
+ StructDecl structDecl = getStructDecl(simpleType);
+ List<String> memTypes = structDecl.getMemberTypes(simpleType);
+ List<String> members = structDecl.getMembers(simpleType);
+ if (isArrayOrList(retType, retType)) { // An array or list
+ println("for(int i = 0; i < retLen; i++) {");
+ for (int i = 0; i < members.size(); i++) {
+ String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+ println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+ println("retClsVal[retPos++] = null;");
+ }
+ println("}");
+ } else { // Just one struct element
+ for (int i = 0; i < members.size(); i++) {
+ String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+ println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+ println("retClsVal[retPos++] = null;");
+ }
+ }
+ println("Object[] retObj = rmiCall.getStructObjects(retCls, retClsVal);");
+ if (isArray(retType)) { // An array
+ println(simpleType + "[] structRet = new " + simpleType + "[retLen];");
+ println("for(int i = 0; i < retLen; i++) {");
+ println("structRet[i] = new " + simpleType + "();");
+ println("}");
+ } else if (isList(retType)) { // A list
+ println("List<" + simpleType + "> structRet = new ArrayList<" + simpleType + ">();");
+ } else
+ println(simpleType + " structRet = new " + simpleType + "();");
+ println("int retObjPos = 0;");
+ writeStructRetMembersJavaStub(simpleType, retType);
+ }
+
+