#define _TESTCLASS_STUB_HPP__
#include <iostream>
+#include <set>
#include <thread>
#include "../IoTRMICall.hpp"
#include "../IoTRMIObject.hpp"
void registerCallback(CallBackInterface* _cb);
void registerCallback(vector<CallBackInterface*>_cb);
int callBack();
- void handleStruct(vector<data> vecData);
+ vector<data> handleStruct(vector<data> vecData);
+ vector<EnumC> handleEnum(vector<EnumC> vecEn);
void ____init_CallBack(); // thread
void ____registerCallBack(); // tell the other side that we are ready
- const static int size = 12;
- const static string methodSignatures[size];
+ //exception_ptr teptr = nullptr;
private:
int intA;
string stringC;
//CallBackInterface cb;
IoTRMICall *rmiCall;
- IoTRMIObject *rmiObj;
string address;
vector<int> ports;
- vector<CallBackInterface*> vecCBObj;
+ const static int objectId = 0; // Default value is 0
- int objectId = 0; // Default value is 0
+ // Specific for callbacks
+ IoTRMIObject *rmiObj;
+ vector<CallBackInterface*> vecCBObj;
static int objIdCnt;
+ // Callback permission
+ const static set<int> set0Allowed;
};
int TestClass_Stub::objIdCnt = 0;
-const string TestClass_Stub::methodSignatures[TestClass_Stub::size] = {
- "voidsetA(int)",
- "voidsetB(float)",
- "voidsetC(string)",
- "sumArray(string[])",
- //"sumArray(int[])",
- "intsetAndGetA(int)",
- "intsetACAndGetA(string,int)",
- "intcallBack()",
- "voidregisterCallBack(CallBackInterface)",
- "voidregisterCallBack(CallBackInterface[])",
- "registercallback",
- "handleStruct(StructJ[])",
- "structsize"
-};
+const set<int> TestClass_Stub::set0Allowed { 0, 1 };
TestClass_Stub::TestClass_Stub() {
TestClass_Stub::TestClass_Stub(int _port, const char* _address, int _rev, bool* _bResult, vector<int> _ports) {
address = _address;
- rmiCall = new IoTRMICall(_port, _address, _rev, _bResult, methodSignatures, size);
+ rmiCall = new IoTRMICall(_port, _address, _rev, _bResult);
ports = _ports;
// Start thread
- cout << "Reached here 1!" << endl;
-// thread th1 (&TestClass_Stub::____init_CallBack, this);
-// th1.detach();
+ /*if (teptr) {
+ try {
+ thread th1 (&TestClass_Stub::____init_CallBack, this);
+ th1.detach();
+ } catch(const exception&) {
+ cout << "Got here!" << endl;
+ throw exception();
+ }
+ }*/
+ thread th1 (&TestClass_Stub::____init_CallBack, this);
+ th1.detach();
//th1.join();
- cout << "Reached here 2!" << endl;
-// ____registerCallBack();
+ ____registerCallBack();
}
delete rmiObj;
rmiObj = NULL;
}
+ // Special for callbacks!!!
for(CallBackInterface* cb : vecCBObj) {
delete cb;
cb = NULL;
void TestClass_Stub::____init_CallBack() {
bool bResult = false;
- cout << "Reach here init!" << endl;
- rmiObj = new IoTRMIObject(ports[0], &bResult, CallBack_CBSkeleton::methodSignatures, CallBack_CBSkeleton::size);
- cout << "Reach here init 2!" << endl;
+ rmiObj = new IoTRMIObject(ports[0], &bResult);
while (true) {
char* method = rmiObj->getMethodBytes();
- cout << "Get method bytes here: " << endl;
- IoTRMIUtil::printBytes(method, rmiObj->getMethodBytesLen(), false);
+ int methodId = IoTRMIObject::getMethodId(method);
+ // Permission check
+ // Complain if the method is not allowed
+ if (set0Allowed.find(methodId) == set0Allowed.end()) {
+ cerr << "TestClass_Skeleton: This object is not allowed to access method " << methodId << endl;
+ exit(-1);
+ //throw exception();
+ //teptr = current_exception();
+ }
int objId = IoTRMIObject::getObjectId(method);
if (objId < vecCBObj.size()) { // Check if still within range
CallBack_CBSkeleton* skel =
dynamic_cast<CallBack_CBSkeleton*> (vecCBObj.at(objId));
- cout << "Dynamic cast done!" << endl;
- //rmiObj->setMethodBytes(method);
- string type = "";
- cout << "About to execute invoke method!" << endl;
- void* retObj = skel->invokeMethod(rmiObj, &type);
- cout << "Executed invoke method!" << endl;
- if (type != "void") {
- rmiObj->sendReturnObj(retObj, type);
- cout << "Sent return object!" << endl;
- }
+ skel->invokeMethod(rmiObj);
} else {
string error = "TestClass_Stub: Illegal object Id: " + to_string(objId);
throw error;
void TestClass_Stub::____registerCallBack() {
int numParam = 3;
- string sign = "registercallback";
+ int methodId = 9;
string retType = "void";
string paramCls[] = { "int", "string", "int" };
int rev = 0;
void* paramObj[] = { &ports[0], &address, &rev };
void* retObj = NULL;
- cout << "Get here! 1" << endl;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
- cout << "Get here! 2" << endl;
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
}
void TestClass_Stub::setA(int _int) {
int numParam = 1;
- string sign = "voidsetA(int)";
+ int methodId = 0;
string retType = "void";
string paramCls[] = { "int" };
void* paramObj[] = { &_int };
void* retObj = NULL;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
}
void TestClass_Stub::setB(float _float) {
int numParam = 1;
- string sign = "voidsetB(float)";
+ int methodId = 1;
string retType = "void";
string paramCls[] = { "float" };
void* paramObj[] = { &_float };
void* retObj = NULL;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
}
void TestClass_Stub::setC(string _string) {
int numParam = 1;
- string sign = "voidsetC(string)";
+ int methodId = 2;
string retType = "void";
string paramCls[] = { "string" };
void* paramObj[] = { &_string };
void* retObj = NULL;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
}
string TestClass_Stub::sumArray(vector<string> newA) {
int numParam = 1;
- string sign = "sumArray(string[])";
+ int methodId = 3;
string retType = "string";
string paramCls[] = { "string[]" };
void* paramObj[] = { &newA };
string retVal = "";
void* retObj = &retVal;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
return retVal;
}
int TestClass_Stub::setAndGetA(int newA) {
int numParam = 1;
- string sign = "intsetAndGetA(int)";
+ int methodId = 4;
string retType = "int";
string paramCls[] = { "int" };
void* paramObj[] = { &newA };
int retVal = 0;
void* retObj = &retVal;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
return retVal;
}
int TestClass_Stub::setACAndGetA(string newC, int newA) {
int numParam = 2;
- string sign = "intsetACAndGetA(string,int)";
+ int methodId = 5;
string retType = "int";
string paramCls[] = { "string", "int" };
void* paramObj[] = { &newC, &newA };
int retVal = 0;
void* retObj = &retVal;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
return retVal;
}
}
int numParam = 1;
- string sign = "voidregisterCallBack(CallBackInterface[])";
+ int methodId = 8;
string retType = "void";
string paramCls[] = { "int" };
int param1 = _cb.size();
void* paramObj[] = { ¶m1 };
void* retObj = NULL;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
}
int TestClass_Stub::callBack() {
int numParam = 0;
- string sign = "intcallBack()";
+ int methodId = 6;
string retType = "int";
string paramCls[] = { };
void* paramObj[] = { };
int retVal = 0;
void* retObj = &retVal;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
return retVal;
}
-void TestClass_Stub::handleStruct(vector<data> vecData) {
+vector<data> TestClass_Stub::handleStruct(vector<data> vecData) {
int numParam = 1;
- string sign = "structsize";
+ int methodId = 11;
string retType = "void";
string paramCls[] = { "int" };
int structsize = vecData.size();
void* paramObj[] = { &structsize };
void* retObj = NULL;
- rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
int numParam2 = 3*vecData.size();
- string sign2 = "handleStruct(StructJ[])";
- string retType2 = "void";
+ int methodId2 = 10;
+ string retType2 = "int";
string paramCls2[numParam2];
void* paramObj2[numParam2];
int pos = 0;
paramCls2[pos] = "int";
paramObj2[pos] = &vecData[i].year; pos++;
}
- void* retObj2 = NULL;
- cout << "In handle struct 3!" << endl;
- rmiCall->remoteCall(objectId, sign2, retType2, paramCls2, paramObj2, numParam2, retObj2);
+ // RETURN STRUCT OBJECT
+ // Get length of struct array
+ int structsize1 = 0;
+ void* retObj2 = { &structsize1 };
+ // IF we don't have returned struct objects, then it's just "void* retObj2 = NULL;"
+ rmiCall->remoteCall(objectId, methodId2, retType2, paramCls2, paramObj2, numParam2, retObj2);
+ cout << "Struct length: " << structsize1 << endl;
+
+ // Get the returned objects
+ string retCls[3*structsize1];
+ void* retObj3[3*structsize1];
+ int numRet = 3*structsize1;
+ // define array of everything
+ string param1[structsize1];
+ float param2[structsize1];
+ int param3[structsize1];
+ pos = 0;
+ for(int i=0; i < structsize1; i++) {
+ retCls[pos] = "string";
+ retObj3[pos++] = ¶m1[i];
+ retCls[pos] = "float";
+ retObj3[pos++] = ¶m2[i];
+ retCls[pos] = "int";
+ retObj3[pos++] = ¶m3[i];
+ }
+ rmiCall->getStructObjects(retCls, numRet, retObj3);
+ vector<data> dat(structsize1);
+ pos = 0;
+ for (int i=0; i < structsize1; i++) {
+ dat[i].name = param1[i];
+ dat[i].value = param2[i];
+ dat[i].year = param3[i];
+ }
+
+ return dat;
}
+vector<EnumC> TestClass_Stub::handleEnum(vector<EnumC> vecEn) {
+
+ int numParam = 1;
+ int numEl = vecEn.size();
+ int methodId = 12;
+ string retType = "int[]";
+ string paramCls[] = { "int[]" };
+ // Need to define this container for integer version of enum
+ vector<int> paramInt(numEl);
+ for(int i = 0; i < numEl; i++) {
+ paramInt[i] = (int) vecEn[i]; // cast enum to integer
+ }
+ void* paramObj[] = { ¶mInt };
+ // if no return value just
+ // void* retObj2 = NULL;
+ // This is with return value:
+ vector<int> retEnumInt;
+ void* retObj = &retEnumInt;
+ rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
+ int enumsize1 = retEnumInt.size();
+ vector<EnumC> retVal(enumsize1);
+ for (int i=0; i < enumsize1; i++) {
+ retVal[i] = (EnumC) retEnumInt[i];
+ }
+ return retVal;
+}
+
+
+
#endif
projects / iot2.git / blobdiff