Refactoring type size handler; using Java types as standard

[iot2.git] / iotjava / iotrmi / C++ / IoTRMIUtil.hpp

diff --git a/iotjava/iotrmi/C++/IoTRMIUtil.hpp b/iotjava/iotrmi/C++/IoTRMIUtil.hpp
index 50e43bb2baf416521d2baac23bc3ec41908ad1bd..b80b1156b6a9e353c8146ae6ba65058956847dfd 100644 (file)
--- a/iotjava/iotrmi/C++/IoTRMIUtil.hpp
+++ b/iotjava/iotrmi/C++/IoTRMIUtil.hpp
@@ -37,6 +37,7 @@ class IoTRMIUtil {
                static int              hashCode(string str);
                static char*    getHashCodeBytes(string methodSign, char* bytes);
                int                     getTypeSize(string type);
+               int                             getVarTypeSize(string type, void* paramObj);
                static int              getArrStringLength(vector<string> arrString);
                static int              getByteStringLength(vector<string> arrString);
                
@@ -97,8 +98,7 @@ class IoTRMIUtil {
                
        private:
                map<string,string>      mapPrimitives;
-               map<string,int>         mapPrimitiveSizesJava;
-               map<string,int>         mapPrimitiveSizesCplus;
+               map<string,int>         mapPrimitiveSizes;
                map<string,string>      mapNonPrimitives;
 };
 
@@ -111,10 +111,8 @@ IoTRMIUtil::IoTRMIUtil() {
                IoTRMITypes::primitivesJava + sizeof(IoTRMITypes::primitivesJava)/sizeof(string));
        std::vector<string> primCplus (IoTRMITypes::primitivesCplus, 
                IoTRMITypes::primitivesCplus + sizeof(IoTRMITypes::primitivesCplus)/sizeof(string));
-       std::vector<int> primJavaSizes (IoTRMITypes::primitivesJavaSizes, 
-               IoTRMITypes::primitivesJavaSizes + sizeof(IoTRMITypes::primitivesJavaSizes)/sizeof(int));
-       std::vector<int> primCplusSizes (IoTRMITypes::primitivesCplusSizes, 
-               IoTRMITypes::primitivesCplusSizes + sizeof(IoTRMITypes::primitivesCplusSizes)/sizeof(int));
+       std::vector<int> primSizes (IoTRMITypes::primitivesSizes, 
+               IoTRMITypes::primitivesSizes + sizeof(IoTRMITypes::primitivesSizes)/sizeof(int));
        std::vector<string> nonPrimJava (IoTRMITypes::nonPrimitivesJava, 
                IoTRMITypes::nonPrimitivesJava + sizeof(IoTRMITypes::nonPrimitivesJava)/sizeof(string));
        std::vector<string> nonPrimCplus (IoTRMITypes::nonPrimitivesCplus, 
@@ -123,8 +121,7 @@ IoTRMIUtil::IoTRMIUtil() {
 
        // Write into maps
        IoTRMITypes::arraysToMap(mapPrimitives, primJava, primCplus);
-       IoTRMITypes::arraysToMap(mapPrimitiveSizesJava, primJava, primJavaSizes); 
-       IoTRMITypes::arraysToMap(mapPrimitiveSizesCplus, primJava, primCplusSizes); 
+       IoTRMITypes::arraysToMap(mapPrimitiveSizes, primJava, primSizes); 
        IoTRMITypes::arraysToMap(mapNonPrimitives, nonPrimJava, nonPrimCplus);
 }
 
@@ -175,13 +172,55 @@ char* IoTRMIUtil::getHashCodeBytes(string methodSign, char* bytes) {
 int IoTRMIUtil::getTypeSize(string type) {
 
        // Handle the types and find the sizes
-       if (mapPrimitiveSizesCplus.find(type) != mapPrimitiveSizesCplus.end())
-               return mapPrimitiveSizesCplus.find(type)->second;
+       if (mapPrimitiveSizes.find(type) != mapPrimitiveSizes.end())
+               return mapPrimitiveSizes.find(type)->second;
        else
                return -1; // Size is unknown
 }
 
 
+// Get variable type size, e.g. strings, arrays, etc.
+int IoTRMIUtil::getVarTypeSize(string type, void* paramObj) {
+
+       int paramLen = 0;
+       if (type.compare("string") == 0) {
+               // Get the length of the string through void* casting to string*
+               paramLen = (*(string*)paramObj).length();
+       } else if (type.compare("string[]") == 0) {
+               paramLen = IoTRMIUtil::getByteStringLength(*(vector<string>*) paramObj);
+       } else if (type.compare("byte[]") == 0) {
+               int dataSize = getTypeSize("byte");
+               paramLen = (*(vector<char>*) paramObj).size() * dataSize;
+       } else if (type.compare("short[]") == 0) {
+               int dataSize = getTypeSize("short");
+               paramLen = (*(vector<short>*) paramObj).size() * dataSize;
+       } else if (type.compare("int[]") == 0) {
+               int dataSize = getTypeSize("int");
+               paramLen = (*(vector<int>*) paramObj).size() * dataSize;
+       } else if (type.compare("long[]") == 0) {
+               int dataSize = getTypeSize("long");
+               paramLen = (*(vector<int64_t>*) paramObj).size() * dataSize;
+       } else if (type.compare("float[]") == 0) {
+               int dataSize = getTypeSize("float");
+               paramLen = (*(vector<float>*) paramObj).size() * dataSize;
+       } else if (type.compare("double[]") == 0) {
+               int dataSize = getTypeSize("double");
+               paramLen = (*(vector<double>*) paramObj).size() * dataSize;
+       } else if (type.compare("bool[]") == 0) {
+               int dataSize = getTypeSize("bool");
+               paramLen = (*(vector<bool>*) paramObj).size() * dataSize;
+       } else if (type.compare("char[]") == 0) {
+               int dataSize = getTypeSize("char");
+               paramLen = (*(vector<char>*) paramObj).size() * dataSize;
+       } else {
+               string error = "IoTRMICall: Unrecognizable type: " + type;
+               throw error;
+       }
+
+       return paramLen;
+}
+
+
 int IoTRMIUtil::getArrStringLength(vector<string> arrString) {
 
        int len = 0;