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