X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=iotjava%2Fiotrmi%2FC%2B%2B%2Fsample%2FTestClass_Skeleton.hpp;h=96b37b45276782a977dd4db14e742f6104253a7c;hb=e9a65a3fa878d7451ceb4f5a2cb1bc9ee846e035;hp=95afe9b7e35b4c01614a7bfdbdd51c5c981e6c7a;hpb=b6effa890ccb61eb4b7a82f0dd7493cac354ef49;p=iot2.git

diff --git a/iotjava/iotrmi/C++/sample/TestClass_Skeleton.hpp b/iotjava/iotrmi/C++/sample/TestClass_Skeleton.hpp
index 95afe9b..96b37b4 100644
--- a/iotjava/iotrmi/C++/sample/TestClass_Skeleton.hpp
+++ b/iotjava/iotrmi/C++/sample/TestClass_Skeleton.hpp
@@ -1,41 +1,82 @@
+#ifndef _TESTCLASS_SKELETON_HPP__
+#define _TESTCLASS_SKELETON_HPP__
+
 #include <iostream>
+#include <exception>
+#include <set>
 #include "../IoTRMIObject.hpp"
-#include "TestClass.hpp"
+#include "../IoTRMICall.hpp"
+#include "CallBack_CBStub.hpp"
+#include "TestClassInterface.hpp"
 
 using namespace std;
 
-class TestClass_Skeleton {
+class TestClass_Skeleton : public TestClassInterface {
 	public:
 		TestClass_Skeleton(TestClassInterface* _tc, int _port);
 		~TestClass_Skeleton();
 
-		void	waitRequestInvokeMethod();
+		void			___waitRequestInvokeMethod();
+		void			setA(int _int);
+		void			setB(float _float);
+		void			setC(string _string);
+		string			sumArray(vector<string> newA);
+		//int64_t		sumArray(vector<int> newA);
+		int				setAndGetA(int newA);
+		int				setACAndGetA(string newC, int newA);
+		void			registerCallback(CallBackInterface* _cb);
+		void			registerCallback(vector<CallBackInterface*> _cb);
+		int				callBack();
+		vector<data>	handleStruct(vector<data> vecData);
+		vector<EnumC>	handleEnum(vector<EnumC> vecEn);
+		
+		void			___setA();
+		void			___setB();
+		void			___setC();
+		void			___sumArray();
+		//int64_t		____sumArray();
+		void			___setAndGetA();
+		void			___setACAndGetA();
+		void			___registerCallback();
+		void			____registerCallback();
+		// For array of callbacks
+		void			___regCB();
+		void			___callBack();
+		// For array of structs
+		int				___structSize();
+		void			___handleStruct(int structsize1);
+		int				___enumSize();
+		void			___handleEnum(int enumsize1);
 
 	private:		
-		TestClassInterface		*tc;
-		IoTRMIObject			*rmiObj;
+		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;
 		//CallBackInterface cbstub;
-
-		const static int size = 8;
-		string methodSignatures[size] = {
-
-			"voidsetA(int)",
-			"voidsetB(float)",
-			"voidsetC(string)",
-			"sumArray(string[])",
-			"intsetAndGetA(int)",
-			"intsetACAndGetA(string,int)",
-			"intcallBack()",
-			"voidregisterCallBack(CallBackInterface)"
-		};
 };
 
 
+// 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;
+
+
 TestClass_Skeleton::TestClass_Skeleton(TestClassInterface* _tc, int _port) {
 
 	bool _bResult = false;
 	tc = _tc;
-	rmiObj = new IoTRMIObject(_port, &_bResult, methodSignatures, size);
+	rmiObj = new IoTRMIObject(_port, &_bResult);
+	___waitRequestInvokeMethod();
 }
 
 
@@ -45,87 +86,367 @@ TestClass_Skeleton::~TestClass_Skeleton() {
 		delete rmiObj;
 		rmiObj = NULL;
 	}
+	if (rmiCall != NULL) {
+		delete rmiCall;
+		rmiCall = NULL;
+	}
+	for(CallBackInterface* cb : vecCBObj) {
+		delete cb;
+		cb = NULL;
+	}
 }
 
 
