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

11 files changed, 216 insertions, 220 deletions

diff --git a/src/components/dbus/include/dbus/dbus_adapter.h b/src/components/dbus/include/dbus/dbus_adapter.h
index ec59fa421e..3877649e10 100644
--- a/src/components/dbus/include/dbus/dbus_adapter.h
+++ b/src/components/dbus/include/dbus/dbus_adapter.h
@@ -85,7 +85,9 @@ class DBusAdapter {
    * \param name pair interface and name of method for call
    * \param obj params for call
    */
-  void MethodCall(uint id, const MessageId func_id, const MessageName& name,
+  void MethodCall(uint id,
+                  const MessageId func_id,
+                  const MessageName& name,
                   const smart_objects::SmartObject& obj);
 
   /**
@@ -95,7 +97,8 @@ class DBusAdapter {
    * \param name pair interface and name of signal for call
    * \param obj params for signal
    */
-  void Signal(const MessageId func_id, const MessageName& name,
+  void Signal(const MessageId func_id,
+              const MessageName& name,
               const smart_objects::SmartObject& obj);
 
   /**
@@ -103,7 +106,9 @@ class DBusAdapter {
    * \param id id message
    * \param obj params for return
    */
-  void MethodReturn(uint id, const MessageId func_id, const MessageName& name,
+  void MethodReturn(uint id,
+                    const MessageId func_id,
+                    const MessageName& name,
                     const smart_objects::SmartObject& obj);
 
   /**
@@ -219,7 +224,8 @@ class DBusAdapter {
    * \param args map of arguments
    * \return true if success
    */
-  bool SetArguments(DBusMessage* msg, const ListArgs& rules,
+  bool SetArguments(DBusMessage* msg,
+                    const ListArgs& rules,
                     const smart_objects::SmartObject& args);
 
   /**
@@ -278,7 +284,7 @@ class DBusAdapter {
   bool SetOptionalValue(
       DBusMessageIter* iter,
       const ford_message_descriptions::ParameterDescription* rules,
-      const smart_objects::SmartObject &param);
+      const smart_objects::SmartObject& param);
 
   /**
    * \brief gets arguments from message
@@ -287,7 +293,7 @@ class DBusAdapter {
    * \param message response message (output)
    * \return true if success
    */
-  bool GetHeader(DBusMessageIter* iter, int *code, std::string *message);
+  bool GetHeader(DBusMessageIter* iter, int* code, std::string* message);
 
   /**
    * \brief gets arguments from message with header
@@ -296,7 +302,8 @@ class DBusAdapter {
    * \param args map of arguments
    * \return true if success
    */
-  bool GetArguments(DBusMessageIter* iter, const ListArgs& rules,
+  bool GetArguments(DBusMessageIter* iter,
+                    const ListArgs& rules,
                     smart_objects::SmartObject& args);
 
   /**
@@ -309,7 +316,7 @@ class DBusAdapter {
   bool GetOneArgument(
       DBusMessageIter* iter,
       const ford_message_descriptions::ParameterDescription* rules,
-      smart_objects::SmartObject &args);
+      smart_objects::SmartObject& args);
 
   /**
    * \brief gets value for argument
@@ -355,7 +362,7 @@ class DBusAdapter {
   bool GetOptionalValue(
       DBusMessageIter* iter,
       const ford_message_descriptions::ParameterDescription* rules,
-      smart_objects::SmartObject &param);
+      smart_objects::SmartObject& param);
 
   /**
    * \brief processes request on introspect
diff --git a/src/components/dbus/include/dbus/dbus_message.h b/src/components/dbus/include/dbus/dbus_message.h
index 42ec68b3bf..10f419f445 100644
--- a/src/components/dbus/include/dbus/dbus_message.h
+++ b/src/components/dbus/include/dbus/dbus_message.h
@@ -46,7 +46,7 @@ enum ContainerType {
 };
 
 class MessageRefKeeper {
-public:
+ public:
   MessageRefKeeper();
   MessageRefKeeper(DBusMessage* message);
   ~MessageRefKeeper();
@@ -55,7 +55,8 @@ public:
   DBusMessage* get() const;
   DBusMessage* Pass();
   void swap(MessageRefKeeper& other);
-private:
+
+ private:
   DBusMessage* raw_message_;
 };
 
@@ -65,6 +66,7 @@ class MessageRef {
   ~MessageRef();
   std::string GetInterface() const;
   std::string GetMember() const;
+
  protected:
   MessageRefKeeper raw_message_ref_;
   friend class MessageReader;
@@ -96,29 +98,30 @@ class MessageReader {
   bool NextIsDictEntry() const;
 
   // Readers
-  bool     TakeBool();
-  uint8_t  TakeByte();
-  int16_t  TakeInt16();
+  bool TakeBool();
+  uint8_t TakeByte();
+  int16_t TakeInt16();
   uint16_t TakeUint16();
-  int32_t  TakeInt32();
+  int32_t TakeInt32();
   uint32_t TakeUint32();
-  int64_t  TakeInt64();
+  int64_t TakeInt64();
   uint64_t TakeUint64();
-  double   TakeDouble();
+  double TakeDouble();
   std::string TakeString();
 
   MessageReader TakeArrayReader();
   MessageReader TakeStructReader();
   MessageReader TakeDictEntryReader();
+
  private:
   typedef int DataType;
   // Container reader constructor
-  MessageReader(MessageReader* reader,
-                DataType container_data_type);
+  MessageReader(MessageReader* reader, DataType container_data_type);
   void MoveToNext();
   void MarkFailed();
   DataType NextValueType() const;
   void ReadNextValue(DataType type, void* value);
+
  private:
   // Fields
   MessageReader* parent_reader_;
@@ -146,13 +149,15 @@ class MessageWriter {
   void PutUint64(uint64_t value);
   void PutDouble(double value);
   void PutString(const std::string& value);
+
  private:
   typedef int DataType;
   // Main constructor
   void WriteAndCheck(DataType value_type, const void* value);
   void CloseWriter();
+
  private:
-  //Fields
+  // Fields
   bool has_opened_subcontainer_;
   MessageWriter* parent_writer_;
   DBusMessageIter iterator_;
@@ -166,11 +171,9 @@ MessageRef MethodCall(const char* bus_name,
                       const char* path,
                       const char* interface,
                       const char* method);
-MessageRef Signal(const char  *path,
-                  const char  *interface,
-                  const char  *name);
-} // namespace dbus
+MessageRef Signal(const char* path, const char* interface, const char* name);
+}  // namespace dbus
 
 #include "dbus/dbus_message_inl.h"
 
-#endif // DBUS_DBUS_MESSAGE_H
+#endif  // DBUS_DBUS_MESSAGE_H
diff --git a/src/components/dbus/include/dbus/dbus_message_inl.h b/src/components/dbus/include/dbus/dbus_message_inl.h
index 714e66ea33..1a10f828de 100644
--- a/src/components/dbus/include/dbus/dbus_message_inl.h
+++ b/src/components/dbus/include/dbus/dbus_message_inl.h
@@ -161,14 +161,11 @@ inline std::string MessageReader::TakeString() {
   return value;
 }
 
-
 inline MessageReader::DataType MessageReader::NextValueType() const {
   DBusMessageIter* iter = const_cast<DBusMessageIter*>(&iterator_);
   return failed_ ? DBUS_TYPE_INVALID : dbus_message_iter_get_arg_type(iter);
 }
 
-
-
 // Message writer methods
 inline void MessageWriter::PutBool(bool value) {
   dbus_bool_t dbus_value = value;
@@ -212,7 +209,6 @@ inline void MessageWriter::PutString(const std::string& value) {
   WriteAndCheck(DBUS_TYPE_STRING, &pointer);
 }
 
-
 }  // namespace dbus
 
-#endif // DBUS_MESSAGE_INL_H
+#endif  // DBUS_MESSAGE_INL_H
diff --git a/src/components/dbus/include/dbus/message_descriptions.h b/src/components/dbus/include/dbus/message_descriptions.h
index 18c27ce0d6..a9e7a5e141 100644
--- a/src/components/dbus/include/dbus/message_descriptions.h
+++ b/src/components/dbus/include/dbus/message_descriptions.h
@@ -38,12 +38,13 @@
 
 namespace ford_message_descriptions {
 
-enum ParameterType {Integer, Boolean, Float, String, Struct, Enum, Array};
+enum ParameterType { Integer, Boolean, Float, String, Struct, Enum, Array };
 
 struct ParameterDescription {
   const char* name;
   const ParameterType type;
-  const bool obligatory; // TODO (dchmerev@luxoft.com): rename to 'mandatory' as in HMI API description
+  const bool obligatory;  // TODO (dchmerev@luxoft.com): rename to 'mandatory'
+                          // as in HMI API description
 };
 
 struct ArrayDescription {
@@ -70,4 +71,3 @@ extern const MessageDescription* message_descriptions[];
 }  // namespace ford_message_descriptions
 
 #endif  // SRC_COMPONENTS_DBUS_INCLUDE_DBUS_MESSAGE_DESCRIPTIONS_H_
-
diff --git a/src/components/dbus/include/dbus/schema.h b/src/components/dbus/include/dbus/schema.h
index 2a5f6f3615..e269bd2596 100644
--- a/src/components/dbus/include/dbus/schema.h
+++ b/src/components/dbus/include/dbus/schema.h
@@ -48,7 +48,7 @@ struct Description;
 
 typedef hmi_apis::FunctionID::eType MessageId;
 typedef hmi_apis::messageType::eType MessageType;
-typedef std::pair<std::string, std::string> MessageName; // interface, message
+typedef std::pair<std::string, std::string> MessageName;  // interface, message
 typedef std::vector<const ParameterDescription*> ListArgs;
 typedef std::vector<const Description*> Messages;
 
diff --git a/src/components/dbus/src/dbus_adapter.cc b/src/components/dbus/src/dbus_adapter.cc
index 4f0cb74527..b4f4b86dd2 100644
--- a/src/components/dbus/src/dbus_adapter.cc
+++ b/src/components/dbus/src/dbus_adapter.cc
@@ -46,8 +46,9 @@ namespace dbus {
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "HMIMessageHandler")
 
-std::vector<std::string> &split(const std::string& s, char delim,
-                                std::vector<std::string> &elems) {
+std::vector<std::string>& split(const std::string& s,
+                                char delim,
+                                std::vector<std::string>& elems) {
   std::stringstream ss(s);
   std::string item;
   while (std::getline(ss, item, delim)) {
@@ -60,12 +61,12 @@ DBusAdapter::DBusAdapter(const std::string& sdlServiceName,
                          const std::string& sdlObjectPath,
                          const std::string& hmiServiceName,
                          const std::string& hmiObjectPath)
-    : sdl_service_name_(sdlServiceName),
-      sdl_object_path_(sdlObjectPath),
-      hmi_service_name_(hmiServiceName),
-      hmi_object_path_(hmiObjectPath),
-      conn_(NULL),
-      schema_(new DBusSchema(ford_message_descriptions::message_descriptions)) {
+    : sdl_service_name_(sdlServiceName)
+    , sdl_object_path_(sdlObjectPath)
+    , hmi_service_name_(hmiServiceName)
+    , hmi_object_path_(hmiObjectPath)
+    , conn_(NULL)
+    , schema_(new DBusSchema(ford_message_descriptions::message_descriptions)) {
 }
 
 DBusAdapter::~DBusAdapter() {
@@ -87,18 +88,17 @@ bool DBusAdapter::Init() {
     dbus_error_free(&err);
     return false;
   }
-  ret = dbus_bus_request_name(conn_, sdl_service_name_.c_str(),
-  DBUS_NAME_FLAG_DO_NOT_QUEUE,
-                              &err);
+  ret = dbus_bus_request_name(
+      conn_, sdl_service_name_.c_str(), DBUS_NAME_FLAG_DO_NOT_QUEUE, &err);
   if (ret == -1 || dbus_error_is_set(&err)) {
     LOG4CXX_ERROR(logger_, "DBus: Can't request name " << err.name);
     dbus_error_free(&err);
     return false;
   }
   if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
-    LOG4CXX_ERROR(
-        logger_,
-        "DBus: Service '" << sdl_service_name_ << "' is already running");
+    LOG4CXX_ERROR(logger_,
+                  "DBus: Service '" << sdl_service_name_
+                                    << "' is already running");
     return false;
   }
 
@@ -131,7 +131,8 @@ bool DBusAdapter::Process(smart_objects::SmartObject& obj) {
   return false;
 }
 
-void DBusAdapter::MethodReturn(uint id, const MessageId func_id,
+void DBusAdapter::MethodReturn(uint id,
+                               const MessageId func_id,
                                const MessageName& name,
                                const smart_objects::SmartObject& obj) {
   LOG4CXX_DEBUG(logger_, "Method return " << name.first << "." << name.second);
@@ -158,8 +159,8 @@ void DBusAdapter::MethodReturn(uint id, const MessageId func_id,
     return;
   }
 
-  const ListArgs& args = schema_->getListArgs(func_id,
-                                              hmi_apis::messageType::response);
+  const ListArgs& args =
+      schema_->getListArgs(func_id, hmi_apis::messageType::response);
   if (!SetArguments(reply, args, obj)) {
     LOG4CXX_ERROR(logger_, "DBus: Failed call method (Signature is wrong)");
     dbus_message_unref(reply);
@@ -180,7 +181,8 @@ void DBusAdapter::MethodReturn(uint id, const MessageId func_id,
   LOG4CXX_INFO(logger_, "DBus: Success return method");
 }
 
-void DBusAdapter::Error(uint id, const std::string& name,
+void DBusAdapter::Error(uint id,
+                        const std::string& name,
                         const std::string& description) {
   LOG4CXX_DEBUG(logger_, "Error " << name << ": " << description);
   if (conn_ == NULL) {
@@ -214,7 +216,8 @@ void DBusAdapter::Error(uint id, const std::string& name,
   LOG4CXX_INFO(logger_, "DBus: Success error");
 }
 
-void DBusAdapter::MethodCall(uint id, const MessageId func_id,
+void DBusAdapter::MethodCall(uint id,
+                             const MessageId func_id,
                              const MessageName& name,
                              const smart_objects::SmartObject& obj) {
   LOG4CXX_DEBUG(logger_, "Method call " << name.first << "." << name.second);
@@ -230,15 +233,17 @@ void DBusAdapter::MethodCall(uint id, const MessageId func_id,
 
   DBusMessage* msg;
   msg = dbus_message_new_method_call(
-      hmi_service_name_.c_str(), hmi_object_path_.c_str(),
-      (hmi_service_name_ + "." + name.first).c_str(), name.second.c_str());
+      hmi_service_name_.c_str(),
+      hmi_object_path_.c_str(),
+      (hmi_service_name_ + "." + name.first).c_str(),
+      name.second.c_str());
   if (NULL == msg) {
     LOG4CXX_WARN(logger_, "DBus: Failed call method (Message Null)");
     return;
   }
 
-  const ListArgs& args = schema_->getListArgs(func_id,
-                                              hmi_apis::messageType::request);
+  const ListArgs& args =
+      schema_->getListArgs(func_id, hmi_apis::messageType::request);
   if (!SetArguments(msg, args, obj)) {
     LOG4CXX_ERROR(logger_, "DBus: Failed call method (Signature is wrong)");
     dbus_message_unref(msg);
@@ -256,7 +261,8 @@ void DBusAdapter::MethodCall(uint id, const MessageId func_id,
   LOG4CXX_INFO(logger_, "DBus: Success call method");
 }
 
-void DBusAdapter::Signal(const MessageId func_id, const MessageName& name,
+void DBusAdapter::Signal(const MessageId func_id,
+                         const MessageName& name,
                          const smart_objects::SmartObject& obj) {
   LOG4CXX_DEBUG(logger_, "Signal " << name.first << "." << name.second);
   if (conn_ == NULL) {
@@ -269,7 +275,7 @@ void DBusAdapter::Signal(const MessageId func_id, const MessageName& name,
     return;
   }
 
-  DBusMessage *msg;
+  DBusMessage* msg;
   msg = dbus_message_new_signal(sdl_object_path_.c_str(),
                                 (sdl_service_name_ + "." + name.first).c_str(),
                                 name.second.c_str());
@@ -278,8 +284,8 @@ void DBusAdapter::Signal(const MessageId func_id, const MessageName& name,
     return;
   }
 
-  const ListArgs& args = schema_->getListArgs(
-      func_id, hmi_apis::messageType::notification);
+  const ListArgs& args =
+      schema_->getListArgs(func_id, hmi_apis::messageType::notification);
   if (!SetArguments(msg, args, obj)) {
     LOG4CXX_ERROR(logger_, "DBus: Failed call method (Signature is wrong)");
     dbus_message_unref(msg);
@@ -306,8 +312,8 @@ bool DBusAdapter::ProcessMethodCall(DBusMessage* msg,
   std::string interface = dbus_message_get_interface(msg);
   LOG4CXX_INFO(logger_, "DBus: name of method " << interface << " " << method);
 
-  if (interface == "org.freedesktop.DBus.Introspectable"
-      && method == "Introspect") {
+  if (interface == "org.freedesktop.DBus.Introspectable" &&
+      method == "Introspect") {
     LOG4CXX_INFO(logger_, "DBus: INTROSPECT");
     Introspect(msg);
     return false;
@@ -331,11 +337,11 @@ bool DBusAdapter::ProcessMethodCall(DBusMessage* msg,
   obj[sos::S_PARAMS][sos::S_CORRELATION_ID] = serial;
   obj[sos::S_PARAMS][sos::S_FUNCTION_ID] = m_id;
   obj[sos::S_PARAMS][sos::S_MESSAGE_TYPE] = hmi_apis::messageType::request;
-  obj[sos::S_MSG_PARAMS] = smart_objects::SmartObject(
-      smart_objects::SmartType_Map);
+  obj[sos::S_MSG_PARAMS] =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
 
-  const ListArgs args = schema_->getListArgs(name,
-                                             hmi_apis::messageType::request);
+  const ListArgs args =
+      schema_->getListArgs(name, hmi_apis::messageType::request);
 
   DBusMessageIter iter;
   dbus_message_iter_init(msg, &iter);
@@ -356,18 +362,18 @@ bool DBusAdapter::ProcessMethodReturn(DBusMessage* msg,
     return false;
   }
 
-  obj[sos::S_MSG_PARAMS] = smart_objects::SmartObject(
-      smart_objects::SmartType_Map);
+  obj[sos::S_MSG_PARAMS] =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
 
-  ListArgs args = schema_->getListArgs(ids.second,
-                                       hmi_apis::messageType::response);
+  ListArgs args =
+      schema_->getListArgs(ids.second, hmi_apis::messageType::response);
   DBusMessageIter iter;
   dbus_message_iter_init(msg, &iter);
   int code = 0;
   std::string message;
   smart_objects::SmartObject description(smart_objects::SmartType_Map);
-  bool ret = GetHeader(&iter, &code, &message)
-      && GetArguments(&iter, args, description);
+  bool ret = GetHeader(&iter, &code, &message) &&
+             GetArguments(&iter, args, description);
 
   if (ret) {
     obj[sos::S_PARAMS][sos::S_CORRELATION_ID] = ids.first;
@@ -402,13 +408,13 @@ bool DBusAdapter::ProcessError(DBusMessage* msg,
   if ((error_name = dbus_message_get_error_name(msg)) != NULL) {
     smart_objects::SmartObject name(smart_objects::SmartType_String);
     name = error_name;
-    ford_message_descriptions::ParameterDescription rule = { "description",
-        ford_message_descriptions::String, true };
+    ford_message_descriptions::ParameterDescription rule = {
+        "description", ford_message_descriptions::String, true};
     ListArgs args;
     args.push_back(&rule);
     smart_objects::SmartObject description(smart_objects::SmartType_Map);
-    description[rule.name] = smart_objects::SmartObject(
-        smart_objects::SmartType_String);
+    description[rule.name] =
+        smart_objects::SmartObject(smart_objects::SmartType_String);
 
     DBusMessageIter iter;
     dbus_message_iter_init(msg, &iter);
@@ -421,13 +427,15 @@ bool DBusAdapter::ProcessError(DBusMessage* msg,
         hmi_apis::messageType::error_response;
     obj[sos::S_PARAMS][sos::kCode] = name.asInt();
     obj[sos::S_PARAMS][sos::kMessage] = description[rule.name].asString();
-    obj[sos::S_MSG_PARAMS] = smart_objects::SmartObject(
-        smart_objects::SmartType_Map);
+    obj[sos::S_MSG_PARAMS] =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
     obj[sos::S_PARAMS]["data"]["method"] = method.first + "." + method.second;
 
-    LOG4CXX_WARN(
-        logger_,
-        "DBus: Call of method " << method.first << "." << method.second << " returned error " << name.asInt() << ": " << description[rule.name].asString());
+    LOG4CXX_WARN(logger_,
+                 "DBus: Call of method " << method.first << "." << method.second
+                                         << " returned error " << name.asInt()
+                                         << ": "
+                                         << description[rule.name].asString());
   } else {
     LOG4CXX_ERROR(logger_, "DBus: Type message isn't error");
   }
@@ -453,11 +461,11 @@ bool DBusAdapter::ProcessSignal(DBusMessage* msg,
 
   obj[sos::S_PARAMS][sos::S_FUNCTION_ID] = m_id;
   obj[sos::S_PARAMS][sos::S_MESSAGE_TYPE] = hmi_apis::messageType::notification;
-  obj[sos::S_MSG_PARAMS] = smart_objects::SmartObject(
-      smart_objects::SmartType_Map);
+  obj[sos::S_MSG_PARAMS] =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
 
-  const ListArgs args = schema_->getListArgs(
-      name, hmi_apis::messageType::notification);
+  const ListArgs args =
+      schema_->getListArgs(name, hmi_apis::messageType::notification);
 
   DBusMessageIter iter;
   dbus_message_iter_init(msg, &iter);
@@ -466,7 +474,8 @@ bool DBusAdapter::ProcessSignal(DBusMessage* msg,
   return ret;
 }
 
-bool DBusAdapter::SetArguments(DBusMessage* msg, const ListArgs& rules,
+bool DBusAdapter::SetArguments(DBusMessage* msg,
+                               const ListArgs& rules,
                                const smart_objects::SmartObject& args) {
   DBusMessageIter iter;
   dbus_message_iter_init_append(msg, &iter);
@@ -500,7 +509,8 @@ bool DBusAdapter::SetValue(
     DBusMessageIter* iter,
     const ford_message_descriptions::ParameterDescription* rules,
     const smart_objects::SmartObject& param) {
-  // LOG4CXX_DEBUG(logger_, "DBus: Set param " << rules->name << " = " << param.asString());
+  // LOG4CXX_DEBUG(logger_, "DBus: Set param " << rules->name << " = " <<
+  // param.asString());
   int type = 0;
   void* value = 0;
   dbus_int32_t integerValue = 0;
@@ -511,13 +521,15 @@ bool DBusAdapter::SetValue(
     case ford_message_descriptions::ParameterType::Array:
       return SetArrayValue(
           iter,
-          reinterpret_cast<const ford_message_descriptions::ArrayDescription*>(rules),
+          reinterpret_cast<const ford_message_descriptions::ArrayDescription*>(
+              rules),
           param);
       break;
     case ford_message_descriptions::ParameterType::Struct:
       return SetStructValue(
           iter,
-          reinterpret_cast<const ford_message_descriptions::StructDescription*>(rules),
+          reinterpret_cast<const ford_message_descriptions::StructDescription*>(
+              rules),
           param);
       break;
     case ford_message_descriptions::ParameterType::Enum:
@@ -542,8 +554,7 @@ bool DBusAdapter::SetValue(
       value = &stringValue;
       break;
     default:
-      LOG4CXX_ERROR(logger_, "DBus: Unknown type of argument")
-      ;
+      LOG4CXX_ERROR(logger_, "DBus: Unknown type of argument");
       return false;
   }
   return dbus_message_iter_append_basic(iter, type, value);
@@ -552,22 +563,22 @@ bool DBusAdapter::SetValue(
 bool DBusAdapter::SetOptionalValue(
     DBusMessageIter* iter,
     const ford_message_descriptions::ParameterDescription* rules,
-    const smart_objects::SmartObject &param) {
+    const smart_objects::SmartObject& param) {
   DBusMessageIter sub_iter;
-  if (!dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL,
-                                        &sub_iter)) {
+  if (!dbus_message_iter_open_container(
+          iter, DBUS_TYPE_STRUCT, NULL, &sub_iter)) {
     LOG4CXX_ERROR(
         logger_,
         "DBus: Can't open container type (STRUCT) for optional parameter");
     return false;
   }
 
-  ford_message_descriptions::ParameterDescription flagRules = { "flag",
-      ford_message_descriptions::Boolean, true };
-  smart_objects::SmartObject flag(
-      param.getType() != smart_objects::SmartType_Invalid);
-  if (!SetValue(&sub_iter, &flagRules, flag)
-      || !SetValue(&sub_iter, rules, param)) {
+  ford_message_descriptions::ParameterDescription flagRules = {
+      "flag", ford_message_descriptions::Boolean, true};
+  smart_objects::SmartObject flag(param.getType() !=
+                                  smart_objects::SmartType_Invalid);
+  if (!SetValue(&sub_iter, &flagRules, flag) ||
+      !SetValue(&sub_iter, rules, param)) {
     return false;
   }
 
@@ -585,15 +596,14 @@ bool DBusAdapter::SetArrayValue(
     const ford_message_descriptions::ArrayDescription* rules,
     const smart_objects::SmartObject& param) {
   smart_objects::SmartType type = param.getType();
-  if (type != smart_objects::SmartType_Array
-      && type != smart_objects::SmartType_Invalid) {
+  if (type != smart_objects::SmartType_Array &&
+      type != smart_objects::SmartType_Invalid) {
     LOG4CXX_ERROR(logger_, "DBus: SmartObject is not a map");
     return false;
   }
   DBusMessageIter sub_iter;
-  if (!dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
-                                        rules->element_dbus_signature,
-                                        &sub_iter)) {
+  if (!dbus_message_iter_open_container(
+          iter, DBUS_TYPE_ARRAY, rules->element_dbus_signature, &sub_iter)) {
     LOG4CXX_ERROR(logger_, "DBus: Can't open container type (ARRAY)");
     return false;
   }
@@ -615,22 +625,22 @@ bool DBusAdapter::SetStructValue(
     const ford_message_descriptions::StructDescription* rules,
     const smart_objects::SmartObject& structure) {
   smart_objects::SmartType type = structure.getType();
-  if (type != smart_objects::SmartType_Map
-      && type != smart_objects::SmartType_Invalid) {
+  if (type != smart_objects::SmartType_Map &&
+      type != smart_objects::SmartType_Invalid) {
     LOG4CXX_ERROR(logger_, "DBus: SmartObject is not a map");
     return false;
   }
   DBusMessageIter sub_iter;
-  if (!dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL,
-                                        &sub_iter)) {
+  if (!dbus_message_iter_open_container(
+          iter, DBUS_TYPE_STRUCT, NULL, &sub_iter)) {
     LOG4CXX_ERROR(logger_, "DBus: Can't open container type (STRUCT)");
     return false;
   }
   const ParameterDescription** entry;
   entry = rules->parameters;
   while (*entry != NULL) {
-    const smart_objects::SmartObject& param = structure.getElement(
-        (*entry)->name);
+    const smart_objects::SmartObject& param =
+        structure.getElement((*entry)->name);
     if (!SetOneArgument(&sub_iter, *entry, param)) {
       return false;
     }
@@ -643,7 +653,8 @@ bool DBusAdapter::SetStructValue(
   return true;
 }
 
-bool DBusAdapter::GetHeader(DBusMessageIter* iter, int* code,
+bool DBusAdapter::GetHeader(DBusMessageIter* iter,
+                            int* code,
                             std::string* message) {
   // Get code of response
   dbus_int32_t intValue;
@@ -673,7 +684,8 @@ bool DBusAdapter::GetHeader(DBusMessageIter* iter, int* code,
   return true;
 }
 
-bool DBusAdapter::GetArguments(DBusMessageIter* iter, const ListArgs& rules,
+bool DBusAdapter::GetArguments(DBusMessageIter* iter,
+                               const ListArgs& rules,
                                smart_objects::SmartObject& args) {
   LOG4CXX_AUTO_TRACE(logger_);
 
@@ -714,7 +726,8 @@ bool DBusAdapter::GetValue(
         return GetArrayValue(
             iter,
             // FIXME (dchmerev@luxoft.com): not portable, danger cast.
-            reinterpret_cast<const ford_message_descriptions::ArrayDescription*>(rules),
+            reinterpret_cast<
+                const ford_message_descriptions::ArrayDescription*>(rules),
             param);
       } else {
         LOG4CXX_ERROR(logger_, "DBus: Not expected type of argument");
@@ -725,7 +738,8 @@ bool DBusAdapter::GetValue(
       if (type == DBUS_TYPE_STRUCT) {
         return GetStructValue(
             iter,
-            reinterpret_cast<const ford_message_descriptions::StructDescription*>(rules),
+            reinterpret_cast<
+                const ford_message_descriptions::StructDescription*>(rules),
             param);
       } else {
         LOG4CXX_ERROR(logger_, "DBus: Not expected type of argument");
@@ -739,7 +753,8 @@ bool DBusAdapter::GetValue(
         dbus_message_iter_get_basic(iter, &integerValue);
         smart_objects::SmartObject value(integerValue);
         param = value;
-        LOG4CXX_DEBUG(logger_, "DBus: " << rules->name << " = " << integerValue);
+        LOG4CXX_DEBUG(logger_,
+                      "DBus: " << rules->name << " = " << integerValue);
       } else {
         LOG4CXX_ERROR(logger_, "DBus: Not expected type of argument");
         return false;
@@ -763,9 +778,9 @@ bool DBusAdapter::GetValue(
         dbus_message_iter_get_basic(iter, &booleanValue);
         smart_objects::SmartObject value(static_cast<bool>(booleanValue));
         param = value;
-        LOG4CXX_DEBUG(
-            logger_,
-            "DBus: " << rules->name << " = " << std::boolalpha << booleanValue);
+        LOG4CXX_DEBUG(logger_,
+                      "DBus: " << rules->name << " = " << std::boolalpha
+                               << booleanValue);
       } else {
         LOG4CXX_ERROR(logger_, "DBus: Not expected type of argument");
         return false;
@@ -786,8 +801,7 @@ bool DBusAdapter::GetValue(
       }
       break;
     default:
-      LOG4CXX_ERROR(logger_, "DBus: Unknown type of argument")
-      ;
+      LOG4CXX_ERROR(logger_, "DBus: Unknown type of argument");
       return false;
   }
   return true;
@@ -817,7 +831,6 @@ bool DBusAdapter::GetStructValue(
     DBusMessageIter* iter,
     const ford_message_descriptions::StructDescription* rules,
     smart_objects::SmartObject& param) {
-
   DBusMessageIter sub_iter;
   dbus_message_iter_recurse(iter, &sub_iter);
   const ParameterDescription** entry;
@@ -840,14 +853,16 @@ bool DBusAdapter::GetOptionalValue(
     smart_objects::SmartObject& param) {
   int type = dbus_message_iter_get_arg_type(iter);
   if (type != DBUS_TYPE_STRUCT) {
-    LOG4CXX_WARN(logger_, "DBus: Not expected type of argument. It is not optional parameter.");
+    LOG4CXX_WARN(
+        logger_,
+        "DBus: Not expected type of argument. It is not optional parameter.");
     return false;
   }
 
   DBusMessageIter sub_iter;
   dbus_message_iter_recurse(iter, &sub_iter);
-  ford_message_descriptions::ParameterDescription flagRules = { "flag",
-      ford_message_descriptions::Boolean, true };
+  ford_message_descriptions::ParameterDescription flagRules = {
+      "flag", ford_message_descriptions::Boolean, true};
   smart_objects::SmartObject flag;
   if (!GetValue(&sub_iter, &flagRules, flag)) {
     return false;
@@ -877,7 +892,7 @@ void DBusAdapter::SaveRequestToHMI(uint32_t serial,
 }
 
 void DBusAdapter::Introspect(DBusMessage* msg) {
-  DBusMessage *reply;
+  DBusMessage* reply;
 
   dbus_uint32_t serial = dbus_message_get_serial(msg);
   reply = dbus_message_new_method_return(msg);
@@ -907,7 +922,7 @@ DBusMessage* DBusAdapter::GetRequestFromHMI(uint32_t serial) {
   std::map<uint32_t, DBusMessage*>::iterator it;
   it = requests_from_hmi_.find(serial);
   if (it != requests_from_hmi_.end()) {
-    DBusMessage *msg = it->second;
+    DBusMessage* msg = it->second;
     requests_from_hmi_.erase(it);
     LOG4CXX_DEBUG(logger_, "D-Bus message: " << msg);
     return msg;
diff --git a/src/components/dbus/src/dbus_message.cc b/src/components/dbus/src/dbus_message.cc
index 702e44f801..b8a55896ce 100644
--- a/src/components/dbus/src/dbus_message.cc
+++ b/src/components/dbus/src/dbus_message.cc
@@ -38,12 +38,10 @@
 
 namespace dbus {
 
-MessageRefKeeper::MessageRefKeeper()
-  : raw_message_(NULL) {
-}
+MessageRefKeeper::MessageRefKeeper() : raw_message_(NULL) {}
 
 MessageRefKeeper::MessageRefKeeper(DBusMessage* message)
-  : raw_message_(message) {
+    : raw_message_(message) {
   assert(raw_message_);
   dbus_message_ref(raw_message_);
 }
@@ -55,7 +53,7 @@ MessageRefKeeper::~MessageRefKeeper() {
 }
 
 MessageRefKeeper::MessageRefKeeper(const MessageRefKeeper& other)
-  : raw_message_(other.raw_message_) {
+    : raw_message_(other.raw_message_) {
   assert(raw_message_);
   dbus_message_ref(raw_message_);
 }
@@ -79,13 +77,9 @@ void MessageRefKeeper::swap(MessageRefKeeper& other) {
   std::swap(raw_message_, other.raw_message_);
 }
 
+MessageRef::MessageRef(DBusMessage* message) : raw_message_ref_(message) {}
 
-MessageRef::MessageRef(DBusMessage* message)
-  : raw_message_ref_(message) {
-}
-
-MessageRef::~MessageRef(){
-}
+MessageRef::~MessageRef() {}
 
 std::string MessageRef::GetInterface() const {
   return dbus_message_get_interface(raw_message_ref_.get());
@@ -97,11 +91,9 @@ std::string MessageRef::GetMember() const {
 
 // Message writer
 MessageReader::MessageReader(const MessageRef& message)
-  : parent_reader_(NULL),
-    failed_(false) {
+    : parent_reader_(NULL), failed_(false) {
   dbus_bool_t success =
-      dbus_message_iter_init(message.raw_message_ref_.get(),
-                             &iterator_);
+      dbus_message_iter_init(message.raw_message_ref_.get(), &iterator_);
   if (!success) {
     MarkFailed();
   }
@@ -109,8 +101,7 @@ MessageReader::MessageReader(const MessageRef& message)
 
 MessageReader::MessageReader(MessageReader* reader,
                              DataType container_data_type)
-  : parent_reader_(reader),
-    failed_(reader->has_failed()) {
+    : parent_reader_(reader), failed_(reader->has_failed()) {
   assert(parent_reader_);
   if (!failed_) {
     if (reader->NextValueType() != container_data_type) {
@@ -122,12 +113,10 @@ MessageReader::MessageReader(MessageReader* reader,
   }
 }
 
-
 bool MessageReader::NextIsDictEntry() const {
   return NextValueType() == DBUS_TYPE_DICT_ENTRY;
 }
 
-
 MessageReader MessageReader::TakeArrayReader() {
   return MessageReader(this, DBUS_TYPE_ARRAY);
 }
@@ -156,8 +145,7 @@ void MessageReader::MarkFailed() {
   }
 }
 
-void MessageReader::ReadNextValue(MessageReader::DataType type,
-                                  void* value) {
+void MessageReader::ReadNextValue(MessageReader::DataType type, void* value) {
   assert(value);
   if (NextValueType() != type) {
     MarkFailed();
@@ -169,28 +157,21 @@ void MessageReader::ReadNextValue(MessageReader::DataType type,
 
 // DbusMessageWriter
 MessageWriter::MessageWriter(const MessageRef& message)
-  : has_opened_subcontainer_(false),
-    parent_writer_(NULL) {
-  dbus_message_iter_init_append(message.raw_message_ref_.get(),
-                                &iterator_);
-}
-
-MessageWriter::MessageWriter(
-    MessageWriter* parent,
-    ContainerType container_type,
-    const char* array_signature)
-  : has_opened_subcontainer_(false),
-    parent_writer_(parent) {
+    : has_opened_subcontainer_(false), parent_writer_(NULL) {
+  dbus_message_iter_init_append(message.raw_message_ref_.get(), &iterator_);
+}
+
+MessageWriter::MessageWriter(MessageWriter* parent,
+                             ContainerType container_type,
+                             const char* array_signature)
+    : has_opened_subcontainer_(false), parent_writer_(parent) {
   assert(parent_writer_);
   // Only array writers require array_signature
-  assert((container_type == kArray && array_signature != NULL)
-         || (container_type != kArray && array_signature == NULL));
+  assert((container_type == kArray && array_signature != NULL) ||
+         (container_type != kArray && array_signature == NULL));
   assert(!parent_writer_->has_opened_subcontainer_);
-  bool enough_memory =
-      dbus_message_iter_open_container(&parent_writer_->iterator_,
-                                       container_type,
-                                       array_signature,
-                                       &iterator_);
+  bool enough_memory = dbus_message_iter_open_container(
+      &parent_writer_->iterator_, container_type, array_signature, &iterator_);
   assert(enough_memory);
   parent_writer_->has_opened_subcontainer_ = true;
 }
@@ -202,8 +183,8 @@ MessageWriter::~MessageWriter() {
   }
 }
 
-void MessageWriter::WriteAndCheck(
-    MessageWriter::DataType value_type, const void* value) {
+void MessageWriter::WriteAndCheck(MessageWriter::DataType value_type,
+                                  const void* value) {
   assert(!has_opened_subcontainer_);
   dbus_bool_t enough_memory =
       dbus_message_iter_append_basic(&iterator_, value_type, value);
@@ -214,8 +195,7 @@ void MessageWriter::CloseWriter() {
   assert(parent_writer_);
   assert(parent_writer_->has_opened_subcontainer_);
   dbus_bool_t enough_memory =
-      dbus_message_iter_close_container(&parent_writer_->iterator_,
-                                        &iterator_);
+      dbus_message_iter_close_container(&parent_writer_->iterator_, &iterator_);
   assert(enough_memory);
   parent_writer_->has_opened_subcontainer_ = false;
 }
@@ -226,18 +206,12 @@ MessageRef MethodCall(const char* bus_name,
                       const char* path,
                       const char* interface,
                       const char* method) {
-  return MessageRef(dbus_message_new_method_call(
-                      bus_name,
-                      path,
-                      interface,
-                      method));
+  return MessageRef(
+      dbus_message_new_method_call(bus_name, path, interface, method));
 }
 
-MessageRef Signal(const char* path,
-                  const char* interface,
-                  const char* name) {
+MessageRef Signal(const char* path, const char* interface, const char* name) {
   return MessageRef(dbus_message_new_signal(path, interface, name));
 }
 
-
-} // namespace dbus
+}  // namespace dbus
diff --git a/src/components/dbus/src/dbus_message_controller.cc b/src/components/dbus/src/dbus_message_controller.cc
index 56efe67905..166037e900 100644
--- a/src/components/dbus/src/dbus_message_controller.cc
+++ b/src/components/dbus/src/dbus_message_controller.cc
@@ -41,22 +41,30 @@ DBusMessageController::DBusMessageController(const std::string& sdlServiceName,
                                              const std::string& sdlObjectPath,
                                              const std::string& hmiServiceName,
                                              const std::string& hmiObjectPath)
-    : DBusAdapter(sdlServiceName, sdlObjectPath,
-                  hmiServiceName, hmiObjectPath) {}
+    : DBusAdapter(
+          sdlServiceName, sdlObjectPath, hmiServiceName, hmiObjectPath) {}
 
 void DBusMessageController::SubscribeTo(const std::string& interface,
                                         const std::string& signal) {
   std::string rule = "type='signal'";
-  rule.append(", sender='").append(hmi_service_name_).append("'")
-      .append(", path='").append(hmi_object_path_).append("'")
-      .append(", interface='").append(hmi_service_name_).append(".")
-      .append(interface).append("'")
-      .append(", member='").append(signal).append("'");
+  rule.append(", sender='")
+      .append(hmi_service_name_)
+      .append("'")
+      .append(", path='")
+      .append(hmi_object_path_)
+      .append("'")
+      .append(", interface='")
+      .append(hmi_service_name_)
+      .append(".")
+      .append(interface)
+      .append("'")
+      .append(", member='")
+      .append(signal)
+      .append("'");
   DBusAdapter::AddMatch(rule);
 }
 
-DBusMessageController::~DBusMessageController() {
-}
+DBusMessageController::~DBusMessageController() {}
 
 void* DBusMessageController::MethodForReceiverThread(void*) {
   while (true) {
diff --git a/src/components/dbus/src/schema.cc b/src/components/dbus/src/schema.cc
index 157479928d..3107d9ce6c 100644
--- a/src/components/dbus/src/schema.cc
+++ b/src/components/dbus/src/schema.cc
@@ -44,35 +44,32 @@ struct Description {
 };
 
 struct IsId : public std::unary_function<const Description*, bool> {
-  explicit IsId(MessageId id)
-      : id_(id) {
-  }
+  explicit IsId(MessageId id) : id_(id) {}
   bool operator()(const Description* desc) {
     return desc->id == id_;
   }
+
  private:
   MessageId id_;
 };
 
 struct IsName : public std::unary_function<const Description*, bool> {
-  explicit IsName(const MessageName& name)
-      : name_(name) {
-  }
+  explicit IsName(const MessageName& name) : name_(name) {}
   bool operator()(const Description* desc) {
     return desc->name == name_;
   }
+
  private:
   MessageName name_;
 };
 
 struct IsIdType : public std::unary_function<const Description*, bool> {
   explicit IsIdType(const MessageId& id, const MessageType& type)
-      : id_(id),
-        type_(type) {
-  }
+      : id_(id), type_(type) {}
   bool operator()(const Description* desc) {
     return desc->id == id_ && desc->type == type_;
   }
+
  private:
   MessageId id_;
   MessageType type_;
@@ -80,12 +77,11 @@ struct IsIdType : public std::unary_function<const Description*, bool> {
 
 struct IsNameType : public std::unary_function<const Description*, bool> {
   explicit IsNameType(const MessageName& name, const MessageType& type)
-      : name_(name),
-        type_(type) {
-  }
+      : name_(name), type_(type) {}
   bool operator()(const Description* desc) {
     return desc->name == name_ && desc->type == type_;
   }
+
  private:
   MessageName name_;
   MessageType type_;
@@ -94,7 +90,7 @@ struct IsNameType : public std::unary_function<const Description*, bool> {
 DBusSchema::DBusSchema(const MessageDescription** array) {
   const MessageDescription** msg = array;
   while (*msg != NULL) {
-    Description *desc = new Description();
+    Description* desc = new Description();
     desc->id = (*msg)->function_id;
     desc->name = std::make_pair((*msg)->interface, (*msg)->name);
     desc->type = (*msg)->message_type;
@@ -110,8 +106,8 @@ DBusSchema::DBusSchema(const MessageDescription** array) {
 }
 
 MessageName DBusSchema::getMessageName(MessageId id) const {
-  Messages::const_iterator it = std::find_if(msgs_.begin(), msgs_.end(),
-                                             IsId(id));
+  Messages::const_iterator it =
+      std::find_if(msgs_.begin(), msgs_.end(), IsId(id));
   if (msgs_.end() != it) {
     return (*it)->name;
   }
@@ -119,8 +115,8 @@ MessageName DBusSchema::getMessageName(MessageId id) const {
 }
 
 MessageId DBusSchema::getMessageId(const MessageName& name) const {
-  Messages::const_iterator it = std::find_if(msgs_.begin(), msgs_.end(),
-                                             IsName(name));
+  Messages::const_iterator it =
+      std::find_if(msgs_.begin(), msgs_.end(), IsName(name));
   if (msgs_.end() != it) {
     return (*it)->id;
   }
@@ -128,8 +124,8 @@ MessageId DBusSchema::getMessageId(const MessageName& name) const {
 }
 
 ListArgs DBusSchema::getListArgs(MessageId id, MessageType type) const {
-  Messages::const_iterator it = std::find_if(msgs_.begin(), msgs_.end(),
-                                             IsIdType(id, type));
+  Messages::const_iterator it =
+      std::find_if(msgs_.begin(), msgs_.end(), IsIdType(id, type));
   if (msgs_.end() != it) {
     return (*it)->args;
   }
@@ -138,8 +134,8 @@ ListArgs DBusSchema::getListArgs(MessageId id, MessageType type) const {
 
 ListArgs DBusSchema::getListArgs(const MessageName& name,
                                  MessageType type) const {
-  Messages::const_iterator it = std::find_if(msgs_.begin(), msgs_.end(),
-                                             IsNameType(name, type));
+  Messages::const_iterator it =
+      std::find_if(msgs_.begin(), msgs_.end(), IsNameType(name, type));
   if (msgs_.end() != it) {
     return (*it)->args;
   }
diff --git a/src/components/dbus/test/test_dbus_adapter.cc b/src/components/dbus/test/test_dbus_adapter.cc
index c5922dfdcb..74a6de1aa9 100644
--- a/src/components/dbus/test/test_dbus_adapter.cc
+++ b/src/components/dbus/test/test_dbus_adapter.cc
@@ -42,20 +42,18 @@ namespace test {
 namespace components {
 namespace dbus {
 
-class DBusAdapterTest : public ::testing::Test {
-};
+class DBusAdapterTest : public ::testing::Test {};
 
 TEST_F(DBusAdapterTest, Initialization) {
   const std::string kSdlServiceName = "test.ford.sdl.core";
   const std::string kSdlObjectPath = "/";
   const std::string kHmiServiceName = "test.ford.sdl.hmi";
   const std::string kHmiObjectPath = "/";
-  ::dbus::DBusAdapter adapter(kSdlServiceName, kSdlObjectPath,
-                            kHmiServiceName, kHmiObjectPath);
+  ::dbus::DBusAdapter adapter(
+      kSdlServiceName, kSdlObjectPath, kHmiServiceName, kHmiObjectPath);
   EXPECT_TRUE(adapter.Init());
 }
 
 }  // namespace dbus
 }  // namespace components
 }  // namespace test
-
diff --git a/src/components/dbus/test/test_schema.cc b/src/components/dbus/test/test_schema.cc
index ecbd4b1bfd..37831279b9 100644
--- a/src/components/dbus/test/test_schema.cc
+++ b/src/components/dbus/test/test_schema.cc
@@ -103,7 +103,8 @@ TEST_F(DBusSchemaTest, GetListArg) {
 
   const MessageId kIdWrong = static_cast<const MessageId>(test_negative_value);
   const MessageName kNameWrong("TestInterface", "TestMessage");
-  const MessageType kTypeWrong = static_cast<const MessageType>(test_negative_value);
+  const MessageType kTypeWrong =
+      static_cast<const MessageType>(test_negative_value);
   const ListArgs kExpListWrong;
   argsName = schema_->getListArgs(kNameWrong, kTypeWrong);
   EXPECT_EQ(kExpListWrong, argsName);
@@ -115,5 +116,3 @@ TEST_F(DBusSchemaTest, GetListArg) {
 }  // namespace dbus
 }  // namespace components
 }  // namespace test
-
-