Use lock_guard instead of unique_lock where possible (which are all(!)

occurences in the library as we do not use condition variables or
re-locking there).
Adapted formatting of lock statements in the sample code.

5 files changed, 17 insertions, 16 deletions

diff --git a/implementation/configuration/src/configuration_impl.cpp b/implementation/configuration/src/configuration_impl.cpp
index 728b204..7480002 100644
--- a/implementation/configuration/src/configuration_impl.cpp
+++ b/implementation/configuration/src/configuration_impl.cpp
@@ -34,7 +34,7 @@ configuration * configuration_impl::get(const std::string &_path) {
 
   bool is_freshly_loaded(false);
   {
-    std::unique_lock < std::mutex > its_lock(mutex_);
+    std::lock_guard<std::mutex> its_lock(mutex_);
 
     auto found_configuration = the_configurations.find(_path);
     if (found_configuration != the_configurations.end()) {
diff --git a/implementation/endpoints/src/client_endpoint_impl.cpp b/implementation/endpoints/src/client_endpoint_impl.cpp
index f71b5a3..77bd7d7 100644
--- a/implementation/endpoints/src/client_endpoint_impl.cpp
+++ b/implementation/endpoints/src/client_endpoint_impl.cpp
@@ -76,7 +76,7 @@ template<typename Protocol, int MaxBufferSize>
 bool client_endpoint_impl<Protocol, MaxBufferSize>::send(const uint8_t *_data,

                                                          uint32_t _size,

                                                          bool _flush) {

-  std::unique_lock < std::mutex > its_lock(mutex_);

+  std::lock_guard<std::mutex> its_lock(mutex_);

 #if 0

   std::stringstream msg;

   msg << "cei::send: ";

diff --git a/implementation/endpoints/src/server_endpoint_impl.cpp b/implementation/endpoints/src/server_endpoint_impl.cpp
index 76bbd0c..ea6a93f 100644
--- a/implementation/endpoints/src/server_endpoint_impl.cpp
+++ b/implementation/endpoints/src/server_endpoint_impl.cpp
@@ -54,7 +54,7 @@ bool server_endpoint_impl<Protocol, MaxBufferSize>::send(
   bool is_valid_target(false);

 

   if (VSOMEIP_SESSION_POS_MAX < _size) {

-    std::unique_lock < std::mutex > its_lock(mutex_);

+    std::lock_guard<std::mutex> its_lock(mutex_);

 

     service_t its_service;

     std::memcpy(&its_service, &_data[VSOMEIP_SERVICE_POS_MIN],

@@ -128,7 +128,7 @@ template<typename Protocol, int MaxBufferSize>
 bool server_endpoint_impl<Protocol, MaxBufferSize>::flush(

     endpoint_type _target) {

   bool is_flushed = false;

-  std::unique_lock < std::mutex > its_lock(mutex_);

+  std::lock_guard<std::mutex> its_lock(mutex_);

   auto i = packetizer_.find(_target);

   if (i != packetizer_.end() && !i->second->empty()) {

     send_queued(_target, i->second);

diff --git a/implementation/routing/src/routing_manager_impl.cpp b/implementation/routing/src/routing_manager_impl.cpp
index a0ba824..2c0710e 100644
--- a/implementation/routing/src/routing_manager_impl.cpp
+++ b/implementation/routing/src/routing_manager_impl.cpp
@@ -227,11 +227,12 @@ bool routing_manager_impl::send(client_t its_client,
 		bool _reliable,
 		bool _flush) {
 	bool is_sent(false);
-	std::unique_lock<std::mutex> its_lock(serialize_mutex_); // TODO: lock serialization only
 
 	if (utility::is_request(_message->get_message_type())) {
 		_message->set_client(its_client);
 	}
+
+	std::lock_guard<std::mutex> its_lock(serialize_mutex_);
 	if (serializer_->serialize(_message.get())) {
 		is_sent = send(its_client, serializer_->get_data(),
 				serializer_->get_size(), _message->get_instance(), _reliable,
@@ -413,7 +414,7 @@ bool routing_manager_impl::set(client_t _client, session_t _session,
 				its_request->set_session(_session);
 				its_request->set_payload(_payload);
 
-				std::unique_lock<std::mutex> its_lock(serialize_mutex_);
+				std::lock_guard<std::mutex> its_lock(serialize_mutex_);
 				if (serializer_->serialize(its_request.get())) {
 					is_set = its_target->send(serializer_->get_data(), serializer_->get_size());
 				} else {
@@ -432,7 +433,7 @@ bool routing_manager_impl::send_to(
 		const std::shared_ptr<endpoint_definition> &_target,
 		std::shared_ptr<message> _message) {
 	bool is_sent(false);
-	std::unique_lock<std::mutex> its_lock(serialize_mutex_);
+	std::lock_guard<std::mutex> its_lock(serialize_mutex_);
 	if (serializer_->serialize(_message.get())) {
 		is_sent = send_to(_target,
 				serializer_->get_data(), serializer_->get_size());
@@ -525,7 +526,7 @@ void routing_manager_impl::on_message(service_t _service, instance_t _instance,
 						its_response->set_message_type(message_type_e::ERROR);
 					}
 
-					std::unique_lock<std::mutex> its_lock(serialize_mutex_);
+					std::lock_guard<std::mutex> its_lock(serialize_mutex_);
 					if (serializer_->serialize(its_response.get())) {
 						send(its_client,
 							serializer_->get_data(), serializer_->get_size(),
@@ -842,7 +843,7 @@ std::shared_ptr<endpoint> routing_manager_impl::find_client_endpoint(
 std::shared_ptr<endpoint> routing_manager_impl::find_or_create_client_endpoint(
 		const boost::asio::ip::address &_address, uint16_t _port,
 		bool _reliable) {
-	std::unique_lock<std::recursive_mutex> its_lock(endpoint_mutex_);
+	std::lock_guard<std::recursive_mutex> its_lock(endpoint_mutex_);
 	std::shared_ptr<endpoint> its_endpoint = find_client_endpoint(_address,
 			_port, _reliable);
 	if (0 == its_endpoint) {
@@ -900,7 +901,7 @@ std::shared_ptr<endpoint> routing_manager_impl::find_server_endpoint(
 
 std::shared_ptr<endpoint> routing_manager_impl::find_or_create_server_endpoint(
 		uint16_t _port, bool _reliable) {
-	std::unique_lock<std::recursive_mutex> its_lock(endpoint_mutex_);
+	std::lock_guard<std::recursive_mutex> its_lock(endpoint_mutex_);
 	std::shared_ptr<endpoint> its_endpoint = find_server_endpoint(_port,
 			_reliable);
 	if (0 == its_endpoint) {
@@ -910,7 +911,7 @@ std::shared_ptr<endpoint> routing_manager_impl::find_or_create_server_endpoint(
 }
 
 std::shared_ptr<endpoint> routing_manager_impl::find_local(client_t _client) {
-	std::unique_lock<std::recursive_mutex> its_lock(endpoint_mutex_);
+	std::lock_guard<std::recursive_mutex> its_lock(endpoint_mutex_);
 	std::shared_ptr<endpoint> its_endpoint;
 	auto found_endpoint = local_clients_.find(_client);
 	if (found_endpoint != local_clients_.end()) {
@@ -920,7 +921,7 @@ std::shared_ptr<endpoint> routing_manager_impl::find_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::lock_guard<std::recursive_mutex> its_lock(endpoint_mutex_);
 
 	std::stringstream its_path;
 	its_path << base_path << std::hex << _client;
@@ -943,7 +944,7 @@ std::shared_ptr<endpoint> routing_manager_impl::find_or_create_local(
 }
 
 void routing_manager_impl::remove_local(client_t _client) {
-	std::unique_lock<std::recursive_mutex> its_lock(endpoint_mutex_);
+	std::lock_guard<std::recursive_mutex> its_lock(endpoint_mutex_);
 	std::shared_ptr<endpoint> its_endpoint = find_local(_client);
 	its_endpoint->stop();
 	local_clients_.erase(_client);
diff --git a/implementation/routing/src/routing_manager_proxy.cpp b/implementation/routing/src/routing_manager_proxy.cpp
index 21216d1..2419604 100644
--- a/implementation/routing/src/routing_manager_proxy.cpp
+++ b/implementation/routing/src/routing_manager_proxy.cpp
@@ -204,7 +204,7 @@ bool routing_manager_proxy::send(client_t its_client,
 		bool _flush,
 		bool _reliable) {
 	bool is_sent(false);
-	std::unique_lock<std::mutex> its_lock(serialize_mutex_);
+	std::lock_guard<std::mutex> its_lock(serialize_mutex_);
 	if (serializer_->serialize(_message.get())) {
 		is_sent = send(its_client, serializer_->get_data(),
 				serializer_->get_size(), _message->get_instance(), _flush,
@@ -225,13 +225,13 @@ bool routing_manager_proxy::send(client_t _client, const byte_t *_data,
 			service_t its_service = VSOMEIP_BYTES_TO_WORD(
 					_data[VSOMEIP_SERVICE_POS_MIN],
 					_data[VSOMEIP_SERVICE_POS_MAX]);
-			std::unique_lock<std::mutex> its_lock(send_mutex_);
+			std::lock_guard<std::mutex> its_lock(send_mutex_);
 			its_target = find_local(its_service, _instance);
 		} else {
 			client_t its_client = VSOMEIP_BYTES_TO_WORD(
 					_data[VSOMEIP_CLIENT_POS_MIN],
 					_data[VSOMEIP_CLIENT_POS_MAX]);
-			std::unique_lock<std::mutex> its_lock(send_mutex_);
+			std::lock_guard<std::mutex> its_lock(send_mutex_);
 			its_target = find_local(its_client);
 		}