-void TestClass_Skeleton::waitRequestInvokeMethod() {
+void TestClass_Skeleton::setA(int _int) {
 
-	// Loop continuously waiting for incoming bytes
-	while (true) {
+	tc->setA(_int);
+}
 
-		rmiObj->getMethodBytes();
-		string methodSign = rmiObj->getSignature();
-		cout << "Method sign: " << methodSign << endl;
-		
-		if (methodSign.compare("voidsetA(int)") == 0) {
-			string paramCls[] = { "int" };
-			int numParam = 1;
-			int param1 = 0;
-			void* paramObj[] = { &param1 };
-			rmiObj->getMethodParams(paramCls, numParam, paramObj);
-			tc->setA(param1);
-		} else if (methodSign.compare("voidsetB(float)") == 0) {
-			string paramCls[] = { "float" };
-			int numParam = 1;
-			float param1 = 0.0;
-			void* paramObj[] = { &param1 };
-			rmiObj->getMethodParams(paramCls, numParam, paramObj);
-			tc->setB(param1);
-		} else if (methodSign.compare("voidsetC(string)") == 0) {
-			string paramCls[] = { "string" };
-			int numParam = 1;
-			string param1 = "";
-			void* paramObj[] = { &param1 };
-			rmiObj->getMethodParams(paramCls, numParam, paramObj);
-			tc->setC(param1);
-		} else if (methodSign.compare("sumArray(string[])") == 0) {
-			string paramCls[] = { "string[]" };
-			int numParam = 1;
-			vector<string> param1;
-			void* paramObj[] = { &param1 };
-			rmiObj->getMethodParams(paramCls, numParam, paramObj);
-			string retVal = tc->sumArray(param1);
-			void* retObj = &retVal;
-			rmiObj->sendReturnObj(retObj, "string");
-		} else if (methodSign.compare("intsetAndGetA(int)") == 0) {
-			string paramCls[] = { "int" };
-			int numParam = 1;
-			int param1 = 0;
-			void* paramObj[] = { &param1 };
-			rmiObj->getMethodParams(paramCls, numParam, paramObj);
-			int retVal = tc->setAndGetA(param1);
-			void* retObj = &retVal;
-			rmiObj->sendReturnObj(retObj, "int");
-		} else if (methodSign.compare("intsetACAndGetA(string,int)") == 0) {
-			string paramCls[] = { "string", "int" };
-			int numParam = 2;
-			string param1 = "";
-			int param2 = 0;
-			void* paramObj[] = { &param1, &param2 };
-			rmiObj->getMethodParams(paramCls, numParam, paramObj);
-			int retVal = tc->setACAndGetA(param1, param2);
-			void* retObj = &retVal;
-			rmiObj->sendReturnObj(retObj, "int");
-		/*} else if (methodSign.compare("voidregisterCallBack(CallBackInterface)") == 0) {
-			//
-		} else if (methodSign.compare("intcallBack()") == 0) {
-			//*/
-		} else {
-			string error = "Signature unreqcognized: " + string(methodSign);
-			throw error;
-		}
-	}
+
+void TestClass_Skeleton::___setA() {
+
+	string paramCls[] = { "int" };
+	int numParam = 1;
+	int param1 = 0;
+	void* paramObj[] = { &param1 };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	setA(param1);
+}
+
+
+void TestClass_Skeleton::setB(float _float) {
+
+	tc->setB(_float);
+}
+
+
+void TestClass_Skeleton::___setB() {
+
+	string paramCls[] = { "float" };
+	int numParam = 1;
+	float param1 = 0.0;
+	void* paramObj[] = { &param1 };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	setB(param1);
+}
+
+
+void TestClass_Skeleton::setC(string _string) {
+
+	tc->setC(_string);
+}
+
+
+void TestClass_Skeleton::___setC() {
+
+	string paramCls[] = { "string" };
+	int numParam = 1;
+	string param1 = "";
+	void* paramObj[] = { &param1 };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	setC(param1);
+}
+
+
+string TestClass_Skeleton::sumArray(vector<string> newA) {
+
+	return tc->sumArray(newA);
 }
 
 
-/*void TestClass_Stub::registerCallback(CallBackInterface _cb) {
+void TestClass_Skeleton::___sumArray() {
 
-	cb = _cb;
+	string paramCls[] = { "string[]" };
+	int numParam = 1;
+	vector<string> param1;
+	void* paramObj[] = { &param1 };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	string retVal = sumArray(param1);
+	void* retObj = &retVal;
+	rmiObj->sendReturnObj(retObj, "string");
 }
 
 
-int TestClass_Stub::callBack() {
+/*int64_t TestClass_Skeleton::sumArray(vector<int> newA) {
+
+	return tc->sumArray(newA);
+}*/
+
+
+/*int64_t TestClass_Skeleton::____sumArray() {
 
-	return cb.printInt();
 }*/
 
+
+int TestClass_Skeleton::setAndGetA(int newA) {
+
+	return tc->setAndGetA(newA);
+}
+
+
+void TestClass_Skeleton::___setAndGetA() {
+
+	string paramCls[] = { "int" };
+	int numParam = 1;
+	int param1 = 0;
+	void* paramObj[] = { &param1 };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	int retVal = setAndGetA(param1);
+	void* retObj = &retVal;
+	rmiObj->sendReturnObj(retObj, "int");
+}
+
+
+int TestClass_Skeleton::setACAndGetA(string newC, int newA) {
+
+	return tc->setACAndGetA(newC, newA);
+}
+
+
+void TestClass_Skeleton::___setACAndGetA() {
+
+	string paramCls[] = { "string", "int" };
+	int numParam = 2;
+	string param1 = "";
+	int param2 = 0;
+	void* paramObj[] = { &param1, &param2 };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	int retVal = setACAndGetA(param1, param2);
+	void* retObj = &retVal;
+	rmiObj->sendReturnObj(retObj, "int");
+}
+
+
+void TestClass_Skeleton::registerCallback(CallBackInterface* _cb) {
+
+	tc->registerCallback(_cb);
+}
+
+
+void TestClass_Skeleton::___registerCallback() {
+
+}
+
+
+void TestClass_Skeleton::registerCallback(vector<CallBackInterface*> _cb) {
+
+	tc->registerCallback(_cb);
+}
+
+
+void TestClass_Skeleton::___regCB() {
+
+	string paramCls[] = { "int", "string", "int" };
+	int numParam = 3;
+	int param1 = 0;
+	string param2 = "";
+	int param3 = 0;
+	void* paramObj[] = { &param1, &param2, &param3 };
+	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);
+}
+
+
+void TestClass_Skeleton::____registerCallback() {
+
+	string paramCls[] = { "int" };
+	int numParam = 1;
+	int numStubs = 0;
+	void* paramObj[] = { &numStubs };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	vector<CallBackInterface*> stub;
+	for (int objId = 0; objId < numStubs; objId++) {
+		CallBackInterface* cb = new CallBack_CBStub(rmiCall, objIdCnt);
+		stub.push_back(cb);
+		vecCBObj.push_back(cb);
+		objIdCnt++;
+	}
+	registerCallback(stub);
+}
+
+
+int TestClass_Skeleton::callBack() {
+
+	tc->callBack();
+}
+
+
+void TestClass_Skeleton::___callBack() {
+
+	int retVal = callBack();
+	void* retObj = &retVal;
+	rmiObj->sendReturnObj(retObj, "int");
+}
+
+
+vector<data> TestClass_Skeleton::handleStruct(vector<data> vecData) {
+
+	return tc->handleStruct(vecData);
+}
+
+
+int TestClass_Skeleton::___structSize() {
+
+	string paramCls[] = { "int" };
+	int numParam = 1;
+	int param1 = 0;
+	void* paramObj[] = { &param1 };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	return param1;
+}
+
+
+void TestClass_Skeleton::___handleStruct(int structsize1) {
+
+	string paramCls[3*structsize1];
+	void* paramObj[3*structsize1];
+	int numParam = 3*structsize1;
+	// define array of everything
+	string param1[structsize1];
+	float param2[structsize1];
+	int param3[structsize1];
+	int pos = 0;
+	for(int i=0; i < structsize1; i++) {
+		paramCls[pos] = "string";
+		paramObj[pos++] = &param1[i];
+		paramCls[pos] = "float";
+		paramObj[pos++] = &param2[i];
+		paramCls[pos] = "int";
+		paramObj[pos++] = &param3[i];
+	}
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	vector<data> dat(structsize1);
+	pos = 0;
+	for (int i=0; i < structsize1; i++) {
+		dat[i].name = param1[i];
+		dat[i].value = param2[i];
+		dat[i].year = param3[i];
+	}
+	// 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);
+}
+
+
+vector<EnumC> TestClass_Skeleton::handleEnum(vector<EnumC> vecEn) {
+
+	return tc->handleEnum(vecEn);
+}
+
+
+int TestClass_Skeleton::___enumSize() {
+
+	string paramCls[] = { "int" };
+	int numParam = 1;
+	int param1 = 0;
+	void* paramObj[] = { &param1 };
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	return param1;
+}
+
+
+void TestClass_Skeleton::___handleEnum() {
+
+	int numParam = 1;
+	string paramCls[] = { "int[]" };
+	vector<int> paramInt;
+	void* paramObj[] = { &paramInt };
+	// Receive the array of integers
+	rmiObj->getMethodParams(paramCls, numParam, paramObj);
+	int enumSize1 = paramInt.size();
+	vector<EnumC> en(enumSize1);
+	for (int i=0; i < enumSize1; i++) {
+		en[i] = (EnumC) paramInt[i];
+	}
+	//handleEnum(en);
+	// if void, just "handleEnum(en)"
+	// this is when we have return value vector<EnumC>
+	vector<EnumC> retEnum = handleEnum(en);
+	// Get length first
+	int enumSize2 = retEnum.size();
+	// Now send the array of integers
+	vector<int> retEnumInt(enumSize2);
+	for (int i=0; i < enumSize2; i++) {
+		retEnumInt[i] = (int) retEnum[i];
+	}
+	void* retObj = &retEnumInt;
+	rmiObj->sendReturnObj(retObj, "int[]");
+}
+
+
+void TestClass_Skeleton::___waitRequestInvokeMethod() {
+
+	int structsize1 = 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;
+			case 1: ___setB(); break;
+			case 2: ___setC(); break;
+			case 3: ___sumArray(); break;
+		/*  case 3: ____sumArray(); break;*/
+			case 4: ___setAndGetA(); break;
+			case 5: ___setACAndGetA(); break;
+			case 6: ___callBack(); break; 
+			case 7: ___registerCallback(); break;
+			case 8:	____registerCallback(); break;
+			case 9: ___regCB(); break;
+			// Handle struct
+			case 10: ___handleStruct(structsize1); break;
+			case 11: structsize1 = ___structSize(); break;
+			case 12: ___handleEnum(); break;
+			default:
+				string error = "Method Id not recognized!";
+				throw error;
+		}
+	}
+}
+
+
+#endif
+