iotjava/iotrmi/C++/sample/TestClass_Stub.hpp

   1 #ifndef _TESTCLASS_STUB_HPP__
   2 #define _TESTCLASS_STUB_HPP__
   3
   4 #include <iostream>
   5 #include <thread>
   6 #include "../IoTRMICall.hpp"
   7 #include "../IoTRMIObject.hpp"
   8 #include "TestClassInterface.hpp"
   9 #include "CallBack_CBSkeleton.hpp"
  10 #include "StructC.hpp"
  11
  12 using namespace std;
  13
  14 class TestClass_Stub : public TestClassInterface {
  15         public:
  16                 TestClass_Stub();
  17                 TestClass_Stub(int _port, const char* _address, int _rev, bool* _bResult, vector<int> _ports);
  18                 ~TestClass_Stub();
  19
  20                 void                            setA(int _int);
  21                 void                            setB(float _float);
  22                 void                            setC(string _string);
  23                 string                          sumArray(vector<string> newA);
  24                 //int64_t                               sumArray(vector<int> newA);
  25                 int                                     setAndGetA(int newA);
  26                 int                                     setACAndGetA(string newC, int newA);
  27                 void                            registerCallback(CallBackInterface* _cb);
  28                 void                            registerCallback(vector<CallBackInterface*>_cb);
  29                 int                                     callBack();
  30                 void                            handleStruct(vector<data> vecData);
  31                 void                            ____init_CallBack();    // thread
  32                 void                            ____registerCallBack(); // tell the other side that we are ready
  33
  34                 const static int        size = 12;
  35                 const static string methodSignatures[size];
  36
  37         private:
  38                 int                                                     intA;
  39                 float                                           floatB;
  40                 string                                          stringC;
  41                 //CallBackInterface                     cb;
  42                 IoTRMICall                                      *rmiCall;
  43                 IoTRMIObject                            *rmiObj;
  44                 string                                          address;
  45                 vector<int>                                     ports;
  46                 vector<CallBackInterface*>      vecCBObj;
  47
  48                 int             objectId = 0;   // Default value is 0
  49                 static int      objIdCnt;
  50 };
  51
  52
  53 int TestClass_Stub::objIdCnt = 0;
  54
  55
  56 const string TestClass_Stub::methodSignatures[TestClass_Stub::size] = {
  57         "voidsetA(int)",
  58         "voidsetB(float)",
  59         "voidsetC(string)",
  60         "sumArray(string[])",
  61         //"sumArray(int[])",
  62         "intsetAndGetA(int)",
  63         "intsetACAndGetA(string,int)",
  64         "intcallBack()",
  65         "voidregisterCallBack(CallBackInterface)",
  66         "voidregisterCallBack(CallBackInterface[])",
  67         "registercallback",
  68         "handleStruct(StructJ[])",
  69         "structsize"
  70 };
  71
  72
  73 TestClass_Stub::TestClass_Stub() {
  74
  75         address = "";
  76         rmiCall = NULL;
  77 }
  78
  79
  80 TestClass_Stub::TestClass_Stub(int _port, const char* _address, int _rev, bool* _bResult, vector<int> _ports) {
  81
  82         address = _address;
  83         rmiCall = new IoTRMICall(_port, _address, _rev, _bResult, methodSignatures, size);
  84         ports = _ports;
  85         // Start thread
  86         cout << "Reached here 1!" << endl;
  87 //      thread th1 (&TestClass_Stub::____init_CallBack, this);
  88 //      th1.detach();
  89         //th1.join();
  90         cout << "Reached here 2!" << endl;
  91 //      ____registerCallBack();
  92 }
  93
  94
  95 TestClass_Stub::~TestClass_Stub() {
  96
  97         if (rmiCall != NULL) {
  98                 delete rmiCall;
  99                 rmiCall = NULL;
 100         }
 101         if (rmiObj != NULL) {
 102                 delete rmiObj;
 103                 rmiObj = NULL;
 104         }
 105         for(CallBackInterface* cb : vecCBObj) {
 106                 delete cb;
 107                 cb = NULL;
 108         }
 109 }
 110
 111
 112 // Callback handler thread
 113 void TestClass_Stub::____init_CallBack() {
 114
 115         bool bResult = false;
 116         cout << "Reach here init!" << endl;
 117         rmiObj = new IoTRMIObject(ports[0], &bResult, CallBack_CBSkeleton::methodSignatures, CallBack_CBSkeleton::size);
 118         cout << "Reach here init 2!" << endl;
 119         while (true) {
 120                 char* method = rmiObj->getMethodBytes();
 121                 cout << "Get method bytes here: " << endl;
 122                 IoTRMIUtil::printBytes(method, rmiObj->getMethodBytesLen(), false);
 123                 int objId = IoTRMIObject::getObjectId(method);
 124                 if (objId < vecCBObj.size()) {  // Check if still within range
 125                         CallBack_CBSkeleton* skel =
 126                                 dynamic_cast<CallBack_CBSkeleton*> (vecCBObj.at(objId));
 127                         cout << "Dynamic cast done!" << endl;
 128                         //rmiObj->setMethodBytes(method);
 129                         string type = "";
 130                         cout << "About to execute invoke method!" << endl;
 131                         void* retObj = skel->invokeMethod(rmiObj, &type);
 132                         cout << "Executed invoke method!" << endl;
 133                         if (type != "void") {
 134                                 rmiObj->sendReturnObj(retObj, type);
 135                                 cout << "Sent return object!" << endl;
 136                         }
 137                 } else {
 138                         string error = "TestClass_Stub: Illegal object Id: " + to_string(objId);
 139                         throw error;
 140                 }
 141         }
 142 }
 143
 144
 145 // Notify that callback thread is ready
 146 void TestClass_Stub::____registerCallBack() {
 147
 148         int numParam = 3;
 149         string sign = "registercallback";
 150         string retType = "void";
 151         string paramCls[] = { "int", "string", "int" };
 152         int rev = 0;
 153         void* paramObj[] = { &ports[0], &address, &rev };
 154         void* retObj = NULL;
 155         cout << "Get here! 1" << endl;
 156         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 157         cout << "Get here! 2" << endl;
 158 }
 159
 160
 161 void TestClass_Stub::setA(int _int) {
 162
 163         int numParam = 1;
 164         string sign = "voidsetA(int)";
 165         string retType = "void";
 166         string paramCls[] = { "int" };
 167         void* paramObj[] = { &_int };
 168         void* retObj = NULL;
 169         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 170 }
 171
 172
 173 void TestClass_Stub::setB(float _float) {
 174
 175         int numParam = 1;
 176         string sign = "voidsetB(float)";
 177         string retType = "void";
 178         string paramCls[] = { "float" };
 179         void* paramObj[] = { &_float };
 180         void* retObj = NULL;
 181         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 182 }
 183
 184
 185 void TestClass_Stub::setC(string _string) {
 186
 187         int numParam = 1;
 188         string sign = "voidsetC(string)";
 189         string retType = "void";
 190         string paramCls[] = { "string" };
 191         void* paramObj[] = { &_string };
 192         void* retObj = NULL;
 193         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 194 }
 195
 196
 197 string TestClass_Stub::sumArray(vector<string> newA) {
 198
 199         int numParam = 1;
 200         string sign = "sumArray(string[])";
 201         string retType = "string";
 202         string paramCls[] = { "string[]" };
 203         void* paramObj[] = { &newA };
 204         string retVal = "";
 205         void* retObj = &retVal;
 206         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 207         return retVal;
 208 }
 209
 210
 211 /*int64_t TestClass_Stub::sumArray(vector<int> newA) {
 212
 213         int numParam = 1;
 214         string sign = "sumArray(int[])";
 215         string retType = "long";
 216         string paramCls[] = { "int[]" };
 217         void* paramObj[] = { &newA };
 218         int64_t retVal = 0;
 219         void* retObj = &retVal;
 220         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 221         return retVal;
 222 }*/
 223
 224
 225
 226 int TestClass_Stub::setAndGetA(int newA) {
 227
 228         int numParam = 1;
 229         string sign = "intsetAndGetA(int)";
 230         string retType = "int";
 231         string paramCls[] = { "int" };
 232         void* paramObj[] = { &newA };
 233         int retVal = 0;
 234         void* retObj = &retVal;
 235         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 236         return retVal;
 237 }
 238
 239
 240 int TestClass_Stub::setACAndGetA(string newC, int newA) {
 241
 242         int numParam = 2;
 243         string sign = "intsetACAndGetA(string,int)";
 244         string retType = "int";
 245         string paramCls[] = { "string", "int" };
 246         void* paramObj[] = { &newC, &newA };
 247         int retVal = 0;
 248         void* retObj = &retVal;
 249         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 250         return retVal;
 251 }
 252
 253
 254 void TestClass_Stub::registerCallback(CallBackInterface* _cb) {
 255
 256         //Should implement the callback here
 257 }
 258
 259
 260 void TestClass_Stub::registerCallback(vector<CallBackInterface*> _cb) {
 261
 262         for (CallBackInterface* cb: _cb) {
 263                 CallBack_CBSkeleton* skel = new CallBack_CBSkeleton(cb, objIdCnt++);
 264                 vecCBObj.push_back(skel);
 265         }
 266
 267         int numParam = 1;
 268         string sign = "voidregisterCallBack(CallBackInterface[])";
 269         string retType = "void";
 270         string paramCls[] = { "int" };
 271         int param1 = _cb.size();
 272         void* paramObj[] = { &param1 };
 273         void* retObj = NULL;
 274         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 275 }
 276
 277
 278 int TestClass_Stub::callBack() {
 279
 280         int numParam = 0;
 281         string sign = "intcallBack()";
 282         string retType = "int";
 283         string paramCls[] = { };
 284         void* paramObj[] = { };
 285         int retVal = 0;
 286         void* retObj = &retVal;
 287         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 288         return retVal;
 289 }
 290
 291
 292 void TestClass_Stub::handleStruct(vector<data> vecData) {
 293
 294         int numParam = 1;
 295         string sign = "structsize";
 296         string retType = "void";
 297         string paramCls[] = { "int" };
 298         int structsize = vecData.size();
 299         void* paramObj[] = { &structsize };
 300         void* retObj = NULL;
 301         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 302
 303         int numParam2 = 3*vecData.size();
 304         string sign2 = "handleStruct(StructJ[])";
 305         string retType2 = "void";
 306         string paramCls2[numParam2];
 307         void* paramObj2[numParam2];
 308         int pos = 0;
 309         for(int i = 0; i < vecData.size(); i++) {
 310                 paramCls2[pos] = "string";
 311                 paramObj2[pos] = &vecData[i].name; pos++;
 312                 paramCls2[pos] = "float";
 313                 paramObj2[pos] = &vecData[i].value; pos++;
 314                 paramCls2[pos] = "int";
 315                 paramObj2[pos] = &vecData[i].year; pos++;
 316         }
 317         void* retObj2 = NULL;
 318         cout << "In handle struct 3!" << endl;
 319         rmiCall->remoteCall(objectId, sign2, retType2, paramCls2, paramObj2, numParam2, retObj2);
 320 }
 321
 322
 323 #endif