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