Preparing C++ stubs and skeletons for circular compilation (it couldn't compile earlier)

[iot2.git] / iotjava / iotrmi / C++ / basics / TestClassInterface_Skeleton.cpp

diff --git a/iotjava/iotrmi/C++/basics/TestClassInterface_Skeleton.cpp b/iotjava/iotrmi/C++/basics/TestClassInterface_Skeleton.cpp
index 60ad5fdd2883daa723602f24abc9261a44c9b7d5..0ad75869f1436ca13846c5badae0fca7c810ab0b 100644 (file)
--- a/iotjava/iotrmi/C++/basics/TestClassInterface_Skeleton.cpp
+++ b/iotjava/iotrmi/C++/basics/TestClassInterface_Skeleton.cpp
@@ -3,12 +3,133 @@
 #include "TestClassInterface_Skeleton.hpp"
 #include "TestClass.hpp"
 
+#include "CallBackInterfaceWithCallBack_Stub.cpp"
+
 using namespace std;
 
+TestClassInterface_Skeleton::TestClassInterface_Skeleton(TestClassInterface *_mainObj, string _callbackAddress, int _port) {
+       bool _bResult = false;
+       mainObj = _mainObj;
+       callbackAddress = _callbackAddress;
+       rmiObj = new IoTRMIObject(_port, &_bResult);
+       set0Allowed.insert(-9999);
+       ___waitRequestInvokeMethod();
+}
+
+TestClassInterface_Skeleton::TestClassInterface_Skeleton(TestClassInterface *_mainObj, int _objIdCnt, string _callbackAddress) {
+       bool _bResult = false;
+       mainObj = _mainObj;
+       objIdCnt = _objIdCnt;
+       callbackAddress = _callbackAddress;
+       set0Allowed.insert(-9999);
+       ___waitRequestInvokeMethod();
+}
+
+TestClassInterface_Skeleton::~TestClassInterface_Skeleton() {
+       if (rmiObj != NULL) {
+               delete rmiObj;
+               rmiObj = NULL;
+       }
+       if (rmiCall != NULL) {
+               delete rmiCall;
+               rmiCall = NULL;
+       }
+       for(CallBackInterfaceWithCallBack* cb : vecCallbackObj) {
+               delete cb;
+               cb = NULL;
+       }
+}
+
+short TestClassInterface_Skeleton::getShort(short in) {
+       return mainObj->getShort(in);
+}
+
+void TestClassInterface_Skeleton::registerCallback(CallBackInterfaceWithCallBack* _cb) {
+       mainObj->registerCallback(_cb);
+}
+
+void TestClassInterface_Skeleton::___regCB() {
+       int numParam = 3;
+       vector<int> param1;
+       string param2 = "";
+       int param3 = 0;
+       string paramCls[] = { "int*", "String", "int" };
+       void* paramObj[] = { &param1, &param2, &param3 };
+       rmiObj->getMethodParams(paramCls, numParam, paramObj);
+       bool bResult = false;
+       rmiCall = new IoTRMICall(param1[1], param2.c_str(), param3, &bResult);
+}
+
+int TestClassInterface_Skeleton::callBack() {
+       return mainObj->callBack();
+}
+
+void TestClassInterface_Skeleton::___getShort() {
+       string paramCls[] = { "short" };
+       int numParam = 1;
+       short in;
+       void* paramObj[] = { &in };
+       rmiObj->getMethodParams(paramCls, numParam, paramObj);
+       short retVal = getShort(in);
+       void* retObj = &retVal;
+       rmiObj->sendReturnObj(retObj, "short");
+}
+
+void TestClassInterface_Skeleton::___registerCallback() {
+       string paramCls[] = { "int" };
+       int numParam = 1;
+       int numStubs0 = 0;
+       void* paramObj[] = { &numStubs0 };
+       rmiObj->getMethodParams(paramCls, numParam, paramObj);
+       //CallBackInterfaceWithCallBack* stub0 = new CallBackInterfaceWithCallBack_CallbackStub(rmiCall, callbackAddress, objIdCnt, ports);
+       CallBackInterfaceWithCallBack* stub0 = new CallBackInterfaceWithCallBack_Stub(rmiCall, callbackAddress, objIdCnt, ports);
+       vecCallbackObj.push_back(stub0);
+       objIdCnt++;
+       registerCallback(stub0);
+}
+
+void TestClassInterface_Skeleton::___callBack() {
+       string paramCls[] = {  };
+       int numParam = 0;
+       void* paramObj[] = {  };
+       rmiObj->getMethodParams(paramCls, numParam, paramObj);
+       int retVal = callBack();
+       void* retObj = &retVal;
+       rmiObj->sendReturnObj(retObj, "int");
+}
+
+void TestClassInterface_Skeleton::___waitRequestInvokeMethod() {
+       while (true) {
+               rmiObj->getMethodBytes();
+               int _objectId = rmiObj->getObjectId();
+               int methodId = rmiObj->getMethodId();
+               if (_objectId == object0Id) {
+                       if (set0Allowed.find(methodId) == set0Allowed.end()) {
+                               cerr << "Object with object Id: " << _objectId << "  is not allowed to access method: " << methodId << endl;
+                               return;
+                       }
+               }
+               else {
+                       cerr << "Object Id: " << _objectId << " not recognized!" << endl;
+                       return;
+               }
+               switch (methodId) {
+                       case 0: ___getShort(); break;
+                       case 1: ___registerCallback(); break;
+                       case 2: ___callBack(); break;
+                       case -9999: ___regCB(); break;
+                       default: 
+                       cerr << "Method Id " << methodId << " not recognized!" << endl;
+                       throw exception();
+               }
+       }
+}
+
+
 int main(int argc, char *argv[])
 {
        // First argument is port number
-       int port = atoi(argv[1]);
+       /*int port = atoi(argv[1]);
        int argv2 = atoi(argv[2]);
        float argv3 = atof(argv[3]);
        string argv4 = string(argv[4]);
@@ -16,10 +137,12 @@ int main(int argc, char *argv[])
        cout << port << endl;
        cout << argv2 << endl;
        cout << argv3 << endl;
-       cout << argv4 << endl;
+       cout << argv4 << endl;*/
 
+       int port = 5010;
        //TestClassInterface *tc = new TestClass(argv2, argv3, argv4);
-       //TestClassInterface_Skeleton *tcSkel = new TestClassInterface_Skeleton(tc, port);
+       TestClassInterface *tc = new TestClass(123, 2.345, "test");
+       TestClassInterface_Skeleton *tcSkel = new TestClassInterface_Skeleton(tc, "localhost", port);
 
        //delete tc;
        //delete tcSkel;