1 #ifndef _TESTCLASS_STUB_HPP__
2 #define _TESTCLASS_STUB_HPP__
7 #include "../IoTRMICall.hpp"
8 #include "../IoTRMIObject.hpp"
9 #include "TestClassInterface.hpp"
10 #include "CallBack_CBSkeleton.hpp"
11 #include "StructC.hpp"
15 class TestClass_Stub : public TestClassInterface {
18 TestClass_Stub(int _port, const char* _address, int _rev, bool* _bResult, vector<int> _ports);
22 void setB(float _float);
23 void setC(string _string);
24 string sumArray(vector<string> newA);
25 //int64_t sumArray(vector<int> newA);
26 int setAndGetA(int newA);
27 int setACAndGetA(string newC, int newA);
28 void registerCallback(CallBackInterface* _cb);
29 void registerCallback(vector<CallBackInterface*>_cb);
31 vector<data> handleStruct(vector<data> vecData);
32 vector<EnumC> handleEnum(vector<EnumC> vecEn);
33 void ____init_CallBack(); // thread
34 void ____registerCallBack(); // tell the other side that we are ready
36 //exception_ptr teptr = nullptr;
42 //CallBackInterface cb;
46 const static int objectId = 0; // Default value is 0
48 // Specific for callbacks
50 vector<CallBackInterface*> vecCBObj;
52 // Callback permission
53 const static set<int> set0Allowed;
57 int TestClass_Stub::objIdCnt = 0;
60 const set<int> TestClass_Stub::set0Allowed { 0, 1 };
63 TestClass_Stub::TestClass_Stub() {
70 TestClass_Stub::TestClass_Stub(int _port, const char* _address, int _rev, bool* _bResult, vector<int> _ports) {
73 rmiCall = new IoTRMICall(_port, _address, _rev, _bResult);
78 thread th1 (&TestClass_Stub::____init_CallBack, this);
80 } catch(const exception&) {
81 cout << "Got here!" << endl;
85 thread th1 (&TestClass_Stub::____init_CallBack, this);
88 ____registerCallBack();
92 TestClass_Stub::~TestClass_Stub() {
94 if (rmiCall != NULL) {
102 // Special for callbacks!!!
103 for(CallBackInterface* cb : vecCBObj) {
110 // Callback handler thread
111 void TestClass_Stub::____init_CallBack() {
113 bool bResult = false;
114 rmiObj = new IoTRMIObject(ports[0], &bResult);
116 char* method = rmiObj->getMethodBytes();
117 int methodId = IoTRMIObject::getMethodId(method);
119 // Complain if the method is not allowed
120 if (set0Allowed.find(methodId) == set0Allowed.end()) {
121 cerr << "TestClass_Skeleton: This object is not allowed to access method " << methodId << endl;
124 //teptr = current_exception();
126 int objId = IoTRMIObject::getObjectId(method);
127 if (objId < vecCBObj.size()) { // Check if still within range
128 CallBack_CBSkeleton* skel =
129 dynamic_cast<CallBack_CBSkeleton*> (vecCBObj.at(objId));
130 skel->invokeMethod(rmiObj);
132 string error = "TestClass_Stub: Illegal object Id: " + to_string(objId);
139 // Notify that callback thread is ready
140 void TestClass_Stub::____registerCallBack() {
144 string retType = "void";
145 string paramCls[] = { "int", "string", "int" };
147 void* paramObj[] = { &ports[0], &address, &rev };
149 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
153 void TestClass_Stub::setA(int _int) {
157 string retType = "void";
158 string paramCls[] = { "int" };
159 void* paramObj[] = { &_int };
161 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
165 void TestClass_Stub::setB(float _float) {
169 string retType = "void";
170 string paramCls[] = { "float" };
171 void* paramObj[] = { &_float };
173 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
177 void TestClass_Stub::setC(string _string) {
181 string retType = "void";
182 string paramCls[] = { "string" };
183 void* paramObj[] = { &_string };
185 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
189 string TestClass_Stub::sumArray(vector<string> newA) {
193 string retType = "string";
194 string paramCls[] = { "string[]" };
195 void* paramObj[] = { &newA };
197 void* retObj = &retVal;
198 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
203 /*int64_t TestClass_Stub::sumArray(vector<int> newA) {
206 string sign = "sumArray(int[])";
207 string retType = "long";
208 string paramCls[] = { "int[]" };
209 void* paramObj[] = { &newA };
211 void* retObj = &retVal;
212 rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
218 int TestClass_Stub::setAndGetA(int newA) {
222 string retType = "int";
223 string paramCls[] = { "int" };
224 void* paramObj[] = { &newA };
226 void* retObj = &retVal;
227 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
232 int TestClass_Stub::setACAndGetA(string newC, int newA) {
236 string retType = "int";
237 string paramCls[] = { "string", "int" };
238 void* paramObj[] = { &newC, &newA };
240 void* retObj = &retVal;
241 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
246 void TestClass_Stub::registerCallback(CallBackInterface* _cb) {
248 //Should implement the callback here
252 void TestClass_Stub::registerCallback(vector<CallBackInterface*> _cb) {
254 for (CallBackInterface* cb: _cb) {
255 CallBack_CBSkeleton* skel = new CallBack_CBSkeleton(cb, objIdCnt++);
256 vecCBObj.push_back(skel);
261 string retType = "void";
262 string paramCls[] = { "int" };
263 int param1 = _cb.size();
264 void* paramObj[] = { ¶m1 };
266 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
270 int TestClass_Stub::callBack() {
274 string retType = "int";
275 string paramCls[] = { };
276 void* paramObj[] = { };
278 void* retObj = &retVal;
279 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
284 vector<data> TestClass_Stub::handleStruct(vector<data> vecData) {
288 string retType = "void";
289 string paramCls[] = { "int" };
290 int structsize = vecData.size();
291 void* paramObj[] = { &structsize };
293 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
295 int numParam2 = 3*vecData.size();
297 string retType2 = "int";
298 string paramCls2[numParam2];
299 void* paramObj2[numParam2];
301 for(int i = 0; i < vecData.size(); i++) {
302 paramCls2[pos] = "string";
303 paramObj2[pos] = &vecData[i].name; pos++;
304 paramCls2[pos] = "float";
305 paramObj2[pos] = &vecData[i].value; pos++;
306 paramCls2[pos] = "int";
307 paramObj2[pos] = &vecData[i].year; pos++;
309 // RETURN STRUCT OBJECT
310 // Get length of struct array
312 void* retObj2 = { &structsize1 };
313 // IF we don't have returned struct objects, then it's just "void* retObj2 = NULL;"
314 rmiCall->remoteCall(objectId, methodId2, retType2, paramCls2, paramObj2, numParam2, retObj2);
315 cout << "Struct length: " << structsize1 << endl;
317 // Get the returned objects
318 string retCls[3*structsize1];
319 void* retObj3[3*structsize1];
320 int numRet = 3*structsize1;
321 // define array of everything
322 string param1[structsize1];
323 float param2[structsize1];
324 int param3[structsize1];
326 for(int i=0; i < structsize1; i++) {
327 retCls[pos] = "string";
328 retObj3[pos++] = ¶m1[i];
329 retCls[pos] = "float";
330 retObj3[pos++] = ¶m2[i];
332 retObj3[pos++] = ¶m3[i];
334 rmiCall->getStructObjects(retCls, numRet, retObj3);
335 vector<data> dat(structsize1);
337 for (int i=0; i < structsize1; i++) {
338 dat[i].name = param1[i];
339 dat[i].value = param2[i];
340 dat[i].year = param3[i];
347 vector<EnumC> TestClass_Stub::handleEnum(vector<EnumC> vecEn) {
350 int numEl = vecEn.size();
352 string retType = "int[]";
353 string paramCls[] = { "int[]" };
354 // Need to define this container for integer version of enum
355 vector<int> paramInt(numEl);
356 for(int i = 0; i < numEl; i++) {
357 paramInt[i] = (int) vecEn[i]; // cast enum to integer
359 void* paramObj[] = { ¶mInt };
360 // if no return value just
361 // void* retObj2 = NULL;
362 // This is with return value:
363 vector<int> retEnumInt;
364 void* retObj = &retEnumInt;
365 rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);
366 int enumsize1 = retEnumInt.size();
367 vector<EnumC> retVal(enumsize1);
368 for (int i=0; i < enumsize1; i++) {
369 retVal[i] = (EnumC) retEnumInt[i];