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         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         rmiCall = new IoTRMICall(param1, param2.c_str(), param3, &bResult);
 237 }
 238
 239
 240 void TestClass_Skeleton::____registerCallback() {
 241
 242         string paramCls[] = { "int" };
 243         int numParam = 1;
 244         int numStubs = 0;
 245         void* paramObj[] = { &numStubs };
 246         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 247         vector<CallBackInterface*> stub;
 248         for (int objId = 0; objId < numStubs; objId++) {
 249                 CallBackInterface* cb = new CallBack_CBStub(rmiCall, objIdCnt);
 250                 stub.push_back(cb);
 251                 vecCBObj.push_back(cb);
 252                 objIdCnt++;
 253         }
 254         registerCallback(stub);
 255 }
 256
 257
 258 int TestClass_Skeleton::callBack() {
 259
 260         tc->callBack();
 261 }
 262
 263
 264 void TestClass_Skeleton::___callBack() {
 265
 266         int retVal = callBack();
 267         void* retObj = &retVal;
 268         rmiObj->sendReturnObj(retObj, "int");
 269 }
 270
 271
 272 void TestClass_Skeleton::handleStruct(vector<data> vecData) {
 273
 274         tc->handleStruct(vecData);
 275 }
 276
 277
 278 int TestClass_Skeleton::___structSize() {
 279
 280         string paramCls[] = { "int" };
 281         int numParam = 1;
 282         int param1 = 0;
 283         void* paramObj[] = { &param1 };
 284         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 285         return param1;
 286 }
 287
 288
 289 void TestClass_Skeleton::___handleStruct(int structsize1) {
 290
 291         string paramCls[3*structsize1];
 292         void* paramObj[3*structsize1];
 293         int numParam = 3*structsize1;
 294         // define array of everything
 295         string param1[structsize1];
 296         float param2[structsize1];
 297         int param3[structsize1];
 298         int pos = 0;
 299         for(int i=0; i < structsize1; i++) {
 300                 paramCls[pos] = "string";
 301                 paramObj[pos++] = &param1[i];
 302                 paramCls[pos] = "float";
 303                 paramObj[pos++] = &param2[i];
 304                 paramCls[pos] = "int";
 305                 paramObj[pos++] = &param3[i];
 306         }
 307         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 308         vector<data> dat(structsize1);
 309         pos = 0;
 310         for (int i=0; i < structsize1; i++) {
 311                 dat[i].name = param1[i];
 312                 dat[i].value = param2[i];
 313                 dat[i].year = param3[i];
 314         }
 315         handleStruct(dat);
 316 }
 317
 318
 319 vector<EnumC> TestClass_Skeleton::handleEnum(vector<EnumC> vecEn) {
 320
 321         return tc->handleEnum(vecEn);
 322 }
 323
 324
 325 int TestClass_Skeleton::___enumSize() {
 326
 327         string paramCls[] = { "int" };
 328         int numParam = 1;
 329         int param1 = 0;
 330         void* paramObj[] = { &param1 };
 331         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 332         return param1;
 333 }
 334
 335
 336 void TestClass_Skeleton::___handleEnum(int enumsize1) {
 337
 338         int numParam = 1;
 339         string paramCls[] = { "int[]" };
 340         vector<int> paramInt;
 341         void* paramObj[] = { &paramInt };
 342         // Receive the array of integers
 343         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 344         int enumSize1 = paramInt.size();
 345         vector<EnumC> en(enumSize1);
 346         for (int i=0; i < enumSize1; i++) {
 347                 en[i] = (EnumC) paramInt[i];
 348         }
 349         //handleEnum(en);
 350         // if void, just "handleEnum(en)"
 351         // this is when we have return value vector<EnumC>
 352         vector<EnumC> retEnum = handleEnum(en);
 353         // Get length first
 354         int enumSize2 = retEnum.size();
 355         // Now send the array of integers
 356         vector<int> retEnumInt(enumSize2);
 357         for (int i=0; i < enumSize2; i++) {
 358                 retEnumInt[i] = (int) retEnum[i];
 359         }
 360         void* retObj = &retEnumInt;
 361         rmiObj->sendReturnObj(retObj, "int[]");
 362 }
 363
 364
 365 void TestClass_Skeleton::___waitRequestInvokeMethod() {
 366
 367         int structsize1 = 0;
 368         int enumsize1 = 0;
 369         // Loop continuously waiting for incoming bytes
 370         while (true) {
 371
 372                 rmiObj->getMethodBytes();
 373                 int methodId = rmiObj->getMethodId();
 374
 375                 switch (methodId) {
 376                         case 0: ___setA(); break;
 377                         case 1: ___setB(); break;
 378                         case 2: ___setC(); break;
 379                         case 3: ___sumArray(); break;
 380                 /*  case 3: ____sumArray(); break;*/
 381                         case 4: ___setAndGetA(); break;
 382                         case 5: ___setACAndGetA(); break;
 383                         case 6: ___callBack(); break;
 384                         case 7: ___registerCallback(); break;
 385                         case 8: ____registerCallback(); break;
 386                         case 9: ___regCB(); break;
 387                         // Handle struct
 388                         case 10: ___handleStruct(structsize1); break;
 389                         case 11: structsize1 = ___structSize(); break;
 390                         case 12: ___handleEnum(enumsize1); break;
 391                         default:
 392                                 string error = "Method Id not recognized!";
 393                                 throw error;
 394                 }
 395         }
 396 }
 397
 398
 399 #endif
 400