Use (more) shared pointers

6 files changed, 56 insertions, 37 deletions

diff --git a/implementation/routing/include/routing_manager.hpp b/implementation/routing/include/routing_manager.hpp
index 022aefa..9dd2294 100644
--- a/implementation/routing/include/routing_manager.hpp
+++ b/implementation/routing/include/routing_manager.hpp
@@ -83,9 +83,9 @@ public:
 
 	virtual bool is_available(service_t _service, instance_t _instance) const = 0;
 
-	virtual endpoint * find_local(client_t _client) = 0;
-	virtual endpoint * find_local(service_t _service, instance_t _instance) = 0;
-	virtual endpoint * find_or_create_local(client_t _client) = 0;
+	virtual std::shared_ptr< endpoint > find_local(client_t _client) = 0;
+	virtual std::shared_ptr< endpoint > find_local(service_t _service, instance_t _instance) = 0;
+	virtual std::shared_ptr< endpoint > find_or_create_local(client_t _client) = 0;
 	virtual void remove_local(client_t _client) = 0;
 };
 
diff --git a/implementation/routing/include/routing_manager_impl.hpp b/implementation/routing/include/routing_manager_impl.hpp
index 4769c91..3d5e62f 100644
--- a/implementation/routing/include/routing_manager_impl.hpp
+++ b/implementation/routing/include/routing_manager_impl.hpp
@@ -107,11 +107,11 @@ public:
 	bool is_available(service_t _service, instance_t _instance) const;
 
 	// interface to stub
-	endpoint * create_local(client_t _client);
-	endpoint * find_local(client_t _client);
-	endpoint * find_or_create_local(client_t _client);
+	std::shared_ptr< endpoint > create_local(client_t _client);
+	std::shared_ptr< endpoint > find_local(client_t _client);
+	std::shared_ptr< endpoint > find_or_create_local(client_t _client);
 	void remove_local(client_t _client);
-	endpoint * find_local(service_t _service, instance_t _instance);
+	std::shared_ptr< endpoint > find_local(service_t _service, instance_t _instance);
 
 	// interface "service_discovery_host"
 	const std::map< std::string, std::shared_ptr< servicegroup > > & get_servicegroups() const;
@@ -129,6 +129,7 @@ private:
 	void create_service(service_t _service, instance_t _instance,
 						major_version_t _major, minor_version_t _minor, ttl_t _ttl);
 
+	std::shared_ptr< endpoint > find_remote_client(service_t _service, instance_t _instance, bool _reliable);
 
 	std::shared_ptr< endpoint > create_client_endpoint(const std::string &_address, uint16_t _port, bool _reliable);
 	std::shared_ptr< endpoint > find_client_endpoint(const std::string &_address, uint16_t _port, bool _reliable);
diff --git a/implementation/routing/include/routing_manager_proxy.hpp b/implementation/routing/include/routing_manager_proxy.hpp
index 361446e..9986b6a 100644
--- a/implementation/routing/include/routing_manager_proxy.hpp
+++ b/implementation/routing/include/routing_manager_proxy.hpp
@@ -88,16 +88,16 @@ public:
 
 	bool is_available(service_t _service, instance_t _instance) const;
 
-	endpoint * find_local(client_t _client);
-	endpoint * find_local(service_t _service, instance_t _instance);
-	endpoint * find_or_create_local(client_t _client);
+	std::shared_ptr< endpoint > find_local(client_t _client);
+	std::shared_ptr< endpoint > find_local(service_t _service, instance_t _instance);
+	std::shared_ptr< endpoint > find_or_create_local(client_t _client);
 	void remove_local(client_t _client);
 
 private:
 	void register_application();
 	void deregister_application();
 
-	endpoint * create_local(client_t _client);
+	std::shared_ptr< endpoint > create_local(client_t _client);
 
 	bool is_request(byte_t _message_type) const;
 
