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                 vector<data>            handleStruct(vector<data> vecData);
  31                 vector<EnumC>           handleEnum(vector<EnumC> vecEn);
  32                 void                            ____init_CallBack();    // thread
  33                 void                            ____registerCallBack(); // tell the other side that we are ready
  34
  35         private:
  36                 int                                                     intA;
  37                 float                                           floatB;
  38                 string                                          stringC;
  39                 //CallBackInterface                     cb;
  40                 IoTRMICall                                      *rmiCall;
  41                 IoTRMIObject                            *rmiObj;
  42                 string                                          address;
  43                 vector<int>                                     ports;
  44                 vector<CallBackInterface*>      vecCBObj;
  45
  46                 int             objectId = 0;   // Default value is 0
  47                 static int      objIdCnt;
  48 };
  49
  50
  51 int TestClass_Stub::objIdCnt = 0;
  52
  53
  54 TestClass_Stub::TestClass_Stub() {
  55
  56         address = "";
  57         rmiCall = NULL;
  58 }
  59
  60
  61 TestClass_Stub::TestClass_Stub(int _port, const char* _address, int _rev, bool* _bResult, vector<int> _ports) {
  62
  63         address = _address;
  64         rmiCall = new IoTRMICall(_port, _address, _rev, _bResult);
  65         ports = _ports;
  66         // Start thread
  67 //      thread th1 (&TestClass_Stub::____init_CallBack, this);
  68 //      th1.detach();
  69         //th1.join();
  70 //      ____registerCallBack();
  71 }
  72
  73
  74 TestClass_Stub::~TestClass_Stub() {
  75
  76         if (rmiCall != NULL) {
  77                 delete rmiCall;
  78                 rmiCall = NULL;
  79         }
  80         if (rmiObj != NULL) {
  81                 delete rmiObj;
  82                 rmiObj = NULL;
  83         }
  84         for(CallBackInterface* cb : vecCBObj) {
  85                 delete cb;
  86                 cb = NULL;
  87         }
  88 }
  89
  90
  91 // Callback handler thread
  92 void TestClass_Stub::____init_CallBack() {
  93
  94         bool bResult = false;
  95         rmiObj = new IoTRMIObject(ports[0], &bResult);
  96         while (true) {
  97                 char* method = rmiObj->getMethodBytes();
  98                 int objId = IoTRMIObject::getObjectId(method);
  99                 if (objId < vecCBObj.size()) {  // Check if still within range
 100                         CallBack_CBSkeleton* skel =
 101                                 dynamic_cast<CallBack_CBSkeleton*> (vecCBObj.at(objId));
 102                         skel->invokeMethod(rmiObj);
 103                 } else {
 104                         string error = "TestClass_Stub: Illegal object Id: " + to_string(objId);
 105                         throw error;
 106                 }
 107         }
 108 }
 109
 110
 111 // Notify that callback thread is ready
 112 void TestClass_Stub::____registerCallBack() {
 113
 114         int numParam = 3;
 115         int methodId = 9;
 116         string retType = "void";
 117         string paramCls[] = { "int", "string", "int" };
 118         int rev = 0;
 119         void* paramObj[] = { &ports[0], &address, &rev };
 120         void* retObj = NULL;
 121         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 122 }
 123
 124
 125 void TestClass_Stub::setA(int _int) {
 126
 127         int numParam = 1;
 128         int methodId = 0;
 129         string retType = "void";
 130         string paramCls[] = { "int" };
 131         void* paramObj[] = { &_int };
 132         void* retObj = NULL;
 133         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 134 }
 135
 136
 137 void TestClass_Stub::setB(float _float) {
 138
 139         int numParam = 1;
 140         int methodId = 1;
 141         string retType = "void";
 142         string paramCls[] = { "float" };
 143         void* paramObj[] = { &_float };
 144         void* retObj = NULL;
 145         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 146 }
 147
 148
 149 void TestClass_Stub::setC(string _string) {
 150
 151         int numParam = 1;
 152         int methodId = 2;
 153         string retType = "void";
 154         string paramCls[] = { "string" };
 155         void* paramObj[] = { &_string };
 156         void* retObj = NULL;
 157         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 158 }
 159
 160
 161 string TestClass_Stub::sumArray(vector<string> newA) {
 162
 163         int numParam = 1;
 164         int methodId = 3;
 165         string retType = "string";
 166         string paramCls[] = { "string[]" };
 167         void* paramObj[] = { &newA };
 168         string retVal = "";
 169         void* retObj = &retVal;
 170         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 171         return retVal;
 172 }
 173
 174
 175 /*int64_t TestClass_Stub::sumArray(vector<int> newA) {
 176
 177         int numParam = 1;
 178         string sign = "sumArray(int[])";
 179         string retType = "long";
 180         string paramCls[] = { "int[]" };
 181         void* paramObj[] = { &newA };
 182         int64_t retVal = 0;
 183         void* retObj = &retVal;
 184         rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 185         return retVal;
 186 }*/
 187
 188
 189
 190 int TestClass_Stub::setAndGetA(int newA) {
 191
 192         int numParam = 1;
 193         int methodId = 4;
 194         string retType = "int";
 195         string paramCls[] = { "int" };
 196         void* paramObj[] = { &newA };
 197         int retVal = 0;
 198         void* retObj = &retVal;
 199         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 200         return retVal;
 201 }
 202
 203
 204 int TestClass_Stub::setACAndGetA(string newC, int newA) {
 205
 206         int numParam = 2;
 207         int methodId = 5;
 208         string retType = "int";
 209         string paramCls[] = { "string", "int" };
 210         void* paramObj[] = { &newC, &newA };
 211         int retVal = 0;
 212         void* retObj = &retVal;
 213         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 214         return retVal;
 215 }
 216
 217
 218 void TestClass_Stub::registerCallback(CallBackInterface* _cb) {
 219
 220         //Should implement the callback here
 221 }
 222
 223
 224 void TestClass_Stub::registerCallback(vector<CallBackInterface*> _cb) {
 225
 226         for (CallBackInterface* cb: _cb) {
 227                 CallBack_CBSkeleton* skel = new CallBack_CBSkeleton(cb, objIdCnt++);
 228                 vecCBObj.push_back(skel);
 229         }
 230
 231         int numParam = 1;
 232         int methodId = 8;
 233         string retType = "void";
 234         string paramCls[] = { "int" };
 235         int param1 = _cb.size();
 236         void* paramObj[] = { &param1 };
 237         void* retObj = NULL;
 238         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 239 }
 240
 241
 242 int TestClass_Stub::callBack() {
 243
 244         int numParam = 0;
 245         int methodId = 6;
 246         string retType = "int";
 247         string paramCls[] = { };
 248         void* paramObj[] = { };
 249         int retVal = 0;
 250         void* retObj = &retVal;
 251         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 252         return retVal;
 253 }
 254
 255
 256 vector<data> TestClass_Stub::handleStruct(vector<data> vecData) {
 257
 258         int numParam = 1;
 259         int methodId = 11;
 260         string retType = "void";
 261         string paramCls[] = { "int" };
 262         int structsize = vecData.size();
 263         void* paramObj[] = { &structsize };
 264         void* retObj = NULL;
 265         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 266
 267         int numParam2 = 3*vecData.size();
 268         int methodId2 = 10;
 269         string retType2 = "int";
 270         string paramCls2[numParam2];
 271         void* paramObj2[numParam2];
 272         int pos = 0;
 273         for(int i = 0; i < vecData.size(); i++) {
 274                 paramCls2[pos] = "string";
 275                 paramObj2[pos] = &vecData[i].name; pos++;
 276                 paramCls2[pos] = "float";
 277                 paramObj2[pos] = &vecData[i].value; pos++;
 278                 paramCls2[pos] = "int";
 279                 paramObj2[pos] = &vecData[i].year; pos++;
 280         }
 281         // RETURN STRUCT OBJECT
 282         // Get length of struct array
 283         int structsize1 = 0;
 284         void* retObj2 = { &structsize1 };
 285         // IF we don't have returned struct objects, then it's just "void* retObj2 = NULL;"
 286         rmiCall->remoteCall(objectId, methodId2, retType2, paramCls2, paramObj2, numParam2, retObj2);
 287         cout << "Struct length: " << structsize1 << endl;
 288
 289         // Get the returned objects
 290         string retCls[3*structsize1];
 291         void* retObj3[3*structsize1];
 292         int numRet = 3*structsize1;
 293         // define array of everything
 294         string param1[structsize1];
 295         float param2[structsize1];
 296         int param3[structsize1];
 297         pos = 0;
 298         for(int i=0; i < structsize1; i++) {
 299                 retCls[pos] = "string";
 300                 retObj3[pos++] = &param1[i];
 301                 retCls[pos] = "float";
 302                 retObj3[pos++] = &param2[i];
 303                 retCls[pos] = "int";
 304                 retObj3[pos++] = &param3[i];
 305         }
 306         rmiCall->getStructObjects(retCls, numRet, retObj3);
 307         vector<data> dat(structsize1);
 308         pos = 0;
 309         for (int i=0; i < structsize1; i++) {
 310                 dat[i].name = param1[i];
 311                 dat[i].value = param2[i];
 312                 dat[i].year = param3[i];
 313         }
 314
 315         return dat;
 316 }
 317
 318
 319 vector<EnumC> TestClass_Stub::handleEnum(vector<EnumC> vecEn) {
 320
 321         int numParam = 1;
 322         int numEl = vecEn.size();
 323         int methodId = 12;
 324         string retType = "int[]";
 325         string paramCls[] = { "int[]" };
 326         // Need to define this container for integer version of enum
 327         vector<int> paramInt(numEl);
 328         for(int i = 0; i < numEl; i++) {
 329                 paramInt[i] = (int) vecEn[i]; // cast enum to integer
 330         }
 331         void* paramObj[] = { &paramInt };
 332         // if no return value just
 333         // void* retObj2 = NULL;
 334         // This is with return value:
 335         vector<int> retEnumInt;
 336         void* retObj = &retEnumInt;
 337         rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
 338         int enumsize1 = retEnumInt.size();
 339         vector<EnumC> retVal(enumsize1);
 340         for (int i=0; i < enumsize1; i++) {
 341                 retVal[i] = (EnumC) retEnumInt[i];
 342         }
 343         return retVal;
 344 }
 345
 346
 347
 348 #endif