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                 const static int        size = 12;
  31                 const static string methodSignatures[size];
  32
  33         private:
  34                 TestClassInterface                      *tc;
  35                 IoTRMIObject                            *rmiObj;
  36                 IoTRMICall                                      *rmiCall;
  37                 static int                                      objIdCnt;
  38                 vector<CallBackInterface*>      vecCBObj;
  39                 //CallBackInterface cbstub;
  40 };
  41
  42
  43 const string TestClass_Skeleton::methodSignatures[TestClass_Skeleton::size] = {
  44         "voidsetA(int)",
  45         "voidsetB(float)",
  46         "voidsetC(string)",
  47         "sumArray(string[])",
  48         //"sumArray(int[])",
  49         "intsetAndGetA(int)",
  50         "intsetACAndGetA(string,int)",
  51         "intcallBack()",
  52         "voidregisterCallBack(CallBackInterface)",
  53         "voidregisterCallBack(CallBackInterface[])",
  54         "registercallback",
  55         "handleStruct(StructJ[])",
  56         "structsize"
  57 };
  58
  59
  60 int TestClass_Skeleton::objIdCnt = 0;
  61
  62
  63 TestClass_Skeleton::TestClass_Skeleton(TestClassInterface* _tc, int _port) {
  64
  65         bool _bResult = false;
  66         tc = _tc;
  67         cout << "Reached here 1!" << endl;
  68         rmiObj = new IoTRMIObject(_port, &_bResult, methodSignatures, size);
  69         cout << "Reached here 2!" << endl;
  70         waitRequestInvokeMethod();
  71 }
  72
  73
  74 TestClass_Skeleton::~TestClass_Skeleton() {
  75
  76         if (rmiObj != NULL) {
  77                 delete rmiObj;
  78                 rmiObj = NULL;
  79         }
  80         if (rmiCall != NULL) {
  81                 delete rmiCall;
  82                 rmiCall = NULL;
  83         }
  84         for(CallBackInterface* cb : vecCBObj) {
  85                 delete cb;
  86                 cb = NULL;
  87         }
  88 }
  89
  90
  91 void TestClass_Skeleton::waitRequestInvokeMethod() {
  92
  93         int structsize1 = 0;
  94         // Loop continuously waiting for incoming bytes
  95         while (true) {
  96
  97                 rmiObj->getMethodBytes();
  98                 string methodSign = rmiObj->getSignature();
  99                 cout << "Method sign: " << methodSign << endl;
 100
 101                 if (methodSign.compare("voidsetA(int)") == 0) {
 102                         string paramCls[] = { "int" };
 103                         int numParam = 1;
 104                         int param1 = 0;
 105                         void* paramObj[] = { &param1 };
 106                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 107                         setA(param1);
 108                 } else if (methodSign.compare("voidsetB(float)") == 0) {
 109                         string paramCls[] = { "float" };
 110                         int numParam = 1;
 111                         float param1 = 0.0;
 112                         void* paramObj[] = { &param1 };
 113                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 114                         setB(param1);
 115                 } else if (methodSign.compare("voidsetC(string)") == 0) {
 116                         string paramCls[] = { "string" };
 117                         int numParam = 1;
 118                         string param1 = "";
 119                         void* paramObj[] = { &param1 };
 120                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 121                         setC(param1);
 122                 } else if (methodSign.compare("sumArray(string[])") == 0) {
 123                         string paramCls[] = { "string[]" };
 124                         int numParam = 1;
 125                         vector<string> param1;
 126                         void* paramObj[] = { &param1 };
 127                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 128                         string retVal = sumArray(param1);
 129                         void* retObj = &retVal;
 130                         rmiObj->sendReturnObj(retObj, "string");
 131                 /*} else if (methodSign.compare("sumArray(int[])") == 0) {
 132                         string paramCls[] = { "int[]" };
 133                         int numParam = 1;
 134                         vector<int> param1;
 135                         void* paramObj[] = { &param1 };
 136                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 137                         int64_t retVal = sumArray(param1);
 138                         void* retObj = &retVal;
 139                         rmiObj->sendReturnObj(retObj, "long");*/
 140                 } else if (methodSign.compare("intsetAndGetA(int)") == 0) {
 141                         string paramCls[] = { "int" };
 142                         int numParam = 1;
 143                         int param1 = 0;
 144                         void* paramObj[] = { &param1 };
 145                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 146                         int retVal = setAndGetA(param1);
 147                         void* retObj = &retVal;
 148                         rmiObj->sendReturnObj(retObj, "int");
 149                 } else if (methodSign.compare("intsetACAndGetA(string,int)") == 0) {
 150                         string paramCls[] = { "string", "int" };
 151                         int numParam = 2;
 152                         string param1 = "";
 153                         int param2 = 0;
 154                         void* paramObj[] = { &param1, &param2 };
 155                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 156                         int retVal = setACAndGetA(param1, param2);
 157                         void* retObj = &retVal;
 158                         rmiObj->sendReturnObj(retObj, "int");
 159                 /*} else if (methodSign.compare("voidregisterCallBack(CallBackInterface)") == 0) {
 160                         //*/
 161                 } else if (methodSign.compare("voidregisterCallBack(CallBackInterface[])") == 0) {
 162                         string paramCls[] = { "int" };
 163                         int numParam = 1;
 164                         int numStubs = 0;
 165                         void* paramObj[] = { &numStubs };
 166                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 167                         vector<CallBackInterface*> stub;
 168                         for (int objId = 0; objId < numStubs; objId++) {
 169                                 CallBackInterface* cb = new CallBack_CBStub(rmiCall, objIdCnt);
 170                                 stub.push_back(cb);
 171                                 vecCBObj.push_back(cb);
 172                                 objIdCnt++;
 173                         }
 174                         registerCallback(stub);
 175                 } else if (methodSign.compare("registercallback") == 0) {
 176                         string paramCls[] = { "int", "string", "int" };
 177                         int numParam = 3;
 178                         int param1 = 0;
 179                         string param2 = "";
 180                         int param3 = 0;
 181                         void* paramObj[] = { &param1, &param2, &param3 };
 182                         cout << "Get here! Registering callback!" << endl;
 183                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 184                         // Instantiate IoTRMICall object
 185                         bool bResult = false;
 186                         rmiCall = new IoTRMICall(param1, param2.c_str(), param3, &bResult,
 187                                 CallBack_CBStub::methodSignatures, CallBack_CBStub::size);
 188                 } else if (methodSign.compare("intcallBack()") == 0) {
 189                         cout << "Get here inside callback!!!" << endl;
 190                         int retVal = callBack();
 191                         cout << "Return value in TestClass_Skeleton: " << retVal << endl;
 192                         void* retObj = &retVal;
 193                         rmiObj->sendReturnObj(retObj, "int");
 194                 // Handle struct
 195                 } else if (methodSign.compare("structsize") == 0) {
 196                         string paramCls[] = { "int" };
 197                         int numParam = 1;
 198                         int param1 = 0;
 199                         void* paramObj[] = { &param1 };
 200                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 201                         structsize1 = param1;
 202                         cout << "Struct size: " << structsize1 << endl;
 203                 } else if (methodSign.compare("handleStruct(StructJ[])") == 0) {
 204                         string paramCls[3*structsize1];
 205                         void* paramObj[3*structsize1];
 206                         int numParam = 3*structsize1;
 207                         // define array of everything
 208                         string param1[structsize1];
 209                         float param2[structsize1];
 210                         int param3[structsize1];
 211                         int pos = 0;
 212                         for(int i=0; i < structsize1; i++) {
 213                                 paramCls[pos] = "string";
 214                                 paramObj[pos++] = &param1[i];
 215                                 paramCls[pos] = "float";
 216                                 paramObj[pos++] = &param2[i];
 217                                 paramCls[pos] = "int";
 218                                 paramObj[pos++] = &param3[i];
 219                         }
 220                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 221                         vector<data> dat(structsize1);
 222                         pos = 0;
 223                         for (int i=0; i < structsize1; i++) {
 224                                 dat[i].name = param1[i];
 225                                 dat[i].value = param2[i];
 226                                 dat[i].year = param3[i];
 227                         }
 228                         handleStruct(dat);
 229                 } else {
 230                         string error = "Signature unrecognized: " + string(methodSign);
 231                         throw error;
 232                 }
 233         }
 234 }
 235
 236
 237 void TestClass_Skeleton::setA(int _int) {
 238
 239         tc->setA(_int);
 240 }
 241
 242
 243 void TestClass_Skeleton::setB(float _float) {
 244
 245         tc->setB(_float);
 246 }
 247
 248
 249 void TestClass_Skeleton::setC(string _string) {
 250
 251         tc->setC(_string);
 252 }
 253
 254
 255 string TestClass_Skeleton::sumArray(vector<string> newA) {
 256
 257         return tc->sumArray(newA);;
 258 }
 259
 260
 261 /*int64_t TestClass_Skeleton::sumArray(vector<int> newA) {
 262
 263         return tc->sumArray(newA);
 264 }*/
 265
 266
 267 int TestClass_Skeleton::setAndGetA(int newA) {
 268
 269         return tc->setAndGetA(newA);
 270 }
 271
 272
 273 int TestClass_Skeleton::setACAndGetA(string newC, int newA) {
 274
 275         return tc->setACAndGetA(newC, newA);
 276 }
 277
 278
 279 void TestClass_Skeleton::registerCallback(CallBackInterface* _cb) {
 280
 281         tc->registerCallback(_cb);
 282 }
 283
 284
 285 void TestClass_Skeleton::registerCallback(vector<CallBackInterface*> _cb) {
 286
 287         tc->registerCallback(_cb);
 288 }
 289
 290
 291 int TestClass_Skeleton::callBack() {
 292
 293         tc->callBack();
 294 }
 295
 296
 297 void TestClass_Skeleton::handleStruct(vector<data> vecData) {
 298
 299         tc->handleStruct(vecData);
 300 }
 301
 302 #endif
 303