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

   1 #ifndef _TESTCLASS_SKELETON_HPP__
   2 #define _TESTCLASS_SKELETON_HPP__
   3
   4 #include <iostream>
   5 #include "../IoTRMIObject.hpp"
   6 #include "../IoTRMICall.hpp"
   7 #include "CallBack_CBStub.hpp"
   8 #include "TestClassInterface.hpp"
   9
  10 using namespace std;
  11
  12 class TestClass_Skeleton : public TestClassInterface {
  13         public:
  14                 TestClass_Skeleton(TestClassInterface* _tc, int _port);
  15                 ~TestClass_Skeleton();
  16
  17                 void                    ___waitRequestInvokeMethod();
  18                 void                    setA(int _int);
  19                 void                    setB(float _float);
  20                 void                    setC(string _string);
  21                 string                  sumArray(vector<string> newA);
  22                 //int64_t               sumArray(vector<int> newA);
  23                 int                             setAndGetA(int newA);
  24                 int                             setACAndGetA(string newC, int newA);
  25                 void                    registerCallback(CallBackInterface* _cb);
  26                 void                    registerCallback(vector<CallBackInterface*> _cb);
  27                 int                             callBack();
  28                 vector<data>    handleStruct(vector<data> vecData);
  29                 vector<EnumC>   handleEnum(vector<EnumC> vecEn);
  30
  31                 void                    ___setA();
  32                 void                    ___setB();
  33                 void                    ___setC();
  34                 void                    ___sumArray();
  35                 //int64_t               ____sumArray();
  36                 void                    ___setAndGetA();
  37                 void                    ___setACAndGetA();
  38                 void                    ___registerCallback();
  39                 void                    ____registerCallback();
  40                 // For array of callbacks
  41                 void                    ___regCB();
  42                 void                    ___callBack();
  43                 // For array of structs
  44                 int                             ___structSize();
  45                 void                    ___handleStruct(int structsize1);
  46                 int                             ___enumSize();
  47                 void                    ___handleEnum(int enumsize1);
  48
  49         private:
  50                 TestClassInterface                      *tc;
  51                 IoTRMIObject                            *rmiObj;
  52                 IoTRMICall                                      *rmiCall;
  53                 static int                                      objIdCnt;
  54                 vector<CallBackInterface*>      vecCBObj;
  55                 //CallBackInterface cbstub;
  56 };
  57
  58
  59 int TestClass_Skeleton::objIdCnt = 0;
  60
  61
  62 TestClass_Skeleton::TestClass_Skeleton(TestClassInterface* _tc, int _port) {
  63
  64         bool _bResult = false;
  65         tc = _tc;
  66         rmiObj = new IoTRMIObject(_port, &_bResult);
  67         ___waitRequestInvokeMethod();
  68 }
  69
  70
  71 TestClass_Skeleton::~TestClass_Skeleton() {
  72
  73         if (rmiObj != NULL) {
  74                 delete rmiObj;
  75                 rmiObj = NULL;
  76         }
  77         if (rmiCall != NULL) {
  78                 delete rmiCall;
  79                 rmiCall = NULL;
  80         }
  81         for(CallBackInterface* cb : vecCBObj) {
  82                 delete cb;
  83                 cb = NULL;
  84         }
  85 }
  86
  87
  88 void TestClass_Skeleton::setA(int _int) {
  89
  90         tc->setA(_int);
  91 }
  92
  93
  94 void TestClass_Skeleton::___setA() {
  95
  96         string paramCls[] = { "int" };
  97         int numParam = 1;
  98         int param1 = 0;
  99         void* paramObj[] = { &param1 };
 100         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 101         setA(param1);
 102 }
 103
 104
 105 void TestClass_Skeleton::setB(float _float) {
 106
 107         tc->setB(_float);
 108 }
 109
 110
 111 void TestClass_Skeleton::___setB() {
 112
 113         string paramCls[] = { "float" };
 114         int numParam = 1;
 115         float param1 = 0.0;
 116         void* paramObj[] = { &param1 };
 117         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 118         setB(param1);
 119 }
 120
 121
 122 void TestClass_Skeleton::setC(string _string) {
 123
 124         tc->setC(_string);
 125 }
 126
 127
 128 void TestClass_Skeleton::___setC() {
 129
 130         string paramCls[] = { "string" };
 131         int numParam = 1;
 132         string param1 = "";
 133         void* paramObj[] = { &param1 };
 134         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 135         setC(param1);
 136 }
 137
 138
 139 string TestClass_Skeleton::sumArray(vector<string> newA) {
 140
 141         return tc->sumArray(newA);
 142 }
 143
 144
 145 void TestClass_Skeleton::___sumArray() {
 146
 147         string paramCls[] = { "string[]" };
 148         int numParam = 1;
 149         vector<string> param1;
 150         void* paramObj[] = { &param1 };
 151         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 152         string retVal = sumArray(param1);
 153         void* retObj = &retVal;
 154         rmiObj->sendReturnObj(retObj, "string");
 155 }
 156
 157
 158 /*int64_t TestClass_Skeleton::sumArray(vector<int> newA) {
 159
 160         return tc->sumArray(newA);
 161 }*/
 162
 163
 164 /*int64_t TestClass_Skeleton::____sumArray() {
 165
 166 }*/
 167
 168
 169 int TestClass_Skeleton::setAndGetA(int newA) {
 170
 171         return tc->setAndGetA(newA);
 172 }
 173
 174
 175 void TestClass_Skeleton::___setAndGetA() {
 176
 177         string paramCls[] = { "int" };
 178         int numParam = 1;
 179         int param1 = 0;
 180         void* paramObj[] = { &param1 };
 181         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 182         int retVal = setAndGetA(param1);
 183         void* retObj = &retVal;
 184         rmiObj->sendReturnObj(retObj, "int");
 185 }
 186
 187
 188 int TestClass_Skeleton::setACAndGetA(string newC, int newA) {
 189
 190         return tc->setACAndGetA(newC, newA);
 191 }
 192
 193
 194 void TestClass_Skeleton::___setACAndGetA() {
 195
 196         string paramCls[] = { "string", "int" };
 197         int numParam = 2;
 198         string param1 = "";
 199         int param2 = 0;
 200         void* paramObj[] = { &param1, &param2 };
 201         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 202         int retVal = setACAndGetA(param1, param2);
 203         void* retObj = &retVal;
 204         rmiObj->sendReturnObj(retObj, "int");
 205 }
 206
 207
 208 void TestClass_Skeleton::registerCallback(CallBackInterface* _cb) {
 209
 210         tc->registerCallback(_cb);
 211 }
 212
 213
 214 void TestClass_Skeleton::___registerCallback() {
 215
 216 }
 217
 218
 219 void TestClass_Skeleton::registerCallback(vector<CallBackInterface*> _cb) {
 220
 221         tc->registerCallback(_cb);
 222 }
 223
 224
 225 void TestClass_Skeleton::___regCB() {
 226
 227         string paramCls[] = { "int", "string", "int" };
 228         int numParam = 3;
 229         int param1 = 0;
 230         string param2 = "";
 231         int param3 = 0;
 232         void* paramObj[] = { &param1, &param2, &param3 };
 233         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 234         // Instantiate IoTRMICall object
 235         bool bResult = false;
 236         cout << "Port: " << param1 << endl;
 237         cout << "Address: " << param2 << endl;
 238
 239         rmiCall = new IoTRMICall(param1, param2.c_str(), param3, &bResult);
 240 }
 241
 242
 243 void TestClass_Skeleton::____registerCallback() {
 244
 245         string paramCls[] = { "int" };
 246         int numParam = 1;
 247         int numStubs = 0;
 248         void* paramObj[] = { &numStubs };
 249         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 250         vector<CallBackInterface*> stub;
 251         for (int objId = 0; objId < numStubs; objId++) {
 252                 CallBackInterface* cb = new CallBack_CBStub(rmiCall, objIdCnt);
 253                 stub.push_back(cb);
 254                 vecCBObj.push_back(cb);
 255                 objIdCnt++;
 256         }
 257         registerCallback(stub);
 258 }
 259
 260
 261 int TestClass_Skeleton::callBack() {
 262
 263         tc->callBack();
 264 }
 265
 266
 267 void TestClass_Skeleton::___callBack() {
 268
 269         int retVal = callBack();
 270         void* retObj = &retVal;
 271         rmiObj->sendReturnObj(retObj, "int");
 272 }
 273
 274
 275 vector<data> TestClass_Skeleton::handleStruct(vector<data> vecData) {
 276
 277         return tc->handleStruct(vecData);
 278 }
 279
 280
 281 int TestClass_Skeleton::___structSize() {
 282
 283         string paramCls[] = { "int" };
 284         int numParam = 1;
 285         int param1 = 0;
 286         void* paramObj[] = { &param1 };
 287         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 288         return param1;
 289 }
 290
 291
 292 void TestClass_Skeleton::___handleStruct(int structsize1) {
 293
 294         string paramCls[3*structsize1];
 295         void* paramObj[3*structsize1];
 296         int numParam = 3*structsize1;
 297         // define array of everything
 298         string param1[structsize1];
 299         float param2[structsize1];
 300         int param3[structsize1];
 301         int pos = 0;
 302         for(int i=0; i < structsize1; i++) {
 303                 paramCls[pos] = "string";
 304                 paramObj[pos++] = &param1[i];
 305                 paramCls[pos] = "float";
 306                 paramObj[pos++] = &param2[i];
 307                 paramCls[pos] = "int";
 308                 paramObj[pos++] = &param3[i];
 309         }
 310         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 311         vector<data> dat(structsize1);
 312         pos = 0;
 313         for (int i=0; i < structsize1; i++) {
 314                 dat[i].name = param1[i];
 315                 dat[i].value = param2[i];
 316                 dat[i].year = param3[i];
 317         }
 318         // This is a return value of type vector of struct
 319         // If no return value, then just "handleStruct(dat)"
 320         vector<data> retData = handleStruct(dat);
 321         // Send the length first!
 322         int retLength = retData.size();
 323         void* retObj = &retLength;
 324         rmiObj->sendReturnObj(retObj, "int");
 325         // Send the actual bytes - struct of 3 members
 326         int numRetObj = 3*retLength;
 327         string retCls[numRetObj];
 328         void* retObj2[numRetObj];
 329         pos = 0;
 330         for(int i = 0; i < retLength; i++) {
 331                 retCls[pos] = "string";
 332                 retObj2[pos] = &retData[i].name; pos++;
 333                 retCls[pos] = "float";
 334                 retObj2[pos] = &retData[i].value; pos++;
 335                 retCls[pos] = "int";
 336                 retObj2[pos] = &retData[i].year; pos++;
 337         }
 338         rmiObj->sendReturnObj(retObj2, retCls, numRetObj);
 339 }
 340
 341
 342 vector<EnumC> TestClass_Skeleton::handleEnum(vector<EnumC> vecEn) {
 343
 344         return tc->handleEnum(vecEn);
 345 }
 346
 347
 348 int TestClass_Skeleton::___enumSize() {
 349
 350         string paramCls[] = { "int" };
 351         int numParam = 1;
 352         int param1 = 0;
 353         void* paramObj[] = { &param1 };
 354         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 355         return param1;
 356 }
 357
 358
 359 void TestClass_Skeleton::___handleEnum(int enumsize1) {
 360
 361         int numParam = 1;
 362         string paramCls[] = { "int[]" };
 363         vector<int> paramInt;
 364         void* paramObj[] = { &paramInt };
 365         // Receive the array of integers
 366         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 367         int enumSize1 = paramInt.size();
 368         vector<EnumC> en(enumSize1);
 369         for (int i=0; i < enumSize1; i++) {
 370                 en[i] = (EnumC) paramInt[i];
 371         }
 372         //handleEnum(en);
 373         // if void, just "handleEnum(en)"
 374         // this is when we have return value vector<EnumC>
 375         vector<EnumC> retEnum = handleEnum(en);
 376         // Get length first
 377         int enumSize2 = retEnum.size();
 378         // Now send the array of integers
 379         vector<int> retEnumInt(enumSize2);
 380         for (int i=0; i < enumSize2; i++) {
 381                 retEnumInt[i] = (int) retEnum[i];
 382         }
 383         void* retObj = &retEnumInt;
 384         rmiObj->sendReturnObj(retObj, "int[]");
 385 }
 386
 387
 388 void TestClass_Skeleton::___waitRequestInvokeMethod() {
 389
 390         int structsize1 = 0;
 391         int enumsize1 = 0;
 392         // Loop continuously waiting for incoming bytes
 393         while (true) {
 394
 395                 rmiObj->getMethodBytes();
 396                 int methodId = rmiObj->getMethodId();
 397
 398                 switch (methodId) {
 399                         case 0: ___setA(); break;
 400                         case 1: ___setB(); break;
 401                         case 2: ___setC(); break;
 402                         case 3: ___sumArray(); break;
 403                 /*  case 3: ____sumArray(); break;*/
 404                         case 4: ___setAndGetA(); break;
 405                         case 5: ___setACAndGetA(); break;
 406                         case 6: ___callBack(); break;
 407                         case 7: ___registerCallback(); break;
 408                         case 8: ____registerCallback(); break;
 409                         case 9: ___regCB(); break;
 410                         // Handle struct
 411                         case 10: ___handleStruct(structsize1); break;
 412                         case 11: structsize1 = ___structSize(); break;
 413                         case 12: ___handleEnum(enumsize1); break;
 414                         default:
 415                                 string error = "Method Id not recognized!";
 416                                 throw error;
 417                 }
 418         }
 419 }
 420
 421
 422 #endif
 423