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

   1 #include <iostream>
   2 #include "../IoTRMIObject.hpp"
   3 #include "TestClass.hpp"
   4
   5 using namespace std;
   6
   7 class TestClass_Skeleton : public TestClassInterface {
   8         public:
   9                 TestClass_Skeleton(TestClassInterface* _tc, int _port);
  10                 ~TestClass_Skeleton();
  11
  12                 void                    waitRequestInvokeMethod();
  13                 void                    setA(int _int);
  14                 void                    setB(float _float);
  15                 void                    setC(string _string);
  16                 string                  sumArray(vector<string> newA);
  17                 //int64_t               sumArray(vector<int> newA);
  18                 int                             setAndGetA(int newA);
  19                 int                             setACAndGetA(string newC, int newA);
  20                 void                    registerCallback(CallBackInterface* _cb);
  21                 void                    registerCallback(vector<CallBackInterface*> _cb);
  22                 int                             callBack();
  23
  24                 const static int        size = 9;
  25                 const static string methodSignatures[size];
  26
  27         private:
  28                 TestClassInterface              *tc;
  29                 IoTRMIObject                    *rmiObj;
  30                 //CallBackInterface cbstub;
  31 };
  32
  33
  34 const string TestClass_Skeleton::methodSignatures[TestClass_Skeleton::size] = {
  35         "voidsetA(int)",
  36         "voidsetB(float)",
  37         "voidsetC(string)",
  38         "sumArray(string[])",
  39         //"sumArray(int[])",
  40         "intsetAndGetA(int)",
  41         "intsetACAndGetA(string,int)",
  42         "intcallBack()",
  43         "voidregisterCallBack(CallBackInterface)",
  44         "voidregisterCallBack(CallBackInterface[])"
  45 };
  46
  47
  48 TestClass_Skeleton::TestClass_Skeleton(TestClassInterface* _tc, int _port) {
  49
  50         bool _bResult = false;
  51         tc = _tc;
  52         rmiObj = new IoTRMIObject(_port, &_bResult, methodSignatures, size);
  53 }
  54
  55
  56 TestClass_Skeleton::~TestClass_Skeleton() {
  57
  58         if (rmiObj != NULL) {
  59                 delete rmiObj;
  60                 rmiObj = NULL;
  61         }
  62 }
  63
  64
  65 void TestClass_Skeleton::waitRequestInvokeMethod() {
  66
  67         // Loop continuously waiting for incoming bytes
  68         while (true) {
  69
  70                 rmiObj->getMethodBytes();
  71                 string methodSign = rmiObj->getSignature();
  72                 cout << "Method sign: " << methodSign << endl;
  73
  74                 if (methodSign.compare("voidsetA(int)") == 0) {
  75                         string paramCls[] = { "int" };
  76                         int numParam = 1;
  77                         int param1 = 0;
  78                         void* paramObj[] = { &param1 };
  79                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
  80                         setA(param1);
  81                 } else if (methodSign.compare("voidsetB(float)") == 0) {
  82                         string paramCls[] = { "float" };
  83                         int numParam = 1;
  84                         float param1 = 0.0;
  85                         void* paramObj[] = { &param1 };
  86                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
  87                         setB(param1);
  88                 } else if (methodSign.compare("voidsetC(string)") == 0) {
  89                         string paramCls[] = { "string" };
  90                         int numParam = 1;
  91                         string param1 = "";
  92                         void* paramObj[] = { &param1 };
  93                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
  94                         setC(param1);
  95                 } else if (methodSign.compare("sumArray(string[])") == 0) {
  96                         string paramCls[] = { "string[]" };
  97                         int numParam = 1;
  98                         vector<string> param1;
  99                         void* paramObj[] = { &param1 };
 100                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 101                         string retVal = sumArray(param1);
 102                         void* retObj = &retVal;
 103                         rmiObj->sendReturnObj(retObj, "string");
 104                 /*} else if (methodSign.compare("sumArray(int[])") == 0) {
 105                         string paramCls[] = { "int[]" };
 106                         int numParam = 1;
 107                         vector<int> param1;
 108                         void* paramObj[] = { &param1 };
 109                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 110                         int64_t retVal = sumArray(param1);
 111                         void* retObj = &retVal;
 112                         rmiObj->sendReturnObj(retObj, "long");*/
 113                 } else if (methodSign.compare("intsetAndGetA(int)") == 0) {
 114                         string paramCls[] = { "int" };
 115                         int numParam = 1;
 116                         int param1 = 0;
 117                         void* paramObj[] = { &param1 };
 118                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 119                         int retVal = setAndGetA(param1);
 120                         void* retObj = &retVal;
 121                         rmiObj->sendReturnObj(retObj, "int");
 122                 } else if (methodSign.compare("intsetACAndGetA(string,int)") == 0) {
 123                         string paramCls[] = { "string", "int" };
 124                         int numParam = 2;
 125                         string param1 = "";
 126                         int param2 = 0;
 127                         void* paramObj[] = { &param1, &param2 };
 128                         rmiObj->getMethodParams(paramCls, numParam, paramObj);
 129                         int retVal = setACAndGetA(param1, param2);
 130                         void* retObj = &retVal;
 131                         rmiObj->sendReturnObj(retObj, "int");
 132                 /*} else if (methodSign.compare("voidregisterCallBack(CallBackInterface)") == 0) {
 133                         //
 134                 } else if (methodSign.compare("intcallBack()") == 0) {
 135                         //*/
 136                 } else {
 137                         string error = "Signature unreqcognized: " + string(methodSign);
 138                         throw error;
 139                 }
 140         }
 141 }
 142
 143
 144 void TestClass_Skeleton::setA(int _int) {
 145
 146         tc->setA(_int);
 147 }
 148
 149
 150 void TestClass_Skeleton::setB(float _float) {
 151
 152         tc->setB(_float);
 153 }
 154
 155
 156 void TestClass_Skeleton::setC(string _string) {
 157
 158         tc->setC(_string);
 159 }
 160
 161
 162 string TestClass_Skeleton::sumArray(vector<string> newA) {
 163
 164         return tc->sumArray(newA);;
 165 }
 166
 167
 168 /*int64_t TestClass_Skeleton::sumArray(vector<int> newA) {
 169
 170         return tc->sumArray(newA);
 171 }*/
 172
 173
 174 int TestClass_Skeleton::setAndGetA(int newA) {
 175
 176         return tc->setAndGetA(newA);
 177 }
 178
 179
 180 int TestClass_Skeleton::setACAndGetA(string newC, int newA) {
 181
 182         return tc->setACAndGetA(newC, newA);
 183 }
 184
 185
 186 void TestClass_Skeleton::registerCallback(CallBackInterface* _cb) {
 187
 188         tc->registerCallback(_cb);
 189 }
 190
 191
 192 void TestClass_Skeleton::registerCallback(vector<CallBackInterface*> _cb) {
 193
 194         tc->registerCallback(_cb);
 195 }
 196
 197
 198 int TestClass_Skeleton::callBack() {
 199
 200         tc->callBack();
 201 }
 202
 203