1 #ifndef _TESTCLASS_STUB_HPP__
2 #define _TESTCLASS_STUB_HPP__
6 #include "../IoTRMICall.hpp"
7 #include "../IoTRMIObject.hpp"
8 #include "TestClassInterface.hpp"
9 #include "CallBack_CBSkeleton.hpp"
10 #include "StructC.hpp"
14 class TestClass_Stub : public TestClassInterface {
17 TestClass_Stub(int _port, const char* _address, int _rev, bool* _bResult, vector<int> _ports);
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);
32 void ____init_CallBack(); // thread
33 void ____registerCallBack(); // tell the other side that we are ready
39 //CallBackInterface cb;
43 const static int objectId = 0; // Default value is 0
45 // Specific for callbacks
47 vector<CallBackInterface*> vecCBObj;
52 int TestClass_Stub::objIdCnt = 0;
55 TestClass_Stub::TestClass_Stub() {
62 TestClass_Stub::TestClass_Stub(int _port, const char* _address, int _rev, bool* _bResult, vector<int> _ports) {
65 rmiCall = new IoTRMICall(_port, _address, _rev, _bResult);
68 // thread th1 (&TestClass_Stub::____init_CallBack, this);
71 // ____registerCallBack();
75 TestClass_Stub::~TestClass_Stub() {
77 if (rmiCall != NULL) {
85 // Special for callbacks!!!
86 for(CallBackInterface* cb : vecCBObj) {
93 // Callback handler thread
94 void TestClass_Stub::____init_CallBack() {
97 rmiObj = new IoTRMIObject(ports[0], &bResult);
99 char* method = rmiObj->getMethodBytes();
100 int objId = IoTRMIObject::getObjectId(method);
101 if (objId < vecCBObj.size()) { // Check if still within range
102 CallBack_CBSkeleton* skel =
103 dynamic_cast<CallBack_CBSkeleton*> (vecCBObj.at(objId));
104 skel->invokeMethod(rmiObj);
106 string error = "TestClass_Stub: Illegal object Id: " + to_string(objId);
113 // Notify that callback thread is ready
114 void TestClass_Stub::____registerCallBack() {
118 string retType = "void";
119 string paramCls[] = { "int", "string", "int" };
121 void* paramObj[] = { &ports[0], &address, &rev };
123 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
127 void TestClass_Stub::setA(int _int) {
131 string retType = "void";
132 string paramCls[] = { "int" };
133 void* paramObj[] = { &_int };
135 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
139 void TestClass_Stub::setB(float _float) {
143 string retType = "void";
144 string paramCls[] = { "float" };
145 void* paramObj[] = { &_float };
147 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
151 void TestClass_Stub::setC(string _string) {
155 string retType = "void";
156 string paramCls[] = { "string" };
157 void* paramObj[] = { &_string };
159 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
163 string TestClass_Stub::sumArray(vector<string> newA) {
167 string retType = "string";
168 string paramCls[] = { "string[]" };
169 void* paramObj[] = { &newA };
171 void* retObj = &retVal;
172 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
177 /*int64_t TestClass_Stub::sumArray(vector<int> newA) {
180 string sign = "sumArray(int[])";
181 string retType = "long";
182 string paramCls[] = { "int[]" };
183 void* paramObj[] = { &newA };
185 void* retObj = &retVal;
186 rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
192 int TestClass_Stub::setAndGetA(int newA) {
196 string retType = "int";
197 string paramCls[] = { "int" };
198 void* paramObj[] = { &newA };
200 void* retObj = &retVal;
201 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
206 int TestClass_Stub::setACAndGetA(string newC, int newA) {
210 string retType = "int";
211 string paramCls[] = { "string", "int" };
212 void* paramObj[] = { &newC, &newA };
214 void* retObj = &retVal;
215 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
220 void TestClass_Stub::registerCallback(CallBackInterface* _cb) {
222 //Should implement the callback here
226 void TestClass_Stub::registerCallback(vector<CallBackInterface*> _cb) {
228 for (CallBackInterface* cb: _cb) {
229 CallBack_CBSkeleton* skel = new CallBack_CBSkeleton(cb, objIdCnt++);
230 vecCBObj.push_back(skel);
235 string retType = "void";
236 string paramCls[] = { "int" };
237 int param1 = _cb.size();
238 void* paramObj[] = { ¶m1 };
240 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
244 int TestClass_Stub::callBack() {
248 string retType = "int";
249 string paramCls[] = { };
250 void* paramObj[] = { };
252 void* retObj = &retVal;
253 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
258 vector<data> TestClass_Stub::handleStruct(vector<data> vecData) {
262 string retType = "void";
263 string paramCls[] = { "int" };
264 int structsize = vecData.size();
265 void* paramObj[] = { &structsize };
267 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
269 int numParam2 = 3*vecData.size();
271 string retType2 = "int";
272 string paramCls2[numParam2];
273 void* paramObj2[numParam2];
275 for(int i = 0; i < vecData.size(); i++) {
276 paramCls2[pos] = "string";
277 paramObj2[pos] = &vecData[i].name; pos++;
278 paramCls2[pos] = "float";
279 paramObj2[pos] = &vecData[i].value; pos++;
280 paramCls2[pos] = "int";
281 paramObj2[pos] = &vecData[i].year; pos++;
283 // RETURN STRUCT OBJECT
284 // Get length of struct array
286 void* retObj2 = { &structsize1 };
287 // IF we don't have returned struct objects, then it's just "void* retObj2 = NULL;"
288 rmiCall->remoteCall(objectId, methodId2, retType2, paramCls2, paramObj2, numParam2, retObj2);
289 cout << "Struct length: " << structsize1 << endl;
291 // Get the returned objects
292 string retCls[3*structsize1];
293 void* retObj3[3*structsize1];
294 int numRet = 3*structsize1;
295 // define array of everything
296 string param1[structsize1];
297 float param2[structsize1];
298 int param3[structsize1];
300 for(int i=0; i < structsize1; i++) {
301 retCls[pos] = "string";
302 retObj3[pos++] = ¶m1[i];
303 retCls[pos] = "float";
304 retObj3[pos++] = ¶m2[i];
306 retObj3[pos++] = ¶m3[i];
308 rmiCall->getStructObjects(retCls, numRet, retObj3);
309 vector<data> dat(structsize1);
311 for (int i=0; i < structsize1; i++) {
312 dat[i].name = param1[i];
313 dat[i].value = param2[i];
314 dat[i].year = param3[i];
321 vector<EnumC> TestClass_Stub::handleEnum(vector<EnumC> vecEn) {
324 int numEl = vecEn.size();
326 string retType = "int[]";
327 string paramCls[] = { "int[]" };
328 // Need to define this container for integer version of enum
329 vector<int> paramInt(numEl);
330 for(int i = 0; i < numEl; i++) {
331 paramInt[i] = (int) vecEn[i]; // cast enum to integer
333 void* paramObj[] = { ¶mInt };
334 // if no return value just
335 // void* retObj2 = NULL;
336 // This is with return value:
337 vector<int> retEnumInt;
338 void* retObj = &retEnumInt;
339 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
340 int enumsize1 = retEnumInt.size();
341 vector<EnumC> retVal(enumsize1);
342 for (int i=0; i < enumsize1; i++) {
343 retVal[i] = (EnumC) retEnumInt[i];