From b7edf3322fe3f1470a19054bd9826933077f8e91 Mon Sep 17 00:00:00 2001 From: rtrimana Date: Wed, 30 Nov 2016 21:06:13 -0800 Subject: [PATCH] Testing and fixing bugs on enum data types --- config/iotpolicy/testclasspolicy.pol | 10 +- iotjava/iotpolicy/IoTCompiler.java | 186 +++++++++--------- iotjava/iotrmi/C++/basics/TestClass.hpp | 18 +- iotjava/iotrmi/C++/basics/TestClass_Stub.cpp | 13 ++ iotjava/iotrmi/Java/basics/TestClass.java | 18 +- .../iotrmi/Java/basics/TestClass_Stub.java | 6 + 6 files changed, 145 insertions(+), 106 deletions(-) diff --git a/config/iotpolicy/testclasspolicy.pol b/config/iotpolicy/testclasspolicy.pol index 481a284..ddd86d8 100644 --- a/config/iotpolicy/testclasspolicy.pol +++ b/config/iotpolicy/testclasspolicy.pol @@ -24,10 +24,9 @@ public interface TestClassInterface { public List getBooleanList(List in); public List getCharList(List in); - public void registerCallback(CallBackInterface _cb); - public int callBack(); - public Enum handleEnum(Enum en); + public Enum[] handleEnumArray(Enum en[]); + public List handleEnumList(List en); public int getA(); public void setA(int _int); @@ -60,9 +59,10 @@ public interface TestClassInterface { method = "getDoubleList(List in)"; method = "getBooleanList(List in)"; method = "getCharList(List in)"; - method = "registerCallback(CallBackInterface _cb)"; - method = "callBack()"; + method = "handleEnum(Enum en)"; + method = "handleEnumArray(Enum en[])"; + method = "handleEnumList(List en)"; method = "getA()"; method = "setA(int _int)"; method = "setB(float _float)"; diff --git a/iotjava/iotpolicy/IoTCompiler.java b/iotjava/iotpolicy/IoTCompiler.java index ab19e6a..9d9ecdd 100644 --- a/iotjava/iotpolicy/IoTCompiler.java +++ b/iotjava/iotpolicy/IoTCompiler.java @@ -493,15 +493,17 @@ public class IoTCompiler { /** * HELPER: writeJavaInitCallbackPermission() writes the permission for callback */ - private void writeJavaInitCallbackPermission(String intface, InterfaceDecl intDecl) { + private void writeJavaInitCallbackPermission(String intface, InterfaceDecl intDecl, boolean callbackExist) { - String method = "___initCallBack()"; - int methodNumId = intDecl.getHelperMethodNumId(method); - Map> mapNewIntMethods = mapInt2NewInts.get(intface); - for (Map.Entry> intMeth : mapNewIntMethods.entrySet()) { - String newIntface = intMeth.getKey(); - int newObjectId = getNewIntfaceObjectId(newIntface); - println("set" + newObjectId + "Allowed.add(" + methodNumId + ");"); + if (callbackExist) { + String method = "___initCallBack()"; + int methodNumId = intDecl.getHelperMethodNumId(method); + Map> mapNewIntMethods = mapInt2NewInts.get(intface); + for (Map.Entry> intMeth : mapNewIntMethods.entrySet()) { + String newIntface = intMeth.getKey(); + int newObjectId = getNewIntfaceObjectId(newIntface); + println("set" + newObjectId + "Allowed.add(" + methodNumId + ");"); + } } } @@ -558,20 +560,20 @@ public class IoTCompiler { for (int i = 0; i < methParams.size(); i++) { String paramType = methPrmTypes.get(i); String param = methParams.get(i); - String simpleType = getSimpleType(paramType); + String simpleType = getGenericType(paramType); if (isEnumClass(simpleType)) { // Check if this is enum type if (isArray(param)) { // An array - println("int len" + i + " = " + param + ".length;"); - println("int paramEnum" + i + "[] = new int[len];"); + 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] = " + param + "[i].ordinal();"); + println("paramEnum" + i + "[i] = " + getSimpleIdentifier(param) + "[i].ordinal();"); println("}"); } else if (isList(paramType)) { // A list - println("int len" + i + " = " + param + ".size();"); - println("int paramEnum" + i + "[] = new int[len];"); + 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] = " + param + ".get(i).ordinal();"); + println("paramEnum" + i + "[i] = " + getSimpleIdentifier(param) + ".get(i).ordinal();"); println("}"); } else { // Just one element println("int paramEnum" + i + "[] = new int[1];"); @@ -588,10 +590,10 @@ public class IoTCompiler { private void checkAndWriteEnumRetTypeJavaStub(String retType) { // Strips off array "[]" for return type - String pureType = getSimpleArrayType(getSimpleType(retType)); + String pureType = getSimpleArrayType(getGenericType(retType)); // Take the inner type of generic if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) - pureType = getTypeOfGeneric(retType)[0]; + pureType = getGenericType(retType); if (isEnumClass(pureType)) { // Check if this is enum type // Enum decoder @@ -891,16 +893,16 @@ public class IoTCompiler { if (isStructClass(getGenericType(getSimpleArrayType(retType)))) { writeStructReturnJavaStub(getGenericType(getSimpleArrayType(retType)), retType); } else { - // Check if the return value NONPRIMITIVES - if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) { - String[] retGenValType = getTypeOfGeneric(retType); - println("Class retGenValType = " + retGenValType[0] + ".class;"); - println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, retGenValType, paramCls, paramObj);"); - println("return (" + retType + ")retObj;"); - } else if (getParamCategory(retType) == ParamCategory.ENUM) { // This is an enum type + if (getParamCategory(getGenericType(getSimpleArrayType(retType))) == ParamCategory.ENUM) { println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);"); checkAndWriteEnumRetTypeJavaStub(retType); + } else if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) { + // Check if the return value NONPRIMITIVES + String retGenValType = getGenericType(retType); + println("Class retGenValType = " + retGenValType + ".class;"); + println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, retGenValType, paramCls, paramObj);"); + println("return (" + retType + ")retObj;"); } else { println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);"); println("return (" + retType + ")retObj;"); @@ -1246,14 +1248,14 @@ public class IoTCompiler { /** * HELPER: writeConstructorJavaSkeleton() writes the constructor of the skeleton class */ - private void writeConstructorJavaSkeleton(String newSkelClass, String intface, InterfaceDecl intDecl, Collection methods) { + private void writeConstructorJavaSkeleton(String newSkelClass, String intface, InterfaceDecl intDecl, Collection methods, boolean callbackExist) { println("public " + newSkelClass + "(" + intface + " _mainObj, int _port) throws Exception {"); println("mainObj = _mainObj;"); println("rmiObj = new IoTRMIObject(_port);"); // Generate permission control initialization writeConstructorJavaPermission(intface); - writeJavaInitCallbackPermission(intface, intDecl); + writeJavaInitCallbackPermission(intface, intDecl, callbackExist); writeStructPermissionJavaSkeleton(methods, intDecl, intface); println("___waitRequestInvokeMethod();"); println("}\n"); @@ -1393,22 +1395,22 @@ public class IoTCompiler { for (int i = 0; i < methParams.size(); i++) { String paramType = methPrmTypes.get(i); String param = methParams.get(i); - String simpleType = getSimpleType(paramType); + String simpleType = getGenericType(paramType); if (isEnumClass(simpleType)) { // Check if this is enum type println("int paramInt" + i + "[] = (int[]) paramObj[" + i + "];"); println(simpleType + "[] enumVals = " + simpleType + ".values();"); if (isArray(param)) { // An array println("int len" + i + " = paramInt" + i + ".length;"); - println(simpleType + "[] paramEnum = new " + simpleType + "[len];"); + println(simpleType + "[] paramEnum" + i + " = new " + simpleType + "[len" + i + "];"); println("for (int i = 0; i < len" + i + "; i++) {"); - println("paramEnum[i] = enumVals[paramInt" + i + "[i]];"); + println("paramEnum" + i + "[i] = enumVals[paramInt" + i + "[i]];"); println("}"); } else if (isList(paramType)) { // A list println("int len" + i + " = paramInt" + i + ".length;"); - println("List<" + simpleType + "> paramEnum = new ArrayList<" + simpleType + ">();"); + println("List<" + simpleType + "> paramEnum" + i + " = new ArrayList<" + simpleType + ">();"); println("for (int i = 0; i < len" + i + "; i++) {"); - println("paramEnum.add(enumVals[paramInt" + i + "[i]]);"); + println("paramEnum" + i + ".add(enumVals[paramInt" + i + "[i]]);"); println("}"); } else { // Just one element println(simpleType + " paramEnum" + i + " = enumVals[paramInt" + i + "[0]];"); @@ -1424,10 +1426,10 @@ public class IoTCompiler { private void checkAndWriteEnumRetTypeJavaSkeleton(String retType, String methodId) { // Strips off array "[]" for return type - String pureType = getSimpleArrayType(getSimpleType(retType)); + String pureType = getSimpleArrayType(getGenericType(retType)); // Take the inner type of generic if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) - pureType = getTypeOfGeneric(retType)[0]; + pureType = getGenericType(retType); if (isEnumClass(pureType)) { // Check if this is enum type // Enum decoder @@ -1448,10 +1450,10 @@ public class IoTCompiler { private void checkAndWriteEnumRetConvJavaSkeleton(String retType) { // Strips off array "[]" for return type - String pureType = getSimpleArrayType(getSimpleType(retType)); + String pureType = getSimpleArrayType(getGenericType(retType)); // Take the inner type of generic if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) - pureType = getTypeOfGeneric(retType)[0]; + pureType = getGenericType(retType); if (isEnumClass(pureType)) { // Check if this is enum type if (isArray(retType)) { // An array @@ -1462,9 +1464,9 @@ public class IoTCompiler { println("}"); } else if (isList(retType)) { // A list println("int retLen = retEnum.size();"); - println("List<" + pureType + "> retEnumVal = new ArrayList<" + pureType + ">();"); + println("int[] retEnumVal = new int[retLen];"); println("for (int i = 0; i < retLen; i++) {"); - println("retEnumVal.add(retEnum[i].ordinal());"); + println("retEnumVal[i] = retEnum.get(i).ordinal();"); println("}"); } else { // Just one element println("int[] retEnumVal = new int[1];"); @@ -1656,9 +1658,9 @@ public class IoTCompiler { String retType = intDecl.getMethodType(method); if (retType.equals("void")) { print(intDecl.getMethodId(method) + "("); - } else if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) { // Enum type + } else if (isEnumClass(getSimpleArrayType(getGenericType(retType)))) { // Enum type checkAndWriteEnumRetTypeJavaSkeleton(retType, intDecl.getMethodId(method)); - } else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) { // Struct type + } else if (isStructClass(getSimpleArrayType(getGenericType(retType)))) { // Struct type print(retType + " retStruct = " + intDecl.getMethodId(method) + "("); } else { // We do have a return value print("Object retObj = " + intDecl.getMethodId(method) + "("); @@ -1667,9 +1669,9 @@ public class IoTCompiler { if (isCallbackMethod) { print(mapStubParam.get(i)); // Get the callback parameter - } else if (isEnumClass(getSimpleType(methPrmTypes.get(i)))) { // Enum class + } else if (isEnumClass(getGenericType(methPrmTypes.get(i)))) { // Enum class print(getEnumParam(methPrmTypes.get(i), methParams.get(i), i)); - } else if (isStructClass(getSimpleType(methPrmTypes.get(i)))) { + } else if (isStructClass(getGenericType(methPrmTypes.get(i)))) { print("paramStruct" + i); } else { String prmType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i)); @@ -1683,11 +1685,11 @@ public class IoTCompiler { } println(");"); if (!retType.equals("void")) { - if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) { // Enum type + if (isEnumClass(getSimpleArrayType(getGenericType(retType)))) { // Enum type checkAndWriteEnumRetConvJavaSkeleton(retType); println("rmiObj.sendReturnObj(retObj);"); - } else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) { // Struct type - writeStructReturnJavaSkeleton(getSimpleArrayType(getSimpleType(retType)), retType); + } else if (isStructClass(getSimpleArrayType(getGenericType(retType)))) { // Struct type + writeStructReturnJavaSkeleton(getSimpleArrayType(getGenericType(retType)), retType); println("rmiObj.sendReturnObj(retCls, retObj);"); } else println("rmiObj.sendReturnObj(retObj);"); @@ -1778,8 +1780,9 @@ public class IoTCompiler { print("new Class[] { "); for (int i = 0; i < methParams.size(); i++) { String prmType = methPrmTypes.get(i); - if (getParamCategory(prmType) == ParamCategory.NONPRIMITIVES) - print(getTypeOfGeneric(prmType)[0] + ".class"); + if ((getParamCategory(prmType) == ParamCategory.NONPRIMITIVES) && + !isEnumClass(getGenericType(prmType))) + print(getGenericType(prmType) + ".class"); else print("null"); if (i != methParams.size() - 1) @@ -2124,7 +2127,7 @@ public class IoTCompiler { // Write properties writePropertiesJavaSkeleton(intface, callbackExist, intDecl); // Write constructor - writeConstructorJavaSkeleton(newSkelClass, intface, intDecl, methods); + writeConstructorJavaSkeleton(newSkelClass, intface, intDecl, methods, callbackExist); // Write methods writeMethodJavaSkeleton(methods, intDecl, callbackClasses, false); // Write method helper @@ -2552,9 +2555,6 @@ public class IoTCompiler { List methParams = intDecl.getMethodParams(method); List methPrmTypes = intDecl.getMethodParamTypes(method); - - //System.out.println("\n\nMethod return type: " + checkAndGetCplusType(intDecl.getMethodType(method)) + "\n\n"); - print(checkAndGetCplusType(intDecl.getMethodType(method)) + " " + intDecl.getMethodId(method) + "("); boolean isCallbackMethod = false; @@ -2631,11 +2631,8 @@ public class IoTCompiler { if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object print("\"int\""); } else { // Generate normal classes if it's not a callback object - //String paramTypeC = checkAndGetArray(methPrmTypes.get(i), methParams.get(i)); - //String prmType = getSimpleType(getEnumType(paramTypeC)); String paramTypeC = checkAndGetCplusArgClsType(methPrmTypes.get(i), methParams.get(i)); - String prmType = getEnumCplusClsType(paramTypeC); - print("\"" + prmType + "\""); + print("\"" + paramTypeC + "\""); } if (i != methParams.size() - 1) // Check if this is the last element print(", "); @@ -2683,14 +2680,13 @@ public class IoTCompiler { for (int i = 0; i < methParams.size(); i++) { String paramType = methPrmTypes.get(i); String param = methParams.get(i); - String simpleType = getSimpleType(paramType); - if (isEnumClass(simpleType)) { + if (isEnumClass(getGenericType(paramType))) { // Check if this is enum type if (isArrayOrList(paramType, param)) { // An array or vector - println("int len" + i + " = " + param + ".size();"); - println("vector paramEnum" + i + "(len);"); + println("int len" + i + " = " + getSimpleIdentifier(param) + ".size();"); + println("vector paramEnum" + i + "(len" + i + ");"); println("for (int i = 0; i < len" + i + "; i++) {"); - println("paramEnum" + i + "[i] = (int) " + param + "[i];"); + println("paramEnum" + i + "[i] = (int) " + getSimpleIdentifier(param) + "[i];"); println("}"); } else { // Just one element println("vector paramEnum" + i + "(1);"); @@ -2707,10 +2703,10 @@ public class IoTCompiler { private void checkAndWriteEnumRetTypeCplusStub(String retType) { // Strips off array "[]" for return type - String pureType = getSimpleArrayType(getSimpleType(retType)); + String pureType = getSimpleArrayType(getGenericType(retType)); // Take the inner type of generic if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) - pureType = getTypeOfGeneric(retType)[0]; + pureType = getGenericType(retType); if (isEnumClass(pureType)) { // Check if this is enum type println("vector retEnumInt;"); @@ -2955,8 +2951,6 @@ public class IoTCompiler { checkAndWriteStructSetupCplusStub(methParams, methPrmTypes, intDecl, method); println("int methodId = " + intDecl.getMethodNumId(method) + ";"); String retType = intDecl.getMethodType(method); - //String retTypeC = checkAndGetCplusType(retType); - //println("string retType = \"" + checkAndGetCplusArrayType(getStructType(getEnumType(retTypeC))) + "\";"); println("string retType = \"" + checkAndGetCplusRetClsType(getStructType(getEnumType(retType))) + "\";"); // Generate array of parameter types if (isStructPresent(methParams, methPrmTypes)) { @@ -2965,11 +2959,8 @@ public class IoTCompiler { println("int numParam = " + methParams.size() + ";"); print("string paramCls[] = { "); for (int i = 0; i < methParams.size(); i++) { - //String paramTypeC = checkAndGetArray(methPrmTypes.get(i), methParams.get(i)); - //String prmType = getSimpleType(getEnumType(paramTypeC)); String paramTypeC = checkAndGetCplusArgClsType(methPrmTypes.get(i), methParams.get(i)); - String prmType = getEnumCplusClsType(paramTypeC); - print("\"" + prmType + "\""); + print("\"" + paramTypeC + "\""); // Check if this is the last element (don't print a comma) if (i != methParams.size() - 1) { print(", "); @@ -2998,7 +2989,7 @@ public class IoTCompiler { writeStructReturnCplusStub(getGenericType(getSimpleArrayType(retType)), retType); } else { // Check if the return value NONPRIMITIVES - if (getParamCategory(retType) == ParamCategory.ENUM) { + if (isEnumClass(getSimpleArrayType(getGenericType(retType)))) { checkAndWriteEnumRetTypeCplusStub(retType); } else { //if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) @@ -3616,7 +3607,7 @@ public class IoTCompiler { for (int i = 0; i < methParams.size(); i++) { String paramType = methPrmTypes.get(i); String param = methParams.get(i); - String simpleType = getSimpleType(paramType); + String simpleType = getGenericType(paramType); if (isEnumClass(simpleType)) { // Check if this is enum type if (isArrayOrList(paramType, param)) { // An array @@ -3640,7 +3631,7 @@ public class IoTCompiler { private void checkAndWriteEnumRetTypeCplusSkeleton(String retType) { // Strips off array "[]" for return type - String pureType = getSimpleArrayType(getSimpleType(retType)); + String pureType = getSimpleArrayType(getGenericType(retType)); // Take the inner type of generic if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) pureType = getTypeOfGeneric(retType)[0]; @@ -3672,9 +3663,9 @@ public class IoTCompiler { String paramType = returnGenericCallbackType(methPrmTypes.get(i)); if (callbackClasses.contains(paramType)) print("stub" + i); - else if (isEnumClass(getSimpleType(paramType))) // Check if this is enum type + else if (isEnumClass(getGenericType(paramType))) // Check if this is enum type print("paramEnum" + i); - else if (isStructClass(getSimpleType(paramType))) // Struct type + else if (isStructClass(getGenericType(paramType))) // Struct type print("paramStruct" + i); else print(getSimpleIdentifier(methParams.get(i))); @@ -3704,23 +3695,23 @@ public class IoTCompiler { if (retType.equals("void")) { writeMethodInputParameters(methParams, methPrmTypes, callbackClasses, methodId); } else { // We do have a return value - if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) // Enum type + if (isEnumClass(getSimpleArrayType(getGenericType(retType)))) // Enum type print(checkAndGetCplusType(retType) + " retEnum = "); - else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) // Struct type + else if (isStructClass(getSimpleArrayType(getGenericType(retType)))) // Struct type print(checkAndGetCplusType(retType) + " retStruct = "); else print(checkAndGetCplusType(retType) + " retVal = "); writeMethodInputParameters(methParams, methPrmTypes, callbackClasses, methodId); checkAndWriteEnumRetTypeCplusSkeleton(retType); - if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) // Struct type - writeStructReturnCplusSkeleton(getSimpleArrayType(getSimpleType(retType)), retType); - if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) // Enum type + if (isStructClass(getSimpleArrayType(getGenericType(retType)))) // Struct type + writeStructReturnCplusSkeleton(getSimpleArrayType(getGenericType(retType)), retType); + if (isEnumClass(getSimpleArrayType(getGenericType(retType)))) // Enum type println("void* retObj = &retEnumInt;"); else - if (!isStructClass(getSimpleArrayType(getSimpleType(retType)))) // Struct type + if (!isStructClass(getSimpleArrayType(getGenericType(retType)))) // Struct type println("void* retObj = &retVal;"); String retTypeC = checkAndGetCplusType(retType); - if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) // Struct type + if (isStructClass(getSimpleArrayType(getGenericType(retType)))) // Struct type println("rmiObj->sendReturnObj(retObj, retCls, numRetObj);"); else println("rmiObj->sendReturnObj(retObj, \"" + checkAndGetCplusRetClsType(getEnumType(retType)) + "\");"); @@ -3745,11 +3736,8 @@ public class IoTCompiler { callbackType = paramType; print("\"int\""); } else { // Generate normal classes if it's not a callback object - //String paramTypeC = checkAndGetArray(methPrmTypes.get(i), methParams.get(i)); - //String prmType = getSimpleType(getEnumType(paramTypeC)); String paramTypeC = checkAndGetCplusArgClsType(methPrmTypes.get(i), methParams.get(i)); - String prmType = getEnumCplusClsType(paramTypeC); - print("\"" + prmType + "\""); + print("\"" + paramTypeC + "\""); } if (i != methParams.size() - 1) { print(", "); @@ -3763,10 +3751,12 @@ public class IoTCompiler { for (int i = 0; i < methParams.size(); i++) { String paramType = returnGenericCallbackType(methPrmTypes.get(i)); if (!callbackClasses.contains(paramType)) { - String methPrmType = checkAndGetCplusType(methPrmTypes.get(i)); - if (isEnumClass(getSimpleType(methPrmType))) { // Check if this is enum type + String methParamType = methPrmTypes.get(i); + if (isEnumClass(getSimpleArrayType(getGenericType(methParamType)))) { + // Check if this is enum type println("vector paramEnumInt" + i + ";"); } else { + String methPrmType = checkAndGetCplusType(methParamType); String methParamComplete = checkAndGetCplusArray(methPrmType, methParams.get(i)); println(methParamComplete + ";"); } @@ -3778,7 +3768,7 @@ public class IoTCompiler { String paramType = returnGenericCallbackType(methPrmTypes.get(i)); if (callbackClasses.contains(paramType)) print("&numStubs" + i); - else if (isEnumClass(getSimpleType(paramType))) // Check if this is enum type + else if (isEnumClass(getGenericType(paramType))) // Check if this is enum type print("¶mEnumInt" + i); else print("&" + getSimpleIdentifier(methParams.get(i))); @@ -3961,14 +3951,14 @@ public class IoTCompiler { } else { // Generate normal classes if it's not a callback object String paramTypeC = checkAndGetCplusType(methPrmTypes.get(i)); String prmTypeC = checkAndGetCplusArrayType(paramTypeC, methParams.get(i)); - if (isEnumClass(getSimpleType(paramTypeC))) { // Check if this is enum type + if (isEnumClass(getGenericType(paramTypeC))) { // Check if this is enum type println("vector paramEnumInt" + i + ";"); } else { String methParamComplete = checkAndGetCplusArray(paramTypeC, methParams.get(i)); println(methParamComplete + ";"); } println("paramCls[pos] = \"" + getEnumType(prmTypeC) + "\";"); - if (isEnumClass(getSimpleType(paramType))) // Check if this is enum type + if (isEnumClass(getGenericType(paramType))) // Check if this is enum type println("paramObj[pos++] = ¶mEnumInt" + i); else println("paramObj[pos++] = &" + getSimpleIdentifier(methParams.get(i)) + ";"); @@ -4561,9 +4551,12 @@ public class IoTCompiler { /** * This function converts Java to C++ type for compilation */ - private String convertType(String jType) { + private String convertType(String type) { - return mapPrimitives.get(jType); + if (mapPrimitives.containsKey(type)) + return mapPrimitives.get(type); + else + return type; } @@ -4816,7 +4809,7 @@ public class IoTCompiler { String pureType = getSimpleArrayType(type); // Take the inner type of generic if (getParamCategory(type) == ParamCategory.NONPRIMITIVES) - pureType = getTypeOfGeneric(type)[0]; + pureType = getGenericType(type); if (isEnumClass(pureType)) { String enumType = "int[]"; return enumType; @@ -4831,7 +4824,7 @@ public class IoTCompiler { String pureType = getSimpleArrayType(type); // Take the inner type of generic if (getParamCategory(type) == ParamCategory.NONPRIMITIVES) - pureType = getTypeOfGeneric(type)[0]; + pureType = getGenericType(type); if (isEnumClass(pureType)) { String enumType = "int*"; return enumType; @@ -4847,7 +4840,7 @@ public class IoTCompiler { String pureType = getSimpleArrayType(type); // Take the inner type of generic if (getParamCategory(type) == ParamCategory.NONPRIMITIVES) - pureType = getTypeOfGeneric(type)[0]; + pureType = getGenericType(type); if (isStructClass(pureType)) { String structType = "int"; return structType; @@ -5161,7 +5154,12 @@ public class IoTCompiler { // - Check and return C++ vector class, e.g. List A into vector private String checkAndGetCplusArgClsType(String paramType, String param) { - String paramTypeRet = null; + String paramTypeRet = getEnumCplusClsType(paramType); + if (!paramTypeRet.equals(paramType)) + // Just return if it is an enum type + // Type will still be the same if it's not an enum type + return paramTypeRet; + // Check for array declaration if (param.contains("[]")) { paramTypeRet = getSimpleArrayType(paramType) + "*"; diff --git a/iotjava/iotrmi/C++/basics/TestClass.hpp b/iotjava/iotrmi/C++/basics/TestClass.hpp index 6350712..4dd11ff 100644 --- a/iotjava/iotrmi/C++/basics/TestClass.hpp +++ b/iotjava/iotrmi/C++/basics/TestClass.hpp @@ -45,6 +45,8 @@ class TestClass : public TestClassInterface { // Enum Enum handleEnum(Enum en); + vector handleEnumArray(vector vecEn); + vector handleEnumList(vector vecEn); int getA(); void setA(int _int); @@ -268,14 +270,24 @@ Enum TestClass::handleEnum(Enum en) { } -/*vector TestClass::handleEnum(vector vecEn) { +vector TestClass::handleEnumArray(vector vecEn) { - for (EnumC en : vecEn) { + for (Enum en : vecEn) { cout << "Enum: " << en << endl; } return vecEn; -}*/ +} + + +vector TestClass::handleEnumList(vector vecEn) { + + for (Enum en : vecEn) { + cout << "Enum: " << en << endl; + } + + return vecEn; +} string TestClass::sumArray(vector newA) { diff --git a/iotjava/iotrmi/C++/basics/TestClass_Stub.cpp b/iotjava/iotrmi/C++/basics/TestClass_Stub.cpp index a1c35c0..01b0a90 100644 --- a/iotjava/iotrmi/C++/basics/TestClass_Stub.cpp +++ b/iotjava/iotrmi/C++/basics/TestClass_Stub.cpp @@ -87,6 +87,19 @@ int main(int argc, char *argv[]) en = APPLE; Enum res = tcStub->handleEnum(en); cout << "Return value: " << res << endl; + vector vecEn; + vecEn.push_back(APPLE); + vecEn.push_back(ORANGE); + vecEn.push_back(APPLE); + vecEn.push_back(GRAPE); + vector vecRes = tcStub->handleEnumArray(vecEn); + for (Enum en : vecRes) { + cout << "Enum value: " << en << endl; + } + vector vecRes2 = tcStub->handleEnumList(vecEn); + for (Enum en : vecRes2) { + cout << "Enum value: " << en << endl; + } cout << "==== OTHERS ====" << endl; cout << "Return value: " << tcStub->getA() << endl; diff --git a/iotjava/iotrmi/Java/basics/TestClass.java b/iotjava/iotrmi/Java/basics/TestClass.java index 01924a5..a7453a4 100644 --- a/iotjava/iotrmi/Java/basics/TestClass.java +++ b/iotjava/iotrmi/Java/basics/TestClass.java @@ -213,6 +213,7 @@ public class TestClass implements TestClassInterface { } + // Enum public Enum handleEnum(Enum en) { System.out.println("Enum: " + en); @@ -221,15 +222,24 @@ public class TestClass implements TestClassInterface { } - // Enum - /*public EnumJ[] handleEnum(EnumJ[] en) { + public Enum[] handleEnumArray(Enum[] en) { - for (EnumJ e : en) { + for (Enum e : en) { System.out.println("Enum: " + e); } return en; - }*/ + } + + + public List handleEnumList(List en) { + + for (Enum e : en) { + System.out.println("Enum: " + e); + } + + return en; + } // Getters diff --git a/iotjava/iotrmi/Java/basics/TestClass_Stub.java b/iotjava/iotrmi/Java/basics/TestClass_Stub.java index 26ecd43..63c3fff 100644 --- a/iotjava/iotrmi/Java/basics/TestClass_Stub.java +++ b/iotjava/iotrmi/Java/basics/TestClass_Stub.java @@ -64,6 +64,12 @@ public class TestClass_Stub { Enum en = Enum.APPLE; Enum res = tcstub.handleEnum(en); System.out.println("Enum member: " + res); + Enum[] enArr = { Enum.APPLE, Enum.ORANGE, Enum.APPLE, Enum.GRAPE }; + Enum[] resArr = tcstub.handleEnumArray(enArr); + System.out.println("Enum members: " + Arrays.toString(resArr)); + List enArr2 = new ArrayList(Arrays.asList(enArr)); + List resArr2 = tcstub.handleEnumList(enArr2); + System.out.println("Enum members: " + resArr2.toString()); System.out.println("==== OTHERS ===="); System.out.println("Return value: " + tcstub.getA()); -- 2.34.1