X-Git-Url: http://plrg.eecs.uci.edu/git/?p=iot2.git;a=blobdiff_plain;f=iotjava%2Fiotrmi%2FC%2B%2B%2Fsample%2FTestClass_Stub.hpp;h=39ede876717f7602007f60a292072d3bbbc79087;hp=1749a59f7c5dfb37087818ecc39e7ec80b65d1fe;hb=b4f15c87c5200b78a292243cbfb271c48d9d6c5e;hpb=5b5142548aabbcea7859766d4a58dfa979ce4928

diff --git a/iotjava/iotrmi/C++/sample/TestClass_Stub.hpp b/iotjava/iotrmi/C++/sample/TestClass_Stub.hpp
index 1749a59..39ede87 100644
--- a/iotjava/iotrmi/C++/sample/TestClass_Stub.hpp
+++ b/iotjava/iotrmi/C++/sample/TestClass_Stub.hpp
@@ -1,7 +1,13 @@
+#ifndef _TESTCLASS_STUB_HPP__
+#define _TESTCLASS_STUB_HPP__
+
 #include <iostream>
+#include <thread>
 #include "../IoTRMICall.hpp"
 #include "../IoTRMIObject.hpp"
 #include "TestClassInterface.hpp"
+#include "CallBack_CBSkeleton.hpp"
+#include "StructC.hpp"
 
 using namespace std;
 
