1 #ifndef _TESTCLASS_SKELETON_HPP__
2 #define _TESTCLASS_SKELETON_HPP__
5 #include "../IoTRMIObject.hpp"
6 #include "../IoTRMICall.hpp"
7 #include "CallBack_CBStub.hpp"
8 #include "TestClassInterface.hpp"
12 class TestClass_Skeleton : public TestClassInterface {
14 TestClass_Skeleton(TestClassInterface* _tc, int _port);
15 ~TestClass_Skeleton();
17 void ___waitRequestInvokeMethod();
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);
28 void handleStruct(vector<data> vecData);
29 void handleEnum(vector<EnumC> vecEn);
35 //int64_t ____sumArray();
37 void ___setACAndGetA();
38 void ___registerCallback();
39 void ____registerCallback();
40 // For array of callbacks
43 // For array of structs
45 void ___handleStruct(int structsize1);
47 void ___handleEnum(int enumsize1);
49 const static int size = 12;
50 const static string methodSignatures[size];
53 TestClassInterface *tc;
57 vector<CallBackInterface*> vecCBObj;
58 //CallBackInterface cbstub;
62 const string TestClass_Skeleton::methodSignatures[TestClass_Skeleton::size] = {
64 "voidsetB(float)", // 1
65 "voidsetC(string)", // 2
66 "sumArray(string[])", // 3
68 "intsetAndGetA(int)", // 4
69 "intsetACAndGetA(string,int)", // 5
71 "voidregisterCallBack(CallBackInterface)", // 7
72 "voidregisterCallBack(CallBackInterface[])", // 8
73 "registercallback", // 9
74 "handleStruct(StructJ[])", // 10
79 int TestClass_Skeleton::objIdCnt = 0;
82 TestClass_Skeleton::TestClass_Skeleton(TestClassInterface* _tc, int _port) {
84 bool _bResult = false;
86 rmiObj = new IoTRMIObject(_port, &_bResult);
87 ___waitRequestInvokeMethod();
91 TestClass_Skeleton::~TestClass_Skeleton() {
97 if (rmiCall != NULL) {
101 for(CallBackInterface* cb : vecCBObj) {
108 void TestClass_Skeleton::setA(int _int) {
114 void TestClass_Skeleton::___setA() {
116 string paramCls[] = { "int" };
119 void* paramObj[] = { ¶m1 };
120 rmiObj->getMethodParams(paramCls, numParam, paramObj);
125 void TestClass_Skeleton::setB(float _float) {
131 void TestClass_Skeleton::___setB() {
133 string paramCls[] = { "float" };
136 void* paramObj[] = { ¶m1 };
137 rmiObj->getMethodParams(paramCls, numParam, paramObj);
142 void TestClass_Skeleton::setC(string _string) {
148 void TestClass_Skeleton::___setC() {
150 string paramCls[] = { "string" };
153 void* paramObj[] = { ¶m1 };
154 rmiObj->getMethodParams(paramCls, numParam, paramObj);
159 string TestClass_Skeleton::sumArray(vector<string> newA) {
161 return tc->sumArray(newA);
165 void TestClass_Skeleton::___sumArray() {
167 string paramCls[] = { "string[]" };
169 vector<string> param1;
170 void* paramObj[] = { ¶m1 };
171 rmiObj->getMethodParams(paramCls, numParam, paramObj);
172 string retVal = sumArray(param1);
173 void* retObj = &retVal;
174 rmiObj->sendReturnObj(retObj, "string");
178 /*int64_t TestClass_Skeleton::sumArray(vector<int> newA) {
180 return tc->sumArray(newA);
184 /*int64_t TestClass_Skeleton::____sumArray() {
189 int TestClass_Skeleton::setAndGetA(int newA) {
191 return tc->setAndGetA(newA);
195 void TestClass_Skeleton::___setAndGetA() {
197 string paramCls[] = { "int" };
200 void* paramObj[] = { ¶m1 };
201 rmiObj->getMethodParams(paramCls, numParam, paramObj);
202 int retVal = setAndGetA(param1);
203 void* retObj = &retVal;
204 rmiObj->sendReturnObj(retObj, "int");
208 int TestClass_Skeleton::setACAndGetA(string newC, int newA) {
210 return tc->setACAndGetA(newC, newA);
214 void TestClass_Skeleton::___setACAndGetA() {
216 string paramCls[] = { "string", "int" };
220 void* paramObj[] = { ¶m1, ¶m2 };
221 rmiObj->getMethodParams(paramCls, numParam, paramObj);
222 int retVal = setACAndGetA(param1, param2);
223 void* retObj = &retVal;
224 rmiObj->sendReturnObj(retObj, "int");
228 void TestClass_Skeleton::registerCallback(CallBackInterface* _cb) {
230 tc->registerCallback(_cb);
234 void TestClass_Skeleton::___registerCallback() {
239 void TestClass_Skeleton::registerCallback(vector<CallBackInterface*> _cb) {
241 tc->registerCallback(_cb);
245 void TestClass_Skeleton::___regCB() {
247 string paramCls[] = { "int", "string", "int" };
252 void* paramObj[] = { ¶m1, ¶m2, ¶m3 };
253 rmiObj->getMethodParams(paramCls, numParam, paramObj);
254 // Instantiate IoTRMICall object
255 bool bResult = false;
256 rmiCall = new IoTRMICall(param1, param2.c_str(), param3, &bResult);
260 void TestClass_Skeleton::____registerCallback() {
262 string paramCls[] = { "int" };
265 void* paramObj[] = { &numStubs };
266 rmiObj->getMethodParams(paramCls, numParam, paramObj);
267 vector<CallBackInterface*> stub;
268 for (int objId = 0; objId < numStubs; objId++) {
269 CallBackInterface* cb = new CallBack_CBStub(rmiCall, objIdCnt);
271 vecCBObj.push_back(cb);
274 registerCallback(stub);
278 int TestClass_Skeleton::callBack() {
284 void TestClass_Skeleton::___callBack() {
286 int retVal = callBack();
287 void* retObj = &retVal;
288 rmiObj->sendReturnObj(retObj, "int");
292 void TestClass_Skeleton::handleStruct(vector<data> vecData) {
294 tc->handleStruct(vecData);
298 int TestClass_Skeleton::___structSize() {
300 string paramCls[] = { "int" };
303 void* paramObj[] = { ¶m1 };
304 rmiObj->getMethodParams(paramCls, numParam, paramObj);
309 void TestClass_Skeleton::___handleStruct(int structsize1) {
311 string paramCls[3*structsize1];
312 void* paramObj[3*structsize1];
313 int numParam = 3*structsize1;
314 // define array of everything
315 string param1[structsize1];
316 float param2[structsize1];
317 int param3[structsize1];
319 for(int i=0; i < structsize1; i++) {
320 paramCls[pos] = "string";
321 paramObj[pos++] = ¶m1[i];
322 paramCls[pos] = "float";
323 paramObj[pos++] = ¶m2[i];
324 paramCls[pos] = "int";
325 paramObj[pos++] = ¶m3[i];
327 rmiObj->getMethodParams(paramCls, numParam, paramObj);
328 vector<data> dat(structsize1);
330 for (int i=0; i < structsize1; i++) {
331 dat[i].name = param1[i];
332 dat[i].value = param2[i];
333 dat[i].year = param3[i];
339 void TestClass_Skeleton::handleEnum(vector<EnumC> vecEn) {
341 tc->handleEnum(vecEn);
345 int TestClass_Skeleton::___enumSize() {
347 string paramCls[] = { "int" };
350 void* paramObj[] = { ¶m1 };
351 rmiObj->getMethodParams(paramCls, numParam, paramObj);
356 void TestClass_Skeleton::___handleEnum(int enumsize1) {
358 string paramCls[enumsize1];
359 void* paramObj[enumsize1];
360 int numParam = enumsize1;
361 // define array of everything
362 int param1[enumsize1];
363 for(int i=0; i < enumsize1; i++) {
365 paramObj[i] = ¶m1[i];
367 rmiObj->getMethodParams(paramCls, numParam, paramObj);
368 vector<EnumC> en(enumsize1);
369 for (int i=0; i < enumsize1; i++) {
370 en[i] = (EnumC) param1[i];
376 void TestClass_Skeleton::___waitRequestInvokeMethod() {
380 // Loop continuously waiting for incoming bytes
383 rmiObj->getMethodBytes();
384 int methodId = rmiObj->getMethodId();
387 case 0: ___setA(); break;
388 case 1: ___setB(); break;
389 case 2: ___setC(); break;
390 case 3: ___sumArray(); break;
391 /* case 3: ____sumArray(); break;*/
392 case 4: ___setAndGetA(); break;
393 case 5: ___setACAndGetA(); break;
394 case 6: ___callBack(); break;
395 case 7: ___registerCallback(); break;
396 case 8: ____registerCallback(); break;
397 case 9: ___regCB(); break;
399 case 10: ___handleStruct(structsize1); break;
400 case 11: structsize1 = ___structSize(); break;
401 case 12: ___handleEnum(enumsize1); break;
402 case 13: enumsize1 = ___enumSize(); break;
404 string error = "Method Id not recognized!";