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                 void                    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                 const static int        size = 12;
  50                 const static string methodSignatures[size];
  51
  52         private:
  53                 TestClassInterface                      *tc;
  54                 IoTRMIObject                            *rmiObj;
  55                 IoTRMICall                                      *rmiCall;
  56                 static int                                      objIdCnt;
  57                 vector<CallBackInterface*>      vecCBObj;
  58                 //CallBackInterface cbstub;
  59 };
  60
  61
  62 const string TestClass_Skeleton::methodSignatures[TestClass_Skeleton::size] = {
  63         "voidsetA(int)", // 0
  64         "voidsetB(float)", // 1
  65         "voidsetC(string)", // 2
  66         "sumArray(string[])", // 3
  67         //"sumArray(int[])",
  68         "intsetAndGetA(int)", // 4
  69         "intsetACAndGetA(string,int)", // 5
  70         "intcallBack()", // 6
  71         "voidregisterCallBack(CallBackInterface)", // 7
  72         "voidregisterCallBack(CallBackInterface[])", // 8
  73         "registercallback", // 9
  74         "handleStruct(StructJ[])", // 10
  75         "structsize" // 11
  76 };
  77
  78
  79 int TestClass_Skeleton::objIdCnt = 0;
  80
  81
  82 TestClass_Skeleton::TestClass_Skeleton(TestClassInterface* _tc, int _port) {
  83
  84         bool _bResult = false;
  85         tc = _tc;
  86         rmiObj = new IoTRMIObject(_port, &_bResult);
  87         ___waitRequestInvokeMethod();
  88 }
  89
  90
  91 TestClass_Skeleton::~TestClass_Skeleton() {
  92
  93         if (rmiObj != NULL) {
  94                 delete rmiObj;
  95                 rmiObj = NULL;
  96         }
  97         if (rmiCall != NULL) {
  98                 delete rmiCall;
  99                 rmiCall = NULL;
 100         }
 101         for(CallBackInterface* cb : vecCBObj) {
 102                 delete cb;
 103                 cb = NULL;
 104         }
 105 }
 106
 107
 108 void TestClass_Skeleton::setA(int _int) {
 109
 110         tc->setA(_int);
 111 }
 112
 113
 114 void TestClass_Skeleton::___setA() {
 115
 116         string paramCls[] = { "int" };
 117         int numParam = 1;
 118         int param1 = 0;
 119         void* paramObj[] = { &param1 };
 120         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 121         setA(param1);
 122 }
 123
 124
 125 void TestClass_Skeleton::setB(float _float) {
 126
 127         tc->setB(_float);
 128 }
 129
 130
 131 void TestClass_Skeleton::___setB() {
 132
 133         string paramCls[] = { "float" };
 134         int numParam = 1;
 135         float param1 = 0.0;
 136         void* paramObj[] = { &param1 };
 137         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 138         setB(param1);
 139 }
 140
 141
 142 void TestClass_Skeleton::setC(string _string) {
 143
 144         tc->setC(_string);
 145 }
 146
 147
 148 void TestClass_Skeleton::___setC() {
 149
 150         string paramCls[] = { "string" };
 151         int numParam = 1;
 152         string param1 = "";
 153         void* paramObj[] = { &param1 };
 154         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 155         setC(param1);
 156 }
 157
 158
 159 string TestClass_Skeleton::sumArray(vector<string> newA) {
 160
 161         return tc->sumArray(newA);
 162 }
 163
 164
 165 void TestClass_Skeleton::___sumArray() {
 166
 167         string paramCls[] = { "string[]" };
 168         int numParam = 1;
 169         vector<string> param1;
 170         void* paramObj[] = { &param1 };
 171         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 172         string retVal = sumArray(param1);
 173         void* retObj = &retVal;
 174         rmiObj->sendReturnObj(retObj, "string");
 175 }
 176
 177
 178 /*int64_t TestClass_Skeleton::sumArray(vector<int> newA) {
 179
 180         return tc->sumArray(newA);
 181 }*/
 182
 183
 184 /*int64_t TestClass_Skeleton::____sumArray() {
 185
 186 }*/
 187
 188
 189 int TestClass_Skeleton::setAndGetA(int newA) {
 190
 191         return tc->setAndGetA(newA);
 192 }
 193
 194
 195 void TestClass_Skeleton::___setAndGetA() {
 196
 197         string paramCls[] = { "int" };
 198         int numParam = 1;
 199         int param1 = 0;
 200         void* paramObj[] = { &param1 };
 201         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 202         int retVal = setAndGetA(param1);
 203         void* retObj = &retVal;
 204         rmiObj->sendReturnObj(retObj, "int");
 205 }
 206
 207
 208 int TestClass_Skeleton::setACAndGetA(string newC, int newA) {
 209
 210         return tc->setACAndGetA(newC, newA);
 211 }
 212
 213
 214 void TestClass_Skeleton::___setACAndGetA() {
 215
 216         string paramCls[] = { "string", "int" };
 217         int numParam = 2;
 218         string param1 = "";
 219         int param2 = 0;
 220         void* paramObj[] = { &param1, &param2 };
 221         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 222         int retVal = setACAndGetA(param1, param2);
 223         void* retObj = &retVal;
 224         rmiObj->sendReturnObj(retObj, "int");
 225 }
 226
 227
 228 void TestClass_Skeleton::registerCallback(CallBackInterface* _cb) {
 229
 230         tc->registerCallback(_cb);
 231 }
 232
 233
 234 void TestClass_Skeleton::___registerCallback() {
 235
 236 }
 237
 238
 239 void TestClass_Skeleton::registerCallback(vector<CallBackInterface*> _cb) {
 240
 241         tc->registerCallback(_cb);
 242 }
 243
 244
 245 void TestClass_Skeleton::___regCB() {
 246
 247         string paramCls[] = { "int", "string", "int" };
 248         int numParam = 3;
 249         int param1 = 0;
 250         string param2 = "";
 251         int param3 = 0;
 252         void* paramObj[] = { &param1, &param2, &param3 };
 253         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 254         // Instantiate IoTRMICall object
 255         bool bResult = false;
 256         rmiCall = new IoTRMICall(param1, param2.c_str(), param3, &bResult);
 257 }
 258
 259
 260 void TestClass_Skeleton::____registerCallback() {
 261
 262         string paramCls[] = { "int" };
 263         int numParam = 1;
 264         int numStubs = 0;
 265         void* paramObj[] = { &numStubs };
 266         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 267         vector<CallBackInterface*> stub;
 268         for (int objId = 0; objId < numStubs; objId++) {
 269                 CallBackInterface* cb = new CallBack_CBStub(rmiCall, objIdCnt);
 270                 stub.push_back(cb);
 271                 vecCBObj.push_back(cb);
 272                 objIdCnt++;
 273         }
 274         registerCallback(stub);
 275 }
 276
 277
 278 int TestClass_Skeleton::callBack() {
 279
 280         tc->callBack();
 281 }
 282
 283
 284 void TestClass_Skeleton::___callBack() {
 285
 286         int retVal = callBack();
 287         void* retObj = &retVal;
 288         rmiObj->sendReturnObj(retObj, "int");
 289 }
 290
 291
 292 void TestClass_Skeleton::handleStruct(vector<data> vecData) {
 293
 294         tc->handleStruct(vecData);
 295 }
 296
 297
 298 int TestClass_Skeleton::___structSize() {
 299
 300         string paramCls[] = { "int" };
 301         int numParam = 1;
 302         int param1 = 0;
 303         void* paramObj[] = { &param1 };
 304         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 305         return param1;
 306 }
 307
 308
 309 void TestClass_Skeleton::___handleStruct(int structsize1) {
 310
 311         string paramCls[3*structsize1];
 312         void* paramObj[3*structsize1];
 313         int numParam = 3*structsize1;
 314         // define array of everything
 315         string param1[structsize1];
 316         float param2[structsize1];
 317         int param3[structsize1];
 318         int pos = 0;
 319         for(int i=0; i < structsize1; i++) {
 320                 paramCls[pos] = "string";
 321                 paramObj[pos++] = &param1[i];
 322                 paramCls[pos] = "float";
 323                 paramObj[pos++] = &param2[i];
 324                 paramCls[pos] = "int";
 325                 paramObj[pos++] = &param3[i];
 326         }
 327         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 328         vector<data> dat(structsize1);
 329         pos = 0;
 330         for (int i=0; i < structsize1; i++) {
 331                 dat[i].name = param1[i];
 332                 dat[i].value = param2[i];
 333                 dat[i].year = param3[i];
 334         }
 335         handleStruct(dat);
 336 }
 337
 338
 339 vector<EnumC> TestClass_Skeleton::handleEnum(vector<EnumC> vecEn) {
 340
 341         return tc->handleEnum(vecEn);
 342 }
 343
 344
 345 int TestClass_Skeleton::___enumSize() {
 346
 347         string paramCls[] = { "int" };
 348         int numParam = 1;
 349         int param1 = 0;
 350         void* paramObj[] = { &param1 };
 351         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 352         return param1;
 353 }
 354
 355
 356 void TestClass_Skeleton::___handleEnum(int enumsize1) {
 357
 358         string paramCls[enumsize1];
 359         void* paramObj[enumsize1];
 360         int numParam = enumsize1;
 361         // define array of everything
 362         int param1[enumsize1];
 363         for(int i=0; i < enumsize1; i++) {
 364                 paramCls[i] = "int";
 365                 paramObj[i] = &param1[i];
 366         }
 367         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 368         vector<EnumC> en(enumsize1);
 369         for (int i=0; i < enumsize1; i++) {
 370                 en[i] = (EnumC) param1[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                         case 13: enumsize1 = ___enumSize(); break;
 415                         default:
 416                                 string error = "Method Id not recognized!";
 417                                 throw error;
 418                 }
 419         }
 420 }
 421
 422
 423 #endif
 424