Fix coding rule of request handlers

Signed-off-by: Junghyun Yeon <jungh.yeon@samsung.com>

diff --git a/src/common/request_handler/abstract_request_handler.cc b/src/common/request_handler/abstract_request_handler.cc
index 63d7e63..4f00260 100644 (file)
--- a/src/common/request_handler/abstract_request_handler.cc
+++ b/src/common/request_handler/abstract_request_handler.cc
@@ -4,10 +4,10 @@
 
 #include "abstract_request_handler.hh"
 
-#include "pkgmgrinfo_debug.h"
-
 #include <string>
 
+#include "pkgmgrinfo_debug.h"
+
 namespace pkgmgr_server {
 namespace request_handler {
 

diff --git a/src/common/request_handler/command_request_handler.cc b/src/common/request_handler/command_request_handler.cc
index a744576..1817cc5 100644 (file)
--- a/src/common/request_handler/command_request_handler.cc
+++ b/src/common/request_handler/command_request_handler.cc
@@ -3,41 +3,47 @@
 // found in the LICENSE file.
 
 #include "command_request_handler.hh"
+
+#include <string>
+
+#include "db_handle_provider.hh"
 #include "parcelable_factory.hh"
 #include "pkginfo_parcelable.hh"
-#include "db_handle_provider.hh"
 
 #include "pkgmgrinfo_debug.h"
 
-#include <string>
-
-using namespace pkgmgr_common::parcel;
-using namespace pkgmgr_common::database;
+namespace pcp = pkgmgr_common::parcel;
+namespace pcd = pkgmgr_common::database;
 
 namespace pkgmgr_server {
 namespace request_handler {
 
 bool CommandRequestHandler::HandleRequest(unsigned char* data, int size,
                                              std::string locale) {
-  auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+  auto abstract_parcel =
+      pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 
   if (abstract_parcel == nullptr ||
-      abstract_parcel->GetType() != ParcelableType::Command) {
+      abstract_parcel->GetType() != pcp::ParcelableType::Command) {
     _LOGE("Invalid parcel or type");
-    result_ = std::make_shared<ResultParcelable>(PMINFO_R_ERROR, std::vector<std::vector<std::string>>{});
+    result_ = std::make_shared<pcp::ResultParcelable>(
+        PMINFO_R_ERROR, std::vector<std::vector<std::string>>{});
     return false;
   }
 
-  auto* parcel = dynamic_cast<CommandParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<pcp::CommandParcelable*>(abstract_parcel.get());
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
-    result_ = std::make_shared<ResultParcelable>(PMINFO_R_ERROR, std::vector<std::vector<std::string>>{});
+    result_ = std::make_shared<pcp::ResultParcelable>(
+        PMINFO_R_ERROR, std::vector<std::vector<std::string>>{});
     return false;
   }
 
   if (parcel->GetCmd() == CommandType::RemoveCache) {
-    pkgmgr_common::DBHandleProvider::GetInst(parcel->GetUid()).SetMemoryMode(GetPID(), false);
-    result_ = std::make_shared<ResultParcelable>(PMINFO_R_OK, std::vector<std::vector<std::string>>{});
+    pkgmgr_common::DBHandleProvider::GetInst(
+        parcel->GetUid()).SetMemoryMode(GetPID(), false);
+    result_ = std::make_shared<pcp::ResultParcelable>(
+        PMINFO_R_OK, std::vector<std::vector<std::string>>{});
     return true;
   }
 

diff --git a/src/common/request_handler/get_appinfo_request_handler.cc b/src/common/request_handler/get_appinfo_request_handler.cc
index 9d7397e..be125c4 100644 (file)
--- a/src/common/request_handler/get_appinfo_request_handler.cc
+++ b/src/common/request_handler/get_appinfo_request_handler.cc
@@ -2,49 +2,51 @@
 // Use of this source code is governed by an apache-2.0 license that can be
 // found in the LICENSE file.
 
+#include "get_appinfo_request_handler.hh"
+
+#include <string>
+
 #include "parcelable_factory.hh"
 #include "filter_parcelable.hh"
 #include "appinfo_db_handler.hh"
-#include "get_appinfo_request_handler.hh"
 
 #include "pkgmgrinfo_debug.h"
 
-#include <string>
-
-using namespace pkgmgr_common::parcel;
-using namespace pkgmgr_common::database;
+namespace pcp = pkgmgr_common::parcel;
+namespace pcd = pkgmgr_common::database;
 
 namespace pkgmgr_server {
 namespace request_handler {
 
 bool GetAppinfoRequestHandler::HandleRequest(unsigned char* data, int size,
                                              std::string locale) {
-  auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+  auto abstract_parcel =
+      pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 
   if (abstract_parcel == nullptr ||
-      abstract_parcel->GetType() != ParcelableType::Filter) {
+      abstract_parcel->GetType() != pcp::ParcelableType::Filter) {
     _LOGE("Invalid parcel or type");
-    result_ = std::make_shared<AppInfoParcelable>(
+    result_ = std::make_shared<pcp::AppInfoParcelable>(
         PMINFO_R_ERROR, std::vector<application_x*>{});
     return false;
   }
 
-  auto* parcel = dynamic_cast<FilterParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<pcp::FilterParcelable*>(abstract_parcel.get());
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
-    result_ = std::make_shared<AppInfoParcelable>(
+    result_ = std::make_shared<pcp::AppInfoParcelable>(
         PMINFO_R_ERROR, std::vector<application_x*>{});
     return false;
   }
 
-  AppInfoDBHandler db(parcel->GetUid(), GetPID());
+  pcd::AppInfoDBHandler db(parcel->GetUid(), GetPID());
   db.SetLocale(locale);
   db.SetFilter(const_cast<pkgmgrinfo_filter_x*>(parcel->GetFilter()));
   int ret = db.Execute();
   if (ret < 0)
     _LOGE("Failed to execute");
 
-  result_ = std::make_shared<AppInfoParcelable>(ret, db.GetAppHandle());
+  result_ = std::make_shared<pcp::AppInfoParcelable>(ret, db.GetAppHandle());
 
   return true;
 }

diff --git a/src/common/request_handler/get_cert_request_handler.cc b/src/common/request_handler/get_cert_request_handler.cc
index 8c72701..b4caae8 100644 (file)
--- a/src/common/request_handler/get_cert_request_handler.cc
+++ b/src/common/request_handler/get_cert_request_handler.cc
@@ -3,46 +3,48 @@
 // found in the LICENSE file.
 
 #include "get_cert_request_handler.hh"
-#include "parcelable_factory.hh"
+
+#include <string>
+
 #include "cert_get_db_handler.hh"
+#include "parcelable_factory.hh"
 
 #include "pkgmgrinfo_debug.h"
 
-#include <string>
-
-using namespace pkgmgr_common::parcel;
-using namespace pkgmgr_common::database;
+namespace pcp = pkgmgr_common::parcel;
+namespace pcd = pkgmgr_common::database;
 
 namespace pkgmgr_server {
 namespace request_handler {
 
 bool GetCertRequestHandler::HandleRequest(unsigned char* data, int size,
                                           std::string locale) {
-  auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+  auto abstract_parcel =
+      pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 
   if (abstract_parcel == nullptr ||
-      abstract_parcel->GetType() != ParcelableType::CertInfo) {
+      abstract_parcel->GetType() != pcp::ParcelableType::CertInfo) {
     _LOGE("Invalid parcel or type");
-    result_ = std::make_shared<CertInfoParcelable>(
+    result_ = std::make_shared<pcp::CertInfoParcelable>(
         PMINFO_R_ERROR, nullptr);
     return false;
   }
 
-  auto* parcel = dynamic_cast<CertInfoParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<pcp::CertInfoParcelable*>(abstract_parcel.get());
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
-    result_ = std::make_shared<CertInfoParcelable>(
+    result_ = std::make_shared<pcp::CertInfoParcelable>(
         PMINFO_R_ERROR, nullptr);
     return false;
   }
 
-  CertGetDBHandler db(parcel->GetUid(), GetPID());
+  pcd::CertGetDBHandler db(parcel->GetUid(), GetPID());
   db.SetLocale(locale);
   db.SetPkgID(parcel->GetPkgId());
 
   int ret = db.Execute();
 
-  result_ = std::make_shared<CertInfoParcelable>(ret, db.GetCertHandle());
+  result_ = std::make_shared<pcp::CertInfoParcelable>(ret, db.GetCertHandle());
 
   return true;
 }

diff --git a/src/common/request_handler/get_depinfo_request_handler.cc b/src/common/request_handler/get_depinfo_request_handler.cc
index 83df088..3921117 100644 (file)
--- a/src/common/request_handler/get_depinfo_request_handler.cc
+++ b/src/common/request_handler/get_depinfo_request_handler.cc
@@ -2,46 +2,49 @@
 // Use of this source code is governed by an apache-2.0 license that can be
 // found in the LICENSE file.
 
-#include "parcelable_factory.hh"
-#include "depinfo_parcelable.hh"
-#include "depinfo_db_handler.hh"
 #include "get_depinfo_request_handler.hh"
 
-#include "pkgmgrinfo_debug.h"
-
 #include <string>
 
-using namespace pkgmgr_common::parcel;
-using namespace pkgmgr_common::database;
+#include "depinfo_db_handler.hh"
+#include "depinfo_parcelable.hh"
+#include "parcelable_factory.hh"
+
+#include "pkgmgrinfo_debug.h"
+
+namespace pcp = pkgmgr_common::parcel;
+namespace pcd = pkgmgr_common::database;
 
 namespace pkgmgr_server {
 namespace request_handler {
 
 bool GetDepinfoRequestHandler::HandleRequest(unsigned char* data, int size,
                                              std::string locale) {
-  auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+  auto abstract_parcel =
+      pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 
   if (abstract_parcel == nullptr ||
-      abstract_parcel->GetType() != ParcelableType::DepInfo) {
+      abstract_parcel->GetType() != pcp::ParcelableType::DepInfo) {
     _LOGE("Invalid parcel or type");
-    result_ = std::make_shared<DepInfoParcelable>(
+    result_ = std::make_shared<pcp::DepInfoParcelable>(
         PMINFO_R_ERROR, std::vector<dependency_x*>{});
     return false;
   }
 
-  auto* parcel = dynamic_cast<DepInfoParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<pcp::DepInfoParcelable*>(abstract_parcel.get());
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
-    result_ = std::make_shared<DepInfoParcelable>(
+    result_ = std::make_shared<pcp::DepInfoParcelable>(
         PMINFO_R_ERROR, std::vector<dependency_x*>{});
     return false;
   }
 
-  DepInfoGetDBHandler db(parcel->GetUid(), GetPID());
+  pcd::DepInfoGetDBHandler db(parcel->GetUid(), GetPID());
   db.SetPkgID(parcel->GetPkgID());
   int ret = db.Execute();
 
-  result_ = std::make_shared<DepInfoParcelable>(ret, db.GetDependencyList());
+  result_ = std::make_shared<pcp::DepInfoParcelable>(
+      ret, db.GetDependencyList());
   return true;
 }
 

diff --git a/src/common/request_handler/get_pkginfo_request_handler.cc b/src/common/request_handler/get_pkginfo_request_handler.cc
index 34935ea..c3d099a 100644 (file)
--- a/src/common/request_handler/get_pkginfo_request_handler.cc
+++ b/src/common/request_handler/get_pkginfo_request_handler.cc
@@ -2,47 +2,50 @@
 // Use of this source code is governed by an apache-2.0 license that can be
 // found in the LICENSE file.
 
+#include "get_pkginfo_request_handler.hh"
+
+#include <string>
+
 #include "parcelable_factory.hh"
-#include "filter_parcelable.hh"
 #include "pkg_get_db_handler.hh"
-#include "get_pkginfo_request_handler.hh"
+#include "filter_parcelable.hh"
 
 #include "pkgmgrinfo_debug.h"
 
-#include <string>
 
-using namespace pkgmgr_common::parcel;
-using namespace pkgmgr_common::database;
+namespace pcp = pkgmgr_common::parcel;
+namespace pcd = pkgmgr_common::database;
 
 namespace pkgmgr_server {
 namespace request_handler {
 
 bool GetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size,
                                              std::string locale) {
-  auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+  auto abstract_parcel =
+      pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 
   if (abstract_parcel == nullptr ||
-      abstract_parcel->GetType() != ParcelableType::Filter) {
+      abstract_parcel->GetType() != pcp::ParcelableType::Filter) {
     _LOGE("Invalid parcel or type");
-    result_ = std::make_shared<PkgInfoParcelable>(
+    result_ = std::make_shared<pcp::PkgInfoParcelable>(
         PMINFO_R_ERROR, std::vector<package_x*>{});
     return false;
   }
 
-  auto* parcel = dynamic_cast<FilterParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<pcp::FilterParcelable*>(abstract_parcel.get());
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
-    result_ = std::make_shared<PkgInfoParcelable>(
+    result_ = std::make_shared<pcp::PkgInfoParcelable>(
         PMINFO_R_ERROR, std::vector<package_x*>{});
     return false;
   }
 
-  PkgGetDBHandler db(parcel->GetUid(), GetPID());
+  pcd::PkgGetDBHandler db(parcel->GetUid(), GetPID());
   db.SetLocale(locale);
   db.SetFilter(const_cast<pkgmgrinfo_filter_x*>(parcel->GetFilter()));
   int ret = db.Execute();
 
-  result_ = std::make_shared<PkgInfoParcelable>(ret, db.GetPkgHandle());
+  result_ = std::make_shared<pcp::PkgInfoParcelable>(ret, db.GetPkgHandle());
 
   return true;
 }

diff --git a/src/common/request_handler/query_request_handler.cc b/src/common/request_handler/query_request_handler.cc
index 69ba132..9abb690 100644 (file)
--- a/src/common/request_handler/query_request_handler.cc
+++ b/src/common/request_handler/query_request_handler.cc
@@ -3,48 +3,50 @@
 // found in the LICENSE file.
 
 #include "query_request_handler.hh"
+
+#include <string>
+
 #include "parcelable_factory.hh"
-#include "query_parcelable.hh"
 #include "query_handler.hh"
+#include "query_parcelable.hh"
 
 #include "pkgmgrinfo_debug.h"
 
-#include <string>
-
-using namespace pkgmgr_common::parcel;
-using namespace pkgmgr_common::database;
+namespace pcp = pkgmgr_common::parcel;
+namespace pcd = pkgmgr_common::database;
 
 namespace pkgmgr_server {
 namespace request_handler {
 
 bool QueryRequestHandler::HandleRequest(unsigned char* data, int size,
                                         std::string locale) {
-  auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+  auto abstract_parcel =
+      pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 
   if (abstract_parcel == nullptr ||
-      abstract_parcel->GetType() != ParcelableType::Query) {
+      abstract_parcel->GetType() != pcp::ParcelableType::Query) {
     _LOGE("Invalid parcel or type");
-    result_ = std::make_shared<ResultParcelable>(
+    result_ = std::make_shared<pcp::ResultParcelable>(
         PMINFO_R_ERROR, std::vector<std::vector<std::string>>{});
     return false;
   }
 
-  auto* parcel = dynamic_cast<QueryParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<pcp::QueryParcelable*>(abstract_parcel.get());
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
-    result_ = std::make_shared<ResultParcelable>(
+    result_ = std::make_shared<pcp::ResultParcelable>(
         PMINFO_R_ERROR, std::vector<std::vector<std::string>>{});
     return false;
   }
 
-  QueryHandler db(parcel->GetUid(), GetPID());
+  pcd::QueryHandler db(parcel->GetUid(), GetPID());
   db.SetLocale(locale);
   db.SetQuery(parcel->GetQueries());
   db.SetDBType(parcel->GetDBType());
   db.SetOpType(parcel->GetOpType());
   int ret = db.Execute();
 
-  result_ = std::make_shared<ResultParcelable>(ret, db.GetResult());
+  result_ = std::make_shared<pcp::ResultParcelable>(ret, db.GetResult());
 
   return true;
 }

diff --git a/src/common/request_handler/set_cert_request_handler.cc b/src/common/request_handler/set_cert_request_handler.cc
index ce14822..5c0dee5 100644 (file)
--- a/src/common/request_handler/set_cert_request_handler.cc
+++ b/src/common/request_handler/set_cert_request_handler.cc
@@ -3,41 +3,44 @@
 // found in the LICENSE file.
 
 #include "set_cert_request_handler.hh"
-#include "parcelable_factory.hh"
-#include "certinfo_parcelable.hh"
-#include "cert_set_db_handler.hh"
 
 #include <string>
 
-using namespace pkgmgr_common::parcel;
-using namespace pkgmgr_common::database;
+#include "certinfo_parcelable.hh"
+#include "cert_set_db_handler.hh"
+#include "parcelable_factory.hh"
+
+namespace pcp = pkgmgr_common::parcel;
+namespace pcd = pkgmgr_common::database;
 
 namespace pkgmgr_server {
 namespace request_handler {
 
 bool SetCertRequestHandler::HandleRequest(unsigned char* data, int size,
                                           std::string locale) {
-  auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+  auto abstract_parcel =
+      pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 
   if (abstract_parcel == nullptr ||
-      abstract_parcel->GetType() != ParcelableType::CertInfo) {
-    //need to set result
+      abstract_parcel->GetType() != pcp::ParcelableType::CertInfo) {
+    // TODO: need to set result
     return false;
   }
 
-  auto* parcel = dynamic_cast<CertInfoParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<pcp::CertInfoParcelable*>(abstract_parcel.get());
   if (parcel == nullptr) {
-    //need to set result
+    // TODO: need to set result
     return false;
   }
 
-  CertSetDBHandler db(parcel->GetUid(), GetPID());
+  pcd::CertSetDBHandler db(parcel->GetUid(), GetPID());
   db.SetLocale(locale);
   db.SetCertHandle(const_cast<pkgmgr_certinfo_x*>(parcel->GetCertInfo()));
 
   int ret = db.Execute();
-  result_ = std::make_shared<ResultParcelable>(ret, std::vector<std::vector<std::string>>{});
-  //need to set result
+  result_ = std::make_shared<pcp::ResultParcelable>(
+      ret, std::vector<std::vector<std::string>>{});
+  // TODO: need to set result
 
   return true;
 }

diff --git a/src/common/request_handler/set_pkginfo_request_handler.cc b/src/common/request_handler/set_pkginfo_request_handler.cc
index df69d44..05edd0e 100644 (file)
--- a/src/common/request_handler/set_pkginfo_request_handler.cc
+++ b/src/common/request_handler/set_pkginfo_request_handler.cc
@@ -3,42 +3,45 @@
 // found in the LICENSE file.
 
 #include "set_pkginfo_request_handler.hh"
+
+#include <string>
+
 #include "parcelable_factory.hh"
 #include "pkginfo_parcelable.hh"
 #include "pkg_set_db_handler.hh"
+
 #include "pkgmgr_parser.h"
 
 #include "pkgmgrinfo_debug.h"
 
-#include <string>
-
-using namespace pkgmgr_common::parcel;
-using namespace pkgmgr_common::database;
+namespace pcp = pkgmgr_common::parcel;
+namespace pcd = pkgmgr_common::database;
 
 namespace pkgmgr_server {
 namespace request_handler {
 
 bool SetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size,
                                              std::string locale) {
-  auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+  auto abstract_parcel =
+      pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 
   if (abstract_parcel == nullptr ||
-      abstract_parcel->GetType() != ParcelableType::PkgInfo) {
+      abstract_parcel->GetType() != pcp::ParcelableType::PkgInfo) {
     _LOGE("Invalid parcel or type");
-    result_ = std::make_shared<ResultParcelable>(
+    result_ = std::make_shared<pcp::ResultParcelable>(
         PM_PARSER_R_ERROR, std::vector<std::vector<std::string>>{});
     return false;
   }
 
-  auto* parcel = dynamic_cast<PkgInfoParcelable*>(abstract_parcel.get());
+  auto* parcel = dynamic_cast<pcp::PkgInfoParcelable*>(abstract_parcel.get());
   if (parcel == nullptr) {
     _LOGE("Parcel is empty");
-    result_ = std::make_shared<ResultParcelable>(
+    result_ = std::make_shared<pcp::ResultParcelable>(
         PM_PARSER_R_ERROR, std::vector<std::vector<std::string>>{});
     return false;
   }
 
-  PkgSetDBHandler db(parcel->GetUid(), GetPID());
+  pcd::PkgSetDBHandler db(parcel->GetUid(), GetPID());
   db.SetLocale(locale);
   db.SetWriteType(parcel->GetWriteType());
 
@@ -53,7 +56,8 @@ bool SetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size,
     }
   }
 
-  result_ = std::make_shared<ResultParcelable>(ret, std::vector<std::vector<std::string>>{});
+  result_ = std::make_shared<pcp::ResultParcelable>(
+      ret, std::vector<std::vector<std::string>>{});
 
   return true;
 }