@@ -21,9 +27,11 @@ class TestClass_Stub : public TestClassInterface {
 		void				registerCallback(CallBackInterface* _cb);
 		void				registerCallback(vector<CallBackInterface*>_cb);
 		int					callBack();
-		void				init_CallBack();
+		void				handleStruct(vector<data> vecData);
+		void				____init_CallBack();	// thread
+		void				____registerCallBack();	// tell the other side that we are ready
 
-		const static int 	size = 9;
+		const static int 	size = 12;
 		const static string methodSignatures[size];
 
 	private:		
@@ -35,12 +43,16 @@ class TestClass_Stub : public TestClassInterface {
 		IoTRMIObject				*rmiObj;
 		string						address;
 		vector<int>					ports;
-		map<int,CallBackInterface*> mapCBObj;
+		vector<CallBackInterface*> 	vecCBObj;
 
 		int 		objectId = 0;	// Default value is 0
+		static int	objIdCnt;
 };
 
 
+int TestClass_Stub::objIdCnt = 0;
+
+
 const string TestClass_Stub::methodSignatures[TestClass_Stub::size] = {
 	"voidsetA(int)",
 	"voidsetB(float)",
@@ -51,7 +63,10 @@ const string TestClass_Stub::methodSignatures[TestClass_Stub::size] = {
 	"intsetACAndGetA(string,int)",
 	"intcallBack()",
 	"voidregisterCallBack(CallBackInterface)",
-	"voidregisterCallBack(CallBackInterface[])"
+	"voidregisterCallBack(CallBackInterface[])",
+	"registercallback",
+	"handleStruct(StructJ[])",
+	"structsize"
 };
 
 
@@ -67,6 +82,13 @@ TestClass_Stub::TestClass_Stub(int _port, const char* _address, int _rev, bool*
 	address = _address;
 	rmiCall = new IoTRMICall(_port, _address, _rev, _bResult, methodSignatures, size);
 	ports = _ports;
+	// Start thread
+	cout << "Reached here 1!" << endl;
+//	thread th1 (&TestClass_Stub::____init_CallBack, this);
+//	th1.detach();
+	//th1.join();
+	cout << "Reached here 2!" << endl;
+//	____registerCallBack();
 }
 
 
@@ -76,21 +98,66 @@ TestClass_Stub::~TestClass_Stub() {
 		delete rmiCall;
 		rmiCall = NULL;
 	}
+	if (rmiObj != NULL) {
+		delete rmiObj;
+		rmiObj = NULL;
+	}
+	for(CallBackInterface* cb : vecCBObj) {
+		delete cb;
+		cb = NULL;
+	}
 }
 
 
 // Callback handler thread
-void TestClass_Stub::init_CallBack() {
+void TestClass_Stub::____init_CallBack() {
 
 	bool bResult = false;
+	cout << "Reach here init!" << endl;
 	rmiObj = new IoTRMIObject(ports[0], &bResult, CallBack_CBSkeleton::methodSignatures, CallBack_CBSkeleton::size);
+	cout << "Reach here init 2!" << endl;
 	while (true) {
 		char* method = rmiObj->getMethodBytes();
-		
+		cout << "Get method bytes here: " << endl;
+		IoTRMIUtil::printBytes(method, rmiObj->getMethodBytesLen(), false);
+		int objId = IoTRMIObject::getObjectId(method);
+		if (objId < vecCBObj.size()) {	// Check if still within range
+			CallBack_CBSkeleton* skel = 
+				dynamic_cast<CallBack_CBSkeleton*> (vecCBObj.at(objId));
+			cout << "Dynamic cast done!" << endl;
+			//rmiObj->setMethodBytes(method);
+			string type = "";
+			cout << "About to execute invoke method!" << endl;
+			void* retObj = skel->invokeMethod(rmiObj, &type);
+			cout << "Executed invoke method!" << endl;
+			if (type != "void") {
+				rmiObj->sendReturnObj(retObj, type);
+				cout << "Sent return object!" << endl;
+			}
+		} else {
+			string error = "TestClass_Stub: Illegal object Id: " + to_string(objId);
+			throw error;
+		}
 	}
 }
 
 
+// Notify that callback thread is ready
+void TestClass_Stub::____registerCallBack() {
+
+	int numParam = 3;
+	string sign = "registercallback";
+	string retType = "void";
+	string paramCls[] = { "int", "string", "int" };
+	int rev = 0;
+	void* paramObj[] = { &ports[0], &address, &rev };
+	void* retObj = NULL;
+	cout << "Get here! 1" << endl;
+	rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+	cout << "Get here! 2" << endl;
+}
+
+
 void TestClass_Stub::setA(int _int) {
 
 	int numParam = 1;
@@ -192,7 +259,19 @@ void TestClass_Stub::registerCallback(CallBackInterface* _cb) {
 
 void TestClass_Stub::registerCallback(vector<CallBackInterface*> _cb) {
 
-	//Should implement the callback here for multiple callback objects
+	for (CallBackInterface* cb: _cb) {
+		CallBack_CBSkeleton* skel = new CallBack_CBSkeleton(cb, objIdCnt++);
+		vecCBObj.push_back(skel);
+	}
+
+	int numParam = 1;
+	string sign = "voidregisterCallBack(CallBackInterface[])";
+	string retType = "void";
+	string paramCls[] = { "int" };
+	int param1 = _cb.size();
+	void* paramObj[] = { &param1 };
+	void* retObj = NULL;
+	rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
 }
 
 
@@ -209,3 +288,36 @@ int TestClass_Stub::callBack() {
 	return retVal;
 }
 
+
+void TestClass_Stub::handleStruct(vector<data> vecData) {
+
+	int numParam = 1;
+	string sign = "structsize";
+	string retType = "void";
+	string paramCls[] = { "int" };
+	int structsize = vecData.size();
+	void* paramObj[] = { &structsize };
+	void* retObj = NULL;
+	rmiCall->remoteCall(objectId, sign, retType, paramCls, paramObj, numParam, retObj);
+
+	int numParam2 = 3*vecData.size();
+	string sign2 = "handleStruct(StructJ[])";
+	string retType2 = "void";
+	string paramCls2[numParam2];
+	void* paramObj2[numParam2];
+	int pos = 0;
+	for(int i = 0; i < vecData.size(); i++) {
+		paramCls2[pos] = "string";
+		paramObj2[pos] = &vecData[i].name; pos++;
+		paramCls2[pos] = "float";
+		paramObj2[pos] = &vecData[i].value; pos++;
+		paramCls2[pos] = "int";
+		paramObj2[pos] = &vecData[i].year; pos++;
+	}
+	void* retObj2 = NULL;
+	cout << "In handle struct 3!" << endl;
+	rmiCall->remoteCall(objectId, sign2, retType2, paramCls2, paramObj2, numParam2, retObj2);
+}
+
+
+#endif