projects / iot2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fixing bugs on char translation; testing for arrays
[iot2.git] / iotjava / iotrmi / C++ / IoTRMIUtil.hpp
diff --git a/iotjava/iotrmi/C++/IoTRMIUtil.hpp b/iotjava/iotrmi/C++/IoTRMIUtil.hpp
index 6b33b6199b58ce2a71d5d4dfaab5d6fc495ea284..5da411cfd4d85179bd5e1a6291766aef4454f8ac 100644 (file)
--- a/iotjava/iotrmi/C++/IoTRMIUtil.hpp
+++ b/iotjava/iotrmi/C++/IoTRMIUtil.hpp
@@ -42,6 +42,7 @@ class IoTRMIUtil {
                static int              getByteStringLength(vector<string> arrString);
                
                // Primitives to byte array
+               static char*    byteToByteArray(char c, char* bytes);
                static char*    shortToByteArray(short i, char* bytes);
                static char*    intToByteArray(int i, char* bytes);
                static char*    longToByteArray(int64_t i, char* bytes);
@@ -52,6 +53,7 @@ class IoTRMIUtil {
                static char*    stringToByteArray(string c, char* bytes);
 
                // Byte array to primitives
+               static char*    byteArrayToByte(char* result, char* bytes);
                static short*   byteArrayToShort(short* result, char* bytes);
                static int*     byteArrayToInt(int* result, char* bytes);
                static int64_t* byteArrayToLong(int64_t* result, char* bytes);
@@ -67,6 +69,7 @@ class IoTRMIUtil {
                static char*    getObjectBytes(char* retObjBytes, void* obj, const char* type);
 
                // Arrays to bytes
+               static char*    arrByteToByteArray(vector<char> arrByte, char* bytes);
                static char*    arrShortToByteArray(vector<short> arrShort, char* bytes);
                static char*    arrIntToByteArray(vector<int> arrInt, char* bytes);
                static char*    arrLongToByteArray(vector<int64_t> arrInt, char* bytes);
@@ -77,6 +80,7 @@ class IoTRMIUtil {
                static char*    arrStringToByteArray(vector<string> arrString, char* bytes);
 
                // Bytes to array
+               static vector<char>*    byteArrayToByteArray(vector<char>* result, char* bytes, int len);
                static vector<short>*   byteArrayToShortArray(vector<short>* result, char* bytes, int len);
                static vector<int>*     byteArrayToIntArray(vector<int>* result, char* bytes, int len);
                static vector<int64_t>* byteArrayToLongArray(vector<int64_t>* result, char* bytes, int len);
@@ -96,6 +100,7 @@ class IoTRMIUtil {
                const static int        PARAM_LEN = 4;          // 4 bytes = 32 bits (4-byte field that stores the length of the param)
                const static int        RETURN_LEN = 4;         // 4 bytes = 32 bits (4-byte field that stores the length of the return object)
                const static int        CHAR_LEN = 2;           // 2 bytes (we follow Java convention)
+               const static int        BYTE_LEN = 1;           // 1 byte
                const static int        BOOL_LEN = 1;           // 1 byte
                
        private:
@@ -188,34 +193,52 @@ int IoTRMIUtil::getVarTypeSize(string type, void* paramObj) {
        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) {
+       } else if (     (type.compare("String*") == 0) ||
+                               (type.compare("string*") == 0) ||
+                               (type.compare("vector<String>") == 0)) {
                paramLen = IoTRMIUtil::getByteStringLength(*(vector<string>*) paramObj);
-       } else if (type.compare("byte[]") == 0) {
+       } else if ( (type.compare("byte*") == 0) ||
+                               (type.compare("Byte*") == 0) ||
+                               (type.compare("vector<Byte>") == 0)) {
                int dataSize = getTypeSize("byte");
                paramLen = (*(vector<char>*) paramObj).size() * dataSize;
-       } else if (type.compare("short[]") == 0) {
+       } else if ( (type.compare("short*") == 0) ||
+                               (type.compare("Short*") == 0) ||
+                               (type.compare("vector<Short>") == 0)) {
                int dataSize = getTypeSize("short");
                paramLen = (*(vector<short>*) paramObj).size() * dataSize;
-       } else if (type.compare("int[]") == 0) {
+       } else if ( (type.compare("int*") == 0) ||
+                               (type.compare("Integer*") == 0) ||
+                               (type.compare("vector<Integer>") == 0)) {
                int dataSize = getTypeSize("int");
                paramLen = (*(vector<int>*) paramObj).size() * dataSize;
-       } else if (type.compare("long[]") == 0) {
+       } else if ( (type.compare("long*") == 0) ||
+                               (type.compare("Long*") == 0) ||
+                               (type.compare("vector<Long>") == 0)) {
                int dataSize = getTypeSize("long");
                paramLen = (*(vector<int64_t>*) paramObj).size() * dataSize;
-       } else if (type.compare("float[]") == 0) {
+       } else if ( (type.compare("float*") == 0) ||
+                               (type.compare("Float*") == 0) ||
+                               (type.compare("vector<Float>") == 0)) {
                int dataSize = getTypeSize("float");
                paramLen = (*(vector<float>*) paramObj).size() * dataSize;
-       } else if (type.compare("double[]") == 0) {
+       } else if ( (type.compare("double*") == 0) ||
+                               (type.compare("Double*") == 0) ||
+                               (type.compare("vector<Double>") == 0)) {
                int dataSize = getTypeSize("double");
                paramLen = (*(vector<double>*) paramObj).size() * dataSize;
-       } else if (type.compare("bool[]") == 0) {
+       } else if ( (type.compare("boolean*") == 0) ||
+                               (type.compare("Boolean*") == 0) ||
+                               (type.compare("vector<Boolean>") == 0)) {
                int dataSize = getTypeSize("boolean");
                paramLen = (*(vector<bool>*) paramObj).size() * dataSize;
-       } else if (type.compare("char[]") == 0) {
+       } else if ( (type.compare("char*") == 0) ||
+                               (type.compare("Character*") == 0) ||
+                               (type.compare("vector<Character>") == 0)) {
                int dataSize = getTypeSize("char");
                paramLen = (*(vector<char>*) paramObj).size() * dataSize;
        } else {
-               cerr << "IoTRMIUtil: Unrecognizable type: " << type;
+               cerr << "IoTRMIUtil: Unrecognizable type: " << type << endl;
                exit(-1);
        }
 
@@ -249,7 +272,7 @@ void* IoTRMIUtil::getParamObject(void* retObj, const char* type, char* paramByte
 
        if (strcmp(type, "b") == 0 ||
                strcmp(type, "byte") == 0) {
-               retObj = (void*) &paramBytes[0];
+               retObj = (void*) byteArrayToByte((char*) retObj, paramBytes);
        } else if ( strcmp(type, "s") == 0 ||
                                strcmp(type, "short") == 0) {
                retObj = (void*) byteArrayToShort((short*) retObj, paramBytes);
@@ -274,11 +297,11 @@ void* IoTRMIUtil::getParamObject(void* retObj, const char* type, char* paramByte
        } else if ( strcmp(type, "Ss") == 0 ||
                                strcmp(type, "String") == 0) {
                retObj = (void*) byteArrayToString((string*) retObj, paramBytes, len);
-       } else if ( string(type).find("[]") != string::npos) {
+       } else if ( string(type).find("*") != string::npos) {
                // This is an array type, i.e. vector
                retObj = getArrayParamObject(retObj, type, paramBytes, len);
        } else {
-               cerr << "IoTRMIUtil: Unrecognizable type: " << type;
+               cerr << "IoTRMIUtil: Unrecognizable type: " << type << endl;
                exit(-1);
        }
 
@@ -286,29 +309,46 @@ void* IoTRMIUtil::getParamObject(void* retObj, const char* type, char* paramByte
 }
 
 
-// Get array of objects from byte array - overload getParamObject function
+// Get array of objects from byte array
 void* IoTRMIUtil::getArrayParamObject(void* retObj, const char* type, char* paramBytes, int len) {
 
-       if (strcmp(type, "byte[]") == 0) {
-               retObj = (vector<char>*) paramBytes;
-       } else if (strcmp(type, "short[]") == 0) {
+       if ((strcmp(type, "byte*") == 0) ||
+               (strcmp(type, "Byte*") == 0) ||
+               (strcmp(type, "vector<Byte>") == 0)) {
+               retObj = byteArrayToByteArray((vector<char>*) retObj, paramBytes, len);
+       } else if ( (strcmp(type, "short*") == 0) ||
+                               (strcmp(type, "Short*") == 0) ||
+                               (strcmp(type, "vector<Short>") == 0)) {
                retObj = byteArrayToShortArray((vector<short>*) retObj, paramBytes, len);
-       } else if (strcmp(type, "int[]") == 0) {
+       } else if ( (strcmp(type, "int*") == 0) ||
+                               (strcmp(type, "Integer*") == 0) ||
+                               (strcmp(type, "vector<Integer>") == 0)) {
                retObj = byteArrayToIntArray((vector<int>*) retObj, paramBytes, len);
-       } else if (strcmp(type, "long[]") == 0) {
+       } else if ( (strcmp(type, "long*") == 0) ||
+                               (strcmp(type, "Long*") == 0) ||
+                               (strcmp(type, "vector<Long>") == 0)) {
                retObj = byteArrayToLongArray((vector<int64_t>*) retObj, paramBytes, len);
-       } else if (strcmp(type, "float[]") == 0) {
+       } else if ( (strcmp(type, "float*") == 0) ||
+                               (strcmp(type, "Float*") == 0) ||
+                               (strcmp(type, "vector<Float>") == 0)) {
                retObj = byteArrayToFloatArray((vector<float>*) retObj, paramBytes, len);
-       } else if (strcmp(type, "double[]") == 0) {
+       } else if ( (strcmp(type, "double*") == 0) ||
+                               (strcmp(type, "Double*") == 0) ||
+                               (strcmp(type, "vector<Double>") == 0)) {
                retObj = byteArrayToDoubleArray((vector<double>*) retObj, paramBytes, len);
-       } else if (strcmp(type, "bool[]") == 0) {
+       } else if ( (strcmp(type, "boolean*") == 0) ||
+                               (strcmp(type, "Boolean*") == 0) ||
+                               (strcmp(type, "vector<Boolean>") == 0)) {
                retObj = byteArrayToBooleanArray((vector<bool>*) retObj, paramBytes, len);
-       } else if (strcmp(type, "char[]") == 0) {
+       } else if ( (strcmp(type, "char*") == 0)      ||
+                               (strcmp(type, "Character*") == 0) ||
+                               (strcmp(type, "vector<Character>") == 0)) {
                retObj = byteArrayToCharArray((vector<char>*) retObj, paramBytes, len);
-       } else if (strcmp(type, "String[]") == 0) {
+       } else if ( (strcmp(type, "String*") == 0) ||
+                               (strcmp(type, "vector<String>") == 0)) {
                retObj = byteArrayToStringArray((vector<string>*) retObj, paramBytes, len);
        } else {
-               cerr << "IoTRMIUtil: Unrecognizable type: " << type;
+               cerr << "IoTRMIUtil: Unrecognizable type: " << type << endl;
                exit(-1);       
        }
 
@@ -321,7 +361,7 @@ char* IoTRMIUtil::getObjectBytes(char* retObjBytes, void* obj, const char* type)
 
        if (strcmp(type, "b") == 0 ||
                strcmp(type, "byte") == 0) {
-               retObjBytes = (char*) obj;
+               retObjBytes = byteToByteArray(*((char*) obj), retObjBytes);             
        } else if ( strcmp(type, "s") == 0 ||
                                strcmp(type, "short") == 0) {
                retObjBytes = shortToByteArray(*((short*) obj), retObjBytes);
@@ -344,14 +384,13 @@ char* IoTRMIUtil::getObjectBytes(char* retObjBytes, void* obj, const char* type)
                                strcmp(type, "char") == 0) {
                retObjBytes = charToByteArray(*((char*) obj), retObjBytes);
        } else if ( strcmp(type, "Ss") == 0 ||
-                               strcmp(type, "String") == 0 ||
-                               strcmp(type, "string") == 0) {
+                               strcmp(type, "String") == 0) {
                retObjBytes = stringToByteArray(*((string*) obj), retObjBytes);
-       } else if ( string(type).find("[]") != string::npos) {
+       } else if ( string(type).find("*") != string::npos) {
        // This is an array type, i.e. vector
                retObjBytes = getArrayObjectBytes(retObjBytes, obj, type);
        } else {
-               cerr << "IoTRMIUtil: Unrecognizable type: " << type;
+               cerr << "IoTRMIUtil: Unrecognizable type: " << type << endl;
                exit(-1);
        }
 
@@ -362,26 +401,43 @@ char* IoTRMIUtil::getObjectBytes(char* retObjBytes, void* obj, const char* type)
 // Getting byte array for arrays of primitives
 char* IoTRMIUtil::getArrayObjectBytes(char* retObjBytes, void* obj, const char* type) {
 
-       if (strcmp(type, "byte[]") == 0) {
-               retObjBytes = (char*) obj;
-       } else if (strcmp(type, "short[]") == 0) {
+       if ((strcmp(type, "byte*") == 0) ||
+               (strcmp(type, "Byte*") == 0) ||
+               (strcmp(type, "vector<Byte>") == 0)) {
+               retObjBytes = arrByteToByteArray(*((vector<char>*) obj), retObjBytes);
+       } else if ( (strcmp(type, "short*") == 0) ||
+                               (strcmp(type, "Short*") == 0) ||
+                               (strcmp(type, "vector<Short>") == 0)) {
                retObjBytes = arrShortToByteArray(*((vector<short>*) obj), retObjBytes);
-       } else if (strcmp(type, "int[]") == 0) {
+       } else if ( (strcmp(type, "int*") == 0) ||
+                               (strcmp(type, "Integer*") == 0) ||
+                               (strcmp(type, "vector<Integer>") == 0)) {
                retObjBytes = arrIntToByteArray(*((vector<int>*) obj), retObjBytes);
-       } else if (strcmp(type, "long[]") == 0) {
+       } else if ( (strcmp(type, "long*") == 0) ||
+                               (strcmp(type, "Long*") == 0) ||
+                               (strcmp(type, "vector<Long>") == 0)) {
                retObjBytes = arrLongToByteArray(*((vector<int64_t>*) obj), retObjBytes);
-       } else if (strcmp(type, "float[]") == 0) {
+       } else if ( (strcmp(type, "float*") == 0) ||
+                               (strcmp(type, "Float*") == 0) ||
+                               (strcmp(type, "vector<Float>") == 0)) {
                retObjBytes = arrFloatToByteArray(*((vector<float>*) obj), retObjBytes);
-       } else if (strcmp(type, "double[]") == 0) {
+       } else if ( (strcmp(type, "double*") == 0) ||
+                               (strcmp(type, "Double*") == 0) ||
+                               (strcmp(type, "vector<Double>") == 0)) {
                retObjBytes = arrDoubleToByteArray(*((vector<double>*) obj), retObjBytes);
-       } else if (strcmp(type, "bool[]") == 0) {
+       } else if ( (strcmp(type, "boolean*") == 0) ||
+                               (strcmp(type, "Boolean*") == 0) ||
+                               (strcmp(type, "vector<Boolean>") == 0)) {
                retObjBytes = arrBooleanToByteArray(*((vector<bool>*) obj), retObjBytes);
-       } else if (strcmp(type, "char[]") == 0) {
+       } else if ( (strcmp(type, "char*") == 0) ||
+                               (strcmp(type, "Character*") == 0) ||
+                               (strcmp(type, "vector<Character>") == 0)) {
                retObjBytes = arrCharToByteArray(*((vector<char>*) obj), retObjBytes);
-       } else if (strcmp(type, "String[]") == 0) {
+       } else if ( (strcmp(type, "String*") == 0) ||
+                               (strcmp(type, "vector<String>") == 0)) {
                retObjBytes = arrStringToByteArray(*((vector<string>*) obj), retObjBytes);
        } else {
-               cerr << "IoTRMIUtil: Unrecognizable type: " << type;
+               cerr << "IoTRMIUtil: Unrecognizable type: " << type << endl;
                exit(-1);
        }
 
@@ -392,6 +448,20 @@ char* IoTRMIUtil::getArrayObjectBytes(char* retObjBytes, void* obj, const char*
 // Conversions
 // Array handlers - we use vector data type and not traditional arrays
 // Array to bytes
+char* IoTRMIUtil::arrByteToByteArray(vector<char> arrByte, char* bytes) {
+
+       int pos = 0;
+       for (char chr : arrByte) {
+               char tmpBytes[BYTE_LEN];
+               byteToByteArray(chr, tmpBytes);
+               memcpy(bytes + pos, tmpBytes, BYTE_LEN);
+               pos = pos + BYTE_LEN;
+       }
+
+       return bytes;
+}
+
+
 char* IoTRMIUtil::arrShortToByteArray(vector<short> arrShort, char* bytes) {
 
        int pos = 0;
@@ -517,6 +587,24 @@ char* IoTRMIUtil::arrStringToByteArray(vector<string> arrString, char* bytes) {
 
 
 // Bytes to array
+vector<char>* IoTRMIUtil::byteArrayToByteArray(vector<char>* result, char* bytes, int len) {
+
+       // Single element bytes
+       char elmt[BYTE_LEN];
+       // Prepare vector
+       int arrLen = len/BYTE_LEN;
+       for(int i = 0; i < arrLen; i++) {
+               int offset = i * BYTE_LEN;
+               memcpy(elmt, bytes + offset, BYTE_LEN);
+               char res;
+               byteArrayToByte(&res, elmt);
+               result->push_back(res);
+       }
+
+       return result;
+}
+
+
 vector<short>* IoTRMIUtil::byteArrayToShortArray(vector<short>* result, char* bytes, int len) {
 
        // Single element bytes
@@ -680,6 +768,15 @@ vector<string>*    IoTRMIUtil::byteArrayToStringArray(vector<string>* result, char*
 
 // Conversions
 // Primitives to byte array
+char* IoTRMIUtil::byteToByteArray(char c, char* bytes) {
+
+       // Just copy the char into char*
+       bytes[0] = c;
+
+       return bytes;
+}
+
+
 char* IoTRMIUtil::shortToByteArray(short s, char* bytes) {
 
        short sInvert = htobe16(s);
@@ -814,6 +911,13 @@ double* IoTRMIUtil::byteArrayToDouble(double* result, char* bytes) {
 }
 
 
+char* IoTRMIUtil::byteArrayToByte(char* result, char* bytes) {
+
+       *result = bytes[0];
+       return result;
+}
+
+
 char* IoTRMIUtil::byteArrayToChar(char* result, char* bytes) {
 
        *result = bytes[1];
The source code and documentation of Vigilia