Format all code in project

        Formated all code in appMain, components, plugins to correct coding-style
	Used clang-format-3.6

        Used 2 commands :
                find src/appMain/ -name "*.h" -o  -name "*.cc" -o -name "*.hpp" -o -name "*.cpp" | xargs clang-format-3.6 -i -style=file
                find src/components/ -name "*.h" -o  -name "*.cc" -o -name "*.hpp" -o -name "*.cpp" | xargs clang-format-3.6 -i -style=file
		find src/plugins/ -name "*.h" -o  -name "*.cc" -o -name "*.hpp" -o -name "*.cpp" | xargs clang-format-3.6 -i -style=file

1 files changed, 58 insertions, 49 deletions

diff --git a/src/components/connection_handler/src/connection.cc b/src/components/connection_handler/src/connection.cc
index 1953792a4f..7bb54d4493 100644
--- a/src/components/connection_handler/src/connection.cc
+++ b/src/components/connection_handler/src/connection.cc
@@ -45,7 +45,6 @@
 #include "security_manager/security_manager.h"
 #endif  // ENABLE_SECURITY
 
-
 /**
  * \namespace connection_handler
  * \brief SmartDeviceLink ConnectionHandler namespace.
@@ -54,19 +53,21 @@ namespace connection_handler {
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "ConnectionHandler")
 
-Service *Session::FindService(const protocol_handler::ServiceType &service_type) {
+Service* Session::FindService(
+    const protocol_handler::ServiceType& service_type) {
   ServiceList::iterator service_it =
       std::find(service_list.begin(), service_list.end(), service_type);
-  if(service_it != service_list.end()){
+  if (service_it != service_list.end()) {
     return &(*service_it);
   }
   return NULL;
 }
 
-const Service *Session::FindService(const protocol_handler::ServiceType &service_type) const {
+const Service* Session::FindService(
+    const protocol_handler::ServiceType& service_type) const {
   ServiceList::const_iterator service_it =
       std::find(service_list.begin(), service_list.end(), service_type);
-  if(service_it != service_list.end()){
+  if (service_it != service_list.end()) {
     return &(*service_it);
   }
   return NULL;
@@ -74,7 +75,7 @@ const Service *Session::FindService(const protocol_handler::ServiceType &service
 
 Connection::Connection(ConnectionHandle connection_handle,
                        DeviceHandle connection_device_handle,
-                       ConnectionHandler *connection_handler,
+                       ConnectionHandler* connection_handler,
                        uint32_t heartbeat_timeout)
     : connection_handler_(connection_handler)
     , connection_handle_(connection_handle)
@@ -85,8 +86,8 @@ Connection::Connection(ConnectionHandle connection_handle,
   DCHECK(connection_handler_);
 
   heartbeat_monitor_ = new HeartBeatMonitor(heartbeat_timeout_, this);
-  heart_beat_monitor_thread_ = threads::CreateThread("HeartBeatMonitor",
-                                                     heartbeat_monitor_);
+  heart_beat_monitor_thread_ =
+      threads::CreateThread("HeartBeatMonitor", heartbeat_monitor_);
   heart_beat_monitor_thread_->start();
 }
 
@@ -103,7 +104,7 @@ Connection::~Connection() {
 // Returns 0 if that key not found
 namespace {
 template <class T>
-uint32_t findGap(const std::map<unsigned char, T> &map) {
+uint32_t findGap(const std::map<unsigned char, T>& map) {
   for (uint32_t i = 1; i <= UCHAR_MAX; ++i) {
     if (map.find(i) == map.end()) {
       return i;
@@ -143,7 +144,7 @@ bool Connection::AddNewService(uint8_t session_id,
                                const bool request_protection) {
   // Ignore wrong services
   if (protocol_handler::kControl == service_type ||
-     protocol_handler::kInvalidServiceType == service_type ) {
+      protocol_handler::kInvalidServiceType == service_type) {
     LOG4CXX_WARN(logger_, "Wrong service " << static_cast<int>(service_type));
     return false;
   }
@@ -154,19 +155,23 @@ bool Connection::AddNewService(uint8_t session_id,
     LOG4CXX_WARN(logger_, "Session not found in this connection!");
     return false;
   }
-  Session &session = session_it->second;
-  Service *service = session.FindService(service_type);
+  Session& session = session_it->second;
+  Service* service = session.FindService(service_type);
   // if service already exists
   if (service) {
 #ifdef ENABLE_SECURITY
-    if(!request_protection) {
-      LOG4CXX_WARN(logger_, "Session " << static_cast<int>(session_id) <<
-                   " already has unprotected service "<< static_cast<int>(service_type));
+    if (!request_protection) {
+      LOG4CXX_WARN(logger_,
+                   "Session " << static_cast<int>(session_id)
+                              << " already has unprotected service "
+                              << static_cast<int>(service_type));
       return false;
     }
     if (service->is_protected_) {
-      LOG4CXX_WARN(logger_, "Session " << static_cast<int>(session_id) <<
-                   " already has protected service "<< static_cast<int>(service_type));
+      LOG4CXX_WARN(logger_,
+                   "Session " << static_cast<int>(session_id)
+                              << " already has protected service "
+                              << static_cast<int>(service_type));
       return false;
     }
     // For unproteced service could be start protection
@@ -187,18 +192,18 @@ inline bool is_incorrect_for_remove_service(
       // Control type is internal part of session
       protocol_handler::kControl == service_type ||
       // RPC and bulk service is necessary part of session
-      protocol_handler::kRpc  == service_type ||
+      protocol_handler::kRpc == service_type ||
       protocol_handler::kBulk == service_type ||
       // Invalid service is not part of session
       protocol_handler::kInvalidServiceType == service_type;
 }
 
-bool Connection::RemoveService(
-    uint8_t session_id, protocol_handler::ServiceType service_type) {
+bool Connection::RemoveService(uint8_t session_id,
+                               protocol_handler::ServiceType service_type) {
   // Ignore wrong and required for Session services
   if (is_incorrect_for_remove_service(service_type)) {
-    LOG4CXX_WARN(logger_, "Could not remove service "
-                 << static_cast<int>(service_type));
+    LOG4CXX_WARN(logger_,
+                 "Could not remove service " << static_cast<int>(service_type));
     return false;
   }
   sync_primitives::AutoLock lock(session_map_lock_);
@@ -209,12 +214,13 @@ bool Connection::RemoveService(
     return false;
   }
 
-  ServiceList &service_list = session_it->second.service_list;
+  ServiceList& service_list = session_it->second.service_list;
   ServiceList::iterator service_it =
       find(service_list.begin(), service_list.end(), service_type);
   if (service_list.end() == service_it) {
-    LOG4CXX_WARN(logger_, "Session " << session_id << " didn't established"
-                  " service " << service_type);
+    LOG4CXX_WARN(logger_,
+                 "Session " << session_id << " didn't established"
+                                             " service " << service_type);
     return false;
   }
   service_list.erase(service_it);
@@ -223,20 +229,21 @@ bool Connection::RemoveService(
 
 #ifdef ENABLE_SECURITY
 int Connection::SetSSLContext(uint8_t session_id,
-                              security_manager::SSLContext *context) {
+                              security_manager::SSLContext* context) {
   sync_primitives::AutoLock lock(session_map_lock_);
   SessionMap::iterator session_it = session_map_.find(session_id);
   if (session_it == session_map_.end()) {
     LOG4CXX_WARN(logger_, "Session not found in this connection!");
     return security_manager::SecurityManager::ERROR_INTERNAL;
   }
-  Session &session = session_it->second;
+  Session& session = session_it->second;
   session.ssl_context = context;
   return security_manager::SecurityManager::ERROR_SUCCESS;
 }
 
-security_manager::SSLContext *Connection::GetSSLContext(
-    const uint8_t session_id, const protocol_handler::ServiceType &service_type) const {
+security_manager::SSLContext* Connection::GetSSLContext(
+    const uint8_t session_id,
+    const protocol_handler::ServiceType& service_type) const {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock lock(session_map_lock_);
   SessionMap::const_iterator session_it = session_map_.find(session_id);
@@ -244,11 +251,11 @@ security_manager::SSLContext *Connection::GetSSLContext(
     LOG4CXX_WARN(logger_, "Session not found in this connection!");
     return NULL;
   }
-  const Session &session = session_it->second;
+  const Session& session = session_it->second;
   // for control services return current SSLContext value
   if (protocol_handler::kControl == service_type)
     return session.ssl_context;
-  const Service *service = session.FindService(service_type);
+  const Service* service = session.FindService(service_type);
   if (!service) {
     LOG4CXX_WARN(logger_, "Service not found in this session!");
     return NULL;
@@ -260,7 +267,8 @@ security_manager::SSLContext *Connection::GetSSLContext(
 }
 
 void Connection::SetProtectionFlag(
-    const uint8_t session_id, const protocol_handler::ServiceType &service_type) {
+    const uint8_t session_id,
+    const protocol_handler::ServiceType& service_type) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock lock(session_map_lock_);
   SessionMap::iterator session_it = session_map_.find(session_id);
@@ -268,8 +276,8 @@ void Connection::SetProtectionFlag(
     LOG4CXX_WARN(logger_, "Session not found in this connection!");
     return;
   }
-  Session &session = session_it->second;
-  Service *service = session.FindService(service_type);
+  Session& session = session_it->second;
+  Service* service = session.FindService(service_type);
   if (!service) {
     LOG4CXX_WARN(logger_, "Service not found in this session!");
     return;
@@ -277,11 +285,11 @@ void Connection::SetProtectionFlag(
   service->is_protected_ = true;
   // Rpc and bulk shall be protected as one service
   if (service->service_type == protocol_handler::kRpc) {
-    Service *service_bulk = session.FindService(protocol_handler::kBulk);
+    Service* service_bulk = session.FindService(protocol_handler::kBulk);
     DCHECK(service_bulk);
     service_bulk->is_protected_ = true;
   } else if (service->service_type == protocol_handler::kBulk) {
-    Service *service_rpc = session.FindService(protocol_handler::kRpc);
+    Service* service_rpc = session.FindService(protocol_handler::kRpc);
     DCHECK(service_rpc);
     service_rpc->is_protected_ = true;
   }
@@ -313,25 +321,24 @@ void Connection::CloseSession(uint8_t session_id) {
     size = session_map_.size();
   }
 
-  connection_handler_->CloseSession(connection_handle_,
-                                    session_id,
-                                    connection_handler::kCommon);
+  connection_handler_->CloseSession(
+      connection_handle_, session_id, connection_handler::kCommon);
 
-  //Close connection if it is last session
+  // Close connection if it is last session
   if (1 == size) {
     connection_handler_->CloseConnection(connection_handle_);
   }
 }
 
-void Connection::UpdateProtocolVersionSession(
-    uint8_t session_id, uint8_t protocol_version) {
+void Connection::UpdateProtocolVersionSession(uint8_t session_id,
+                                              uint8_t protocol_version) {
   sync_primitives::AutoLock lock(session_map_lock_);
   SessionMap::iterator session_it = session_map_.find(session_id);
   if (session_map_.end() == session_it) {
     LOG4CXX_WARN(logger_, "Session not found in this connection!");
     return;
   }
-  Session &session = session_it->second;
+  Session& session = session_it->second;
   session.protocol_version = protocol_version;
 }
 
@@ -343,19 +350,21 @@ bool Connection::SupportHeartBeat(uint8_t session_id) {
     LOG4CXX_WARN(logger_, "Session not found in this connection!");
     return false;
   }
-  Session &session = session_it->second;
-  return ((::protocol_handler::PROTOCOL_VERSION_3 == session.protocol_version ||
-           ::protocol_handler::PROTOCOL_VERSION_4 == session.protocol_version) &&
-           (0 != heartbeat_timeout_));
+  Session& session = session_it->second;
+  return (
+      (::protocol_handler::PROTOCOL_VERSION_3 == session.protocol_version ||
+       ::protocol_handler::PROTOCOL_VERSION_4 == session.protocol_version) &&
+      (0 != heartbeat_timeout_));
 }
 
-bool Connection::ProtocolVersion(uint8_t session_id, uint8_t& protocol_version) {
+bool Connection::ProtocolVersion(uint8_t session_id,
+                                 uint8_t& protocol_version) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock lock(session_map_lock_);
   SessionMap::iterator session_it = session_map_.find(session_id);
   if (session_map_.end() == session_it) {
     LOG4CXX_WARN(logger_, "Session not found in this connection!");
-	return false;
+    return false;
   }
   protocol_version = (session_it->second).protocol_version;
   return true;