Removing printing statements from C++ RMI library - this will cause SO files to get...

[iot2.git] / iotjava / iotrmi / C++ / sample / TestClass_Skeleton.hpp

diff --git a/iotjava/iotrmi/C++/sample/TestClass_Skeleton.hpp b/iotjava/iotrmi/C++/sample/TestClass_Skeleton.hpp
index 6f715fcb528ccea853bb1e27271f62390dbf21e1..96b37b45276782a977dd4db14e742f6104253a7c 100644 (file)
--- a/iotjava/iotrmi/C++/sample/TestClass_Skeleton.hpp
+++ b/iotjava/iotrmi/C++/sample/TestClass_Skeleton.hpp
@@ -2,6 +2,8 @@
 #define _TESTCLASS_SKELETON_HPP__
 
 #include <iostream>
+#include <exception>
+#include <set>
 #include "../IoTRMIObject.hpp"
 #include "../IoTRMICall.hpp"
 #include "CallBack_CBStub.hpp"
@@ -25,7 +27,7 @@ class TestClass_Skeleton : public TestClassInterface {
                void                    registerCallback(CallBackInterface* _cb);
                void                    registerCallback(vector<CallBackInterface*> _cb);
                int                             callBack();
-               void                    handleStruct(vector<data> vecData);
+               vector<data>    handleStruct(vector<data> vecData);
                vector<EnumC>   handleEnum(vector<EnumC> vecEn);
                
                void                    ___setA();
@@ -49,6 +51,11 @@ class TestClass_Skeleton : public TestClassInterface {
        private:                
                TestClassInterface                      *tc;
                IoTRMIObject                            *rmiObj;
+               // Permission setup
+               const static int                        object0Id = 0;
+               //const static int                      object0Permission[];
+               const static set<int>           set0Allowed;
+               
                IoTRMICall                                      *rmiCall;
                static int                                      objIdCnt;
                vector<CallBackInterface*>      vecCBObj;
@@ -56,6 +63,11 @@ class TestClass_Skeleton : public TestClassInterface {
 };
 
 
+// Permission setup
+//const int TestClass_Skeleton::object0Id = 0;
+//const int TestClass_Skeleton::object0Permission[] = {0, 1, 2, 3, 4, 5};
+const set<int> TestClass_Skeleton::set0Allowed {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+
 int TestClass_Skeleton::objIdCnt = 0;
 
 
@@ -233,6 +245,9 @@ void TestClass_Skeleton::___regCB() {
        rmiObj->getMethodParams(paramCls, numParam, paramObj);
        // Instantiate IoTRMICall object
        bool bResult = false;
+       cout << "Port: " << param1 << endl;
+       cout << "Address: " << param2 << endl;
+
        rmiCall = new IoTRMICall(param1, param2.c_str(), param3, &bResult);
 }
 
@@ -269,9 +284,9 @@ void TestClass_Skeleton::___callBack() {
 }
 
 
-void TestClass_Skeleton::handleStruct(vector<data> vecData) {
+vector<data> TestClass_Skeleton::handleStruct(vector<data> vecData) {
 
-       tc->handleStruct(vecData);
+       return tc->handleStruct(vecData);
 }
 
 
@@ -312,7 +327,27 @@ void TestClass_Skeleton::___handleStruct(int structsize1) {
                dat[i].value = param2[i];
                dat[i].year = param3[i];
        }
-       handleStruct(dat);
+       // This is a return value of type vector of struct
+       // If no return value, then just "handleStruct(dat)"
+       vector<data> retData = handleStruct(dat);
+       // Send the length first!
+       int retLength = retData.size();
+       void* retObj = &retLength;
+       rmiObj->sendReturnObj(retObj, "int");
+       // Send the actual bytes - struct of 3 members
+       int numRetObj = 3*retLength;
+       string retCls[numRetObj];
+       void* retObj2[numRetObj];
+       pos = 0;
+       for(int i = 0; i < retLength; i++) {
+               retCls[pos] = "string";
+               retObj2[pos] = &retData[i].name; pos++;
+               retCls[pos] = "float";
+               retObj2[pos] = &retData[i].value; pos++;
+               retCls[pos] = "int";
+               retObj2[pos] = &retData[i].year; pos++;
+       }
+       rmiObj->sendReturnObj(retObj2, retCls, numRetObj);
 }
 
 
@@ -333,7 +368,7 @@ int TestClass_Skeleton::___enumSize() {
 }
 
 
-void TestClass_Skeleton::___handleEnum(int enumsize1) {
+void TestClass_Skeleton::___handleEnum() {
 
        int numParam = 1;
        string paramCls[] = { "int[]" };
@@ -365,12 +400,29 @@ void TestClass_Skeleton::___handleEnum(int enumsize1) {
 void TestClass_Skeleton::___waitRequestInvokeMethod() {
 
        int structsize1 = 0;
-       int enumsize1 = 0;
+
        // Loop continuously waiting for incoming bytes
        while (true) {
 
                rmiObj->getMethodBytes();
+               int _objectId = rmiObj->getObjectId();
                int methodId = rmiObj->getMethodId();
+               if (_objectId == object0Id) {
+               // Multiplex based on object Id
+                       // Complain if the method is not allowed
+                       if (set0Allowed.find(methodId) == set0Allowed.end()) {
+                               cerr << "TestClass_Skeleton: This object is not allowed to access method " << methodId << endl;
+                               //exit(1);
+                               throw exception();
+                       }
+               // If we have more than 1 object Id...
+               //else if (_objectId == object1Id) {
+
+               } else {
+                       cerr << "TestClass_Skeleton: Unrecognizable object Id: " << _objectId << endl;
+                       throw exception();
+                       //exit(1);
+               }
                
                switch (methodId) {
                        case 0: ___setA(); break;
@@ -387,7 +439,7 @@ void TestClass_Skeleton::___waitRequestInvokeMethod() {
                        // Handle struct
                        case 10: ___handleStruct(structsize1); break;
                        case 11: structsize1 = ___structSize(); break;
-                       case 12: ___handleEnum(enumsize1); break;
+                       case 12: ___handleEnum(); break;
                        default:
                                string error = "Method Id not recognized!";
                                throw error;