Final stretch to have working rpc example

5 files changed, 76 insertions, 18 deletions

diff --git a/modules/codec/c++/schema.hpp b/modules/codec/c++/schema.hpp
index c0fb66f..65d7158 100644
--- a/modules/codec/c++/schema.hpp
+++ b/modules/codec/c++/schema.hpp
@@ -201,6 +201,14 @@ struct Interface<Member<Function<Requests, Responses>,Names>...> {
 // NOLINTEND
 } // namespace schema
 
+template<uint64_t I, typename Structural>
+struct schema_type_at_index;
+
+template<uint64_t I, typename... Members>
+struct schema_type_at_index<I, schema::Interface<Members...>> {
+	using Type = typename parameter_pack_type<I, Members...>::type;
+};
+
 template<typename T, typename Schema> 
 struct schema_has_member{
 	static_assert(
diff --git a/modules/remote/c++/remote_loopback.hpp b/modules/remote/c++/remote_loopback.hpp
index 0e9eb2d..8037b81 100644
--- a/modules/remote/c++/remote_loopback.hpp
+++ b/modules/remote/c++/remote_loopback.hpp
@@ -74,13 +74,29 @@ public:
 	{}
 
 	template<string_literal Lit>
-	error_or<
-		id<
-			typename schema_member_type<Lit, Iface>::type::ResponseT
-		>
-	> call(id<typename schema_member_type<Lit, Iface>::type::RequestT> id_param){
+	error_or<void> call(id<typename schema_member_type<Lit, Iface>::type::RequestT> id_param, id<typename schema_member_type<Lit,Iface>::type::ResponseT> id_resp){
+		using Req = typename schema_member_type<Lit,Iface>::type::RequestT;
+		auto req_dat_ptr = std::get<ptr<data_server<Req,Encode,rmt::Loopback>>>(dat_srvs_);
+		auto eo_req_param = req_dat_ptr().find(id_param);
+		if(eo_req_param.is_error()){
+			return std::move(eo_req_param.get_error());
+		}
+		auto& req_param = eo_req_param.get_value();
+
+		auto eo_answer = iface_.template call<Lit>(req_param());
+		if(eo_answer.is_error()){
+			return std::move(eo_answer.get_error());
+		}
+		auto& answer = eo_answer.get_value();
+
+		using Resp = typename schema_member_type<Lit,Iface>::type::ResponseT;
+		auto resp_dat_ptr = std::get<ptr<data_server<Resp,Encode,rmt::Loopback>>>(dat_srvs_);
+		auto eo_send = resp_dat_ptr().send(std::move(answer), id_resp);
+		if(eo_send.is_error()){
+			return std::move(eo_send.get_error());
+		}
 
-		return make_error<err::not_implemented>();
+		return make_void();
 	}
 };
 
diff --git a/modules/remote/c++/remote_loopback_base.hpp b/modules/remote/c++/remote_loopback_base.hpp
index 7a567b2..d91df37 100644
--- a/modules/remote/c++/remote_loopback_base.hpp
+++ b/modules/remote/c++/remote_loopback_base.hpp
@@ -53,16 +53,38 @@ private:
 	std::map<key_t, ptr<i_rpc_server<rmt::Loopback>>> registered_rpc_servers_;
 
 	template<typename Iface, typename Encoding, uint64_t I>
-	error_or<void> find_data_servers_ele(typename rpc_server<Iface,Encoding,rmt::Loopback>::DataServers& ret_val){
-		if
+	error_or<void> find_data_servers_ele(typename rpc_server<Iface,Encoding,rmt::Loopback>::DataServers& ret_val, ref<remote_address<rmt::Loopback>> addr){
+		if constexpr ( I < Iface::size ){
+			using DataTypeGroup = typename rpc_server<Iface,Encoding,rmt::Loopback>::TypeGroup;
+			using Schema = typename tmpl_group_pack_type<I,DataTypeGroup>::type;
+
+			constexpr auto class_id = data_server<Schema, Encoding, rmt::Loopback>::class_id;
+			key_t key;
+			key.data = std::array<uint64_t,3>{addr().get_address_id().get(), class_id.first, class_id.second};
+
+			auto find = registered_data_servers_.find(key);
+			if(find == registered_data_servers_.end()){
+				return make_error<err::not_found>("Server not found");
+			}
+			auto eo_dat_srv = find->second().template cast_to<data_server<Schema, Encoding, rmt::Loopback>>();
+			if(eo_dat_srv.is_error()){
+				auto& err = eo_dat_srv.get_error();
+				return std::move(err);
+			}
+			auto dat_srv = eo_dat_srv.get_value();
+			std::get<I>(ret_val) = dat_srv;
+
+			return find_data_servers_ele<Iface,Encoding,I+1u>(ret_val, addr);
+		}
+		return make_void();
 	}
 
 	template<typename Iface, typename Encoding>
-	error_or<typename rpc_server<Iface, Encoding, rmt::Loopback>::DataServers> find_data_servers(){
+	error_or<typename rpc_server<Iface, Encoding, rmt::Loopback>::DataServers> find_data_servers(ref<remote_address<rmt::Loopback>> addr){
 		typename rpc_server<Iface,Encoding,rmt::Loopback>::DataServers ret_val;
 
 		{
-			auto eov = find_data_servers_ele<Iface,Encoding,0u>(ret_val);
+			auto eov = find_data_servers_ele<Iface,Encoding,0u>(ret_val,addr);
 			if(eov.is_error()){
 				return std::move(eov.get_error());
 			}
@@ -90,7 +112,7 @@ public:
 	template<typename Iface, typename Encode>
 	error_or<own<rpc_server<Iface, Encode, rmt::Loopback>>> rpc_listen(remote_address<rmt::Loopback>& addr, typename rpc_server<Iface,Encode,rmt::Loopback>::InterfaceT iface){
 
-		auto eo_dat_srvs = find_data_servers<Iface,Encode>();
+		auto eo_dat_srvs = find_data_servers<Iface,Encode>(addr);
 		if(eo_dat_srvs.is_error()){
 			return std::move(eo_dat_srvs.get_error());
 		}
diff --git a/modules/remote/c++/transfer_loopback.hpp b/modules/remote/c++/transfer_loopback.hpp
index afc9d17..e45abb3 100644
--- a/modules/remote/c++/transfer_loopback.hpp
+++ b/modules/remote/c++/transfer_loopback.hpp
@@ -43,9 +43,21 @@ public:
 		return class_id;
 	}
 	
-	error_or<void> send(const data<Schema, Encoding>& dat, id<Schema> store_id){
+	error_or<void> send(ref<data<Schema, Encoding>> dat, id<Schema> store_id){
 		try {
-			auto insert_res = values_.emplace(std::make_pair(store_id.get_value(), dat));
+			auto insert_res = values_.emplace(std::make_pair(store_id.get_value(), dat()));
+			if(!insert_res.second){
+				return make_error<err::already_exists>();
+			}
+		}catch(std::exception& ){
+			return make_error<err::out_of_memory>();
+		}
+		return void_t{};
+	}
+	
+	error_or<void> send(data<Schema, Encoding> dat, id<Schema> store_id){
+		try {
+			auto insert_res = values_.emplace(std::make_pair(store_id.get_value(), std::move(dat)));
 			if(!insert_res.second){
 				return make_error<err::already_exists>();
 			}
diff --git a/modules/remote/tests/remote_loopback.cpp b/modules/remote/tests/remote_loopback.cpp
index e1f3898..bd24384 100644
--- a/modules/remote/tests/remote_loopback.cpp
+++ b/modules/remote/tests/remote_loopback.cpp
@@ -53,12 +53,12 @@ SAW_TEST("Remote Loopback RPC"){
 		auto eo_send = u32_srv->send(inp, id32);
 		SAW_EXPECT(eo_send.is_value(), "Failed send.");
 	}
-	auto eo_called = rpc_srv->template call<"foo">(id32);
-	SAW_EXPECT(eo_called.is_value(), "Failed call.");
-	auto& called = eo_called.get_value();
-
 	{
-		auto eo_recv = i64_srv->receive(called);
+		auto eo_called = rpc_srv->template call<"foo">(id32, id64);
+		SAW_EXPECT(eo_called.is_value(), (std::string{"Failed call: "} + std::string{eo_called.get_error().get_category()} ));
+	}
+	{
+		auto eo_recv = i64_srv->receive(id64);
 		SAW_EXPECT(eo_recv.is_value(), "Failed receive.");
 		auto& recv = eo_recv.get_value();
 		SAW_EXPECT((recv.get() == 42), (std::string{"Wrong value received: "} + std::to_string(recv.get())));