1 #ifndef _TESTCLASS_SKELETON_HPP__
2 #define _TESTCLASS_SKELETON_HPP__
7 #include "../IoTRMIObject.hpp"
8 #include "../IoTRMICall.hpp"
9 #include "CallBack_CBStub.hpp"
10 #include "TestClassInterface.hpp"
14 class TestClass_Skeleton : public TestClassInterface {
16 TestClass_Skeleton(TestClassInterface* _tc, int _port);
17 ~TestClass_Skeleton();
19 void ___waitRequestInvokeMethod();
21 void setB(float _float);
22 void setC(string _string);
23 string sumArray(vector<string> newA);
24 //int64_t sumArray(vector<int> newA);
25 int setAndGetA(int newA);
26 int setACAndGetA(string newC, int newA);
27 void registerCallback(CallBackInterface* _cb);
28 void registerCallback(vector<CallBackInterface*> _cb);
30 vector<data> handleStruct(vector<data> vecData);
31 vector<EnumC> handleEnum(vector<EnumC> vecEn);
37 //int64_t ____sumArray();
39 void ___setACAndGetA();
40 void ___registerCallback();
41 void ____registerCallback();
42 // For array of callbacks
45 // For array of structs
47 void ___handleStruct(int structsize1);
49 void ___handleEnum(int enumsize1);
52 TestClassInterface *tc;
55 const static int object0Id;
56 //const static int object0Permission[];
57 const static set<int> set0Allowed;
61 vector<CallBackInterface*> vecCBObj;
62 //CallBackInterface cbstub;
67 const int TestClass_Skeleton::object0Id = 0;
68 //const int TestClass_Skeleton::object0Permission[] = {0, 1, 2, 3, 4, 5};
69 const set<int> TestClass_Skeleton::set0Allowed {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
71 int TestClass_Skeleton::objIdCnt = 0;
74 TestClass_Skeleton::TestClass_Skeleton(TestClassInterface* _tc, int _port) {
76 bool _bResult = false;
78 rmiObj = new IoTRMIObject(_port, &_bResult);
79 ___waitRequestInvokeMethod();
83 TestClass_Skeleton::~TestClass_Skeleton() {
89 if (rmiCall != NULL) {
93 for(CallBackInterface* cb : vecCBObj) {
100 void TestClass_Skeleton::setA(int _int) {
106 void TestClass_Skeleton::___setA() {
108 string paramCls[] = { "int" };
111 void* paramObj[] = { ¶m1 };
112 rmiObj->getMethodParams(paramCls, numParam, paramObj);
117 void TestClass_Skeleton::setB(float _float) {
123 void TestClass_Skeleton::___setB() {
125 string paramCls[] = { "float" };
128 void* paramObj[] = { ¶m1 };
129 rmiObj->getMethodParams(paramCls, numParam, paramObj);
134 void TestClass_Skeleton::setC(string _string) {
140 void TestClass_Skeleton::___setC() {
142 string paramCls[] = { "string" };
145 void* paramObj[] = { ¶m1 };
146 rmiObj->getMethodParams(paramCls, numParam, paramObj);
151 string TestClass_Skeleton::sumArray(vector<string> newA) {
153 return tc->sumArray(newA);
157 void TestClass_Skeleton::___sumArray() {
159 string paramCls[] = { "string[]" };
161 vector<string> param1;
162 void* paramObj[] = { ¶m1 };
163 rmiObj->getMethodParams(paramCls, numParam, paramObj);
164 string retVal = sumArray(param1);
165 void* retObj = &retVal;
166 rmiObj->sendReturnObj(retObj, "string");
170 /*int64_t TestClass_Skeleton::sumArray(vector<int> newA) {
172 return tc->sumArray(newA);
176 /*int64_t TestClass_Skeleton::____sumArray() {
181 int TestClass_Skeleton::setAndGetA(int newA) {
183 return tc->setAndGetA(newA);
187 void TestClass_Skeleton::___setAndGetA() {
189 string paramCls[] = { "int" };
192 void* paramObj[] = { ¶m1 };
193 rmiObj->getMethodParams(paramCls, numParam, paramObj);
194 int retVal = setAndGetA(param1);
195 void* retObj = &retVal;
196 rmiObj->sendReturnObj(retObj, "int");
200 int TestClass_Skeleton::setACAndGetA(string newC, int newA) {
202 return tc->setACAndGetA(newC, newA);
206 void TestClass_Skeleton::___setACAndGetA() {
208 string paramCls[] = { "string", "int" };
212 void* paramObj[] = { ¶m1, ¶m2 };
213 rmiObj->getMethodParams(paramCls, numParam, paramObj);
214 int retVal = setACAndGetA(param1, param2);
215 void* retObj = &retVal;
216 rmiObj->sendReturnObj(retObj, "int");
220 void TestClass_Skeleton::registerCallback(CallBackInterface* _cb) {
222 tc->registerCallback(_cb);
226 void TestClass_Skeleton::___registerCallback() {
231 void TestClass_Skeleton::registerCallback(vector<CallBackInterface*> _cb) {
233 tc->registerCallback(_cb);
237 void TestClass_Skeleton::___regCB() {
239 string paramCls[] = { "int", "string", "int" };
244 void* paramObj[] = { ¶m1, ¶m2, ¶m3 };
245 rmiObj->getMethodParams(paramCls, numParam, paramObj);
246 // Instantiate IoTRMICall object
247 bool bResult = false;
248 cout << "Port: " << param1 << endl;
249 cout << "Address: " << param2 << endl;
251 rmiCall = new IoTRMICall(param1, param2.c_str(), param3, &bResult);
255 void TestClass_Skeleton::____registerCallback() {
257 string paramCls[] = { "int" };
260 void* paramObj[] = { &numStubs };
261 rmiObj->getMethodParams(paramCls, numParam, paramObj);
262 vector<CallBackInterface*> stub;
263 for (int objId = 0; objId < numStubs; objId++) {
264 CallBackInterface* cb = new CallBack_CBStub(rmiCall, objIdCnt);
266 vecCBObj.push_back(cb);
269 registerCallback(stub);
273 int TestClass_Skeleton::callBack() {
279 void TestClass_Skeleton::___callBack() {
281 int retVal = callBack();
282 void* retObj = &retVal;
283 rmiObj->sendReturnObj(retObj, "int");
287 vector<data> TestClass_Skeleton::handleStruct(vector<data> vecData) {
289 return tc->handleStruct(vecData);
293 int TestClass_Skeleton::___structSize() {
295 string paramCls[] = { "int" };
298 void* paramObj[] = { ¶m1 };
299 rmiObj->getMethodParams(paramCls, numParam, paramObj);
304 void TestClass_Skeleton::___handleStruct(int structsize1) {
306 string paramCls[3*structsize1];
307 void* paramObj[3*structsize1];
308 int numParam = 3*structsize1;
309 // define array of everything
310 string param1[structsize1];
311 float param2[structsize1];
312 int param3[structsize1];
314 for(int i=0; i < structsize1; i++) {
315 paramCls[pos] = "string";
316 paramObj[pos++] = ¶m1[i];
317 paramCls[pos] = "float";
318 paramObj[pos++] = ¶m2[i];
319 paramCls[pos] = "int";
320 paramObj[pos++] = ¶m3[i];
322 rmiObj->getMethodParams(paramCls, numParam, paramObj);
323 vector<data> dat(structsize1);
325 for (int i=0; i < structsize1; i++) {
326 dat[i].name = param1[i];
327 dat[i].value = param2[i];
328 dat[i].year = param3[i];
330 // This is a return value of type vector of struct
331 // If no return value, then just "handleStruct(dat)"
332 vector<data> retData = handleStruct(dat);
333 // Send the length first!
334 int retLength = retData.size();
335 void* retObj = &retLength;
336 rmiObj->sendReturnObj(retObj, "int");
337 // Send the actual bytes - struct of 3 members
338 int numRetObj = 3*retLength;
339 string retCls[numRetObj];
340 void* retObj2[numRetObj];
342 for(int i = 0; i < retLength; i++) {
343 retCls[pos] = "string";
344 retObj2[pos] = &retData[i].name; pos++;
345 retCls[pos] = "float";
346 retObj2[pos] = &retData[i].value; pos++;
348 retObj2[pos] = &retData[i].year; pos++;
350 rmiObj->sendReturnObj(retObj2, retCls, numRetObj);
354 vector<EnumC> TestClass_Skeleton::handleEnum(vector<EnumC> vecEn) {
356 return tc->handleEnum(vecEn);
360 int TestClass_Skeleton::___enumSize() {
362 string paramCls[] = { "int" };
365 void* paramObj[] = { ¶m1 };
366 rmiObj->getMethodParams(paramCls, numParam, paramObj);
371 void TestClass_Skeleton::___handleEnum(int enumsize1) {
374 string paramCls[] = { "int[]" };
375 vector<int> paramInt;
376 void* paramObj[] = { ¶mInt };
377 // Receive the array of integers
378 rmiObj->getMethodParams(paramCls, numParam, paramObj);
379 int enumSize1 = paramInt.size();
380 vector<EnumC> en(enumSize1);
381 for (int i=0; i < enumSize1; i++) {
382 en[i] = (EnumC) paramInt[i];
385 // if void, just "handleEnum(en)"
386 // this is when we have return value vector<EnumC>
387 vector<EnumC> retEnum = handleEnum(en);
389 int enumSize2 = retEnum.size();
390 // Now send the array of integers
391 vector<int> retEnumInt(enumSize2);
392 for (int i=0; i < enumSize2; i++) {
393 retEnumInt[i] = (int) retEnum[i];
395 void* retObj = &retEnumInt;
396 rmiObj->sendReturnObj(retObj, "int[]");
400 void TestClass_Skeleton::___waitRequestInvokeMethod() {
404 // Loop continuously waiting for incoming bytes
407 rmiObj->getMethodBytes();
408 int _objectId = rmiObj->getObjectId();
409 int methodId = rmiObj->getMethodId();
410 if (_objectId == object0Id) {
411 // Multiplex based on object Id
412 // Complain if the method is not allowed
413 if (set0Allowed.find(methodId) == set0Allowed.end()) {
414 cerr << "TestClass_Skeleton: This object is not allowed to access method " << methodId << endl;
418 // If we have more than 1 object Id...
419 //else if (_objectId == object1Id) {
422 cerr << "TestClass_Skeleton: Unrecognizable object Id: " << _objectId << endl;
428 case 0: ___setA(); break;
429 case 1: ___setB(); break;
430 case 2: ___setC(); break;
431 case 3: ___sumArray(); break;
432 /* case 3: ____sumArray(); break;*/
433 case 4: ___setAndGetA(); break;
434 case 5: ___setACAndGetA(); break;
435 case 6: ___callBack(); break;
436 case 7: ___registerCallback(); break;
437 case 8: ____registerCallback(); break;
438 case 9: ___regCB(); break;
440 case 10: ___handleStruct(structsize1); break;
441 case 11: structsize1 = ___structSize(); break;
442 case 12: ___handleEnum(enumsize1); break;
444 string error = "Method Id not recognized!";