diff --git a/implementation/routing/src/routing_manager_impl.cpp b/implementation/routing/src/routing_manager_impl.cpp
index f7f4c80..ec0ea39 100644
--- a/implementation/routing/src/routing_manager_impl.cpp
+++ b/implementation/routing/src/routing_manager_impl.cpp
@@ -226,7 +226,7 @@ void routing_manager_impl::send(client_t its_client,
 
 void routing_manager_impl::send(client_t _client,
 		const byte_t *_data, length_t _size, instance_t _instance, bool _flush, bool _reliable) {
-	endpoint *its_target(nullptr);
+	std::shared_ptr< endpoint > its_target;
 
 	client_t its_client = VSOMEIP_BYTES_TO_WORD(_data[VSOMEIP_CLIENT_POS_MIN], _data[VSOMEIP_CLIENT_POS_MAX]);
 	service_t its_service = VSOMEIP_BYTES_TO_WORD(_data[VSOMEIP_SERVICE_POS_MIN], _data[VSOMEIP_SERVICE_POS_MAX]);
@@ -265,7 +265,9 @@ void routing_manager_impl::send(client_t _client,
 				on_message(_data, _size, _instance);
 			} else {
 				if (is_request) {
-
+					its_target = find_remote_client(its_service, _instance, _reliable);
+					if (its_target)
+						its_target->send(_data, _size, _flush);
 				} else {
 
 				}
@@ -525,17 +527,17 @@ std::shared_ptr< endpoint > routing_manager_impl::find_or_create_server_endpoint
 	return its_endpoint;
 }
 
-endpoint * routing_manager_impl::find_local(client_t _client) {
+std::shared_ptr< endpoint > routing_manager_impl::find_local(client_t _client) {
 	std::unique_lock< std::recursive_mutex > its_lock(endpoint_mutex_);
-	endpoint *its_endpoint(0);
+	std::shared_ptr< endpoint > its_endpoint;
 	auto found_endpoint = local_clients_.find(_client);
 	if (found_endpoint != local_clients_.end()) {
-		its_endpoint = found_endpoint->second.get();
+		its_endpoint = found_endpoint->second;
 	}
 	return its_endpoint;
 }
 
-endpoint * routing_manager_impl::create_local(client_t _client) {
+std::shared_ptr< endpoint > routing_manager_impl::create_local(client_t _client) {
 	std::unique_lock< std::recursive_mutex > its_lock(endpoint_mutex_);
 
 	std::stringstream its_path;
@@ -548,12 +550,12 @@ endpoint * routing_manager_impl::create_local(client_t _client) {
 				io_);
 	local_clients_[_client] = its_endpoint;
 	its_endpoint->start();
-	return its_endpoint.get();
+	return its_endpoint;
 }
 
-endpoint * routing_manager_impl::find_or_create_local(client_t _client) {
-	endpoint *its_endpoint(find_local(_client));
-	if (0 == its_endpoint) {
+std::shared_ptr< endpoint > routing_manager_impl::find_or_create_local(client_t _client) {
+	std::shared_ptr< endpoint > its_endpoint(find_local(_client));
+	if (!its_endpoint) {
 		its_endpoint = create_local(_client);
 	}
 	return its_endpoint;
@@ -561,12 +563,12 @@ endpoint * routing_manager_impl::find_or_create_local(client_t _client) {
 
 void routing_manager_impl::remove_local(client_t _client) {
 	std::unique_lock< std::recursive_mutex > its_lock(endpoint_mutex_);
-	endpoint *its_endpoint = find_local(_client);
+	std::shared_ptr< endpoint > its_endpoint = find_local(_client);
 	its_endpoint->stop();
 	local_clients_.erase(_client);
 }
 
-endpoint * routing_manager_impl::find_local(service_t _service, instance_t _instance) {
+std::shared_ptr< endpoint > routing_manager_impl::find_local(service_t _service, instance_t _instance) {
 	return find_local(find_local_client(_service, _instance));
 }
 
@@ -594,6 +596,22 @@ instance_t routing_manager_impl::find_instance(service_t _service, endpoint * _e
 	return its_instance;
 }
 
+std::shared_ptr< endpoint > routing_manager_impl::find_remote_client(
+		service_t _service, instance_t _instance, bool _reliable) {
+	std::shared_ptr< endpoint > its_endpoint;
+	auto found_service = remote_services_.find(_service);
+	if (found_service != remote_services_.end()) {
+		auto found_instance = found_service->second.find(_instance);
+		if (found_instance != found_service->second.end()) {
+			auto found_reliability = found_instance->second.find(_reliable);
+			if (found_reliability != found_instance->second.end()) {
+				its_endpoint = found_reliability->second;
+			}
+		}
+	}
+	return its_endpoint;
+}
+
 void routing_manager_impl::init_routing_info() {
 	VSOMEIP_INFO << "Service Discovery disabled. Using static routing information.";
 	for (auto i : configuration_->get_remote_services()) {
diff --git a/implementation/routing/src/routing_manager_proxy.cpp b/implementation/routing/src/routing_manager_proxy.cpp
index 7c34feb..e524662 100644
--- a/implementation/routing/src/routing_manager_proxy.cpp
+++ b/implementation/routing/src/routing_manager_proxy.cpp
@@ -217,7 +217,7 @@ void routing_manager_proxy::send(client_t _client,
 		const byte_t *_data, length_t _size,
 		instance_t _instance,
 		bool _flush, bool _reliable) {
-	endpoint *its_target(0);
+	std::shared_ptr< endpoint > its_target;
 
 	if (_size > VSOMEIP_MESSAGE_TYPE_POS) {
 		if (is_request(_data[VSOMEIP_MESSAGE_TYPE_POS])) {
@@ -232,7 +232,7 @@ void routing_manager_proxy::send(client_t _client,
 
 		// If no direct endpoint could be found, route to stub
 		if (!its_target)
-			its_target = sender_.get();
+			its_target = sender_;
 
 		std::vector< byte_t > its_command(VSOMEIP_COMMAND_HEADER_SIZE + _size +
 									sizeof(instance_t) + sizeof(bool) + sizeof(bool));
@@ -444,16 +444,16 @@ void routing_manager_proxy::deregister_application() {
 }
 
 
-endpoint * routing_manager_proxy::find_local(client_t _client) {
-	endpoint *its_endpoint(0);
+std::shared_ptr< endpoint > routing_manager_proxy::find_local(client_t _client) {
+	std::shared_ptr< endpoint > its_endpoint;
 	auto found_endpoint = local_endpoints_.find(_client);
 	if (found_endpoint != local_endpoints_.end()) {
-		its_endpoint = found_endpoint->second.get();
+		its_endpoint = found_endpoint->second;
 	}
 	return its_endpoint;
 }
 
-endpoint * routing_manager_proxy::create_local(client_t _client) {
+std::shared_ptr< endpoint > routing_manager_proxy::create_local(client_t _client) {
 	std::stringstream its_path;
 	its_path << VSOMEIP_BASE_PATH << std::hex << _client;
 
@@ -469,11 +469,11 @@ endpoint * routing_manager_proxy::create_local(client_t _client) {
 	local_endpoints_[_client] = its_endpoint;
 	its_endpoint->start();
 
-	return its_endpoint.get();
+	return its_endpoint;
 }
 
-endpoint * routing_manager_proxy::find_or_create_local(client_t _client) {
-	endpoint *its_endpoint(find_local(_client));
+std::shared_ptr< endpoint > routing_manager_proxy::find_or_create_local(client_t _client) {
+	std::shared_ptr< endpoint > its_endpoint(find_local(_client));
 	if (0 == its_endpoint) {
 		its_endpoint = create_local(_client);
 	}
@@ -481,13 +481,13 @@ endpoint * routing_manager_proxy::find_or_create_local(client_t _client) {
 }
 
 void routing_manager_proxy::remove_local(client_t _client) {
-	endpoint *its_endpoint = find_local(_client);
+	std::shared_ptr< endpoint > its_endpoint(find_local(_client));
 	if (its_endpoint)
 		its_endpoint->stop();
 	local_endpoints_.erase(_client);
 }
 
-endpoint * routing_manager_proxy::find_local(service_t _service, instance_t _instance) {
+std::shared_ptr< endpoint > routing_manager_proxy::find_local(service_t _service, instance_t _instance) {
 	client_t its_client(0);
 	auto found_service = local_services_.find(_service);
 	if (found_service != local_services_.end()) {
diff --git a/implementation/routing/src/routing_manager_stub.cpp b/implementation/routing/src/routing_manager_stub.cpp
index 35a7963..69d1835 100644
--- a/implementation/routing/src/routing_manager_stub.cpp
+++ b/implementation/routing/src/routing_manager_stub.cpp
@@ -200,8 +200,8 @@ void routing_manager_stub::on_stop_offer_service(
 }
 
 void routing_manager_stub::send_routing_info(client_t _client) {
-	endpoint *its_endpoint = routing_->find_local(_client);
-	if (0 != its_endpoint) {
+	std::shared_ptr< endpoint > its_endpoint = routing_->find_local(_client);
+	if (its_endpoint) {
 		uint32_t its_capacity = 4096; // TODO: dynamic resizing
 		std::vector< byte_t > its_command(its_capacity);
 		its_command[VSOMEIP_COMMAND_TYPE_POS] = VSOMEIP_ROUTING_INFO;
@@ -256,7 +256,7 @@ void routing_manager_stub::broadcast_routing_info() {
 
 void routing_manager_stub::broadcast(std::vector< byte_t > &_command) const {
 	for (auto a : routing_info_) {
-		endpoint *its_endpoint = routing_->find_local(a.first);
+		std::shared_ptr< endpoint > its_endpoint = routing_->find_local(a.first);
 		if (its_endpoint) {
 			its_endpoint->send(&_command[0], _command.size(), true);
 		}