<refactor>(src, test): Normalize the naming of partial classes

27 files changed, 136 insertions, 135 deletions

diff --git a/src/gpg/function/BasicOperator.cpp b/src/gpg/function/GpgBasicOperator.cpp
index afc37668..cf331907 100644
--- a/src/gpg/function/BasicOperator.cpp
+++ b/src/gpg/function/GpgBasicOperator.cpp
@@ -26,13 +26,13 @@
  *
  */
 
-#include "gpg/function/BasicOperator.h"
+#include "gpg/function/GpgBasicOperator.h"
 
 #include <vector>
 
 #include "gpg/function/GpgKeyGetter.h"
 
-GpgFrontend::GpgError GpgFrontend::BasicOperator::Encrypt(
+GpgFrontend::GpgError GpgFrontend::GpgBasicOperator::Encrypt(
     KeyListPtr keys, GpgFrontend::BypeArrayRef in_buffer,
     GpgFrontend::ByteArrayPtr& out_buffer, GpgFrontend::GpgEncrResult& result) {
   // gpgme_encrypt_result_t e_result;
@@ -58,7 +58,7 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Encrypt(
   return err;
 }
 
-GpgFrontend::GpgError GpgFrontend::BasicOperator::Decrypt(
+GpgFrontend::GpgError GpgFrontend::GpgBasicOperator::Decrypt(
     BypeArrayRef in_buffer, GpgFrontend::ByteArrayPtr& out_buffer,
     GpgFrontend::GpgDecrResult& result) {
   gpgme_error_t err;
@@ -75,7 +75,7 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Decrypt(
   return err;
 }
 
-GpgFrontend::GpgError GpgFrontend::BasicOperator::Verify(
+GpgFrontend::GpgError GpgFrontend::GpgBasicOperator::Verify(
     BypeArrayRef& in_buffer, ByteArrayPtr& sig_buffer,
     GpgVerifyResult& result) const {
   gpgme_error_t err;
@@ -95,7 +95,7 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Verify(
   return err;
 }
 
-GpgFrontend::GpgError GpgFrontend::BasicOperator::Sign(KeyListPtr signers,
+GpgFrontend::GpgError GpgFrontend::GpgBasicOperator::Sign(KeyListPtr signers,
                                                        BypeArrayRef in_buffer,
                                                        ByteArrayPtr& out_buffer,
                                                        gpgme_sig_mode_t mode,
@@ -119,7 +119,7 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Sign(KeyListPtr signers,
   return err;
 }
 
-gpgme_error_t GpgFrontend::BasicOperator::DecryptVerify(
+gpgme_error_t GpgFrontend::GpgBasicOperator::DecryptVerify(
     BypeArrayRef in_buffer, ByteArrayPtr& out_buffer,
     GpgDecrResult& decrypt_result, GpgVerifyResult& verify_result) {
   gpgme_error_t err;
@@ -140,7 +140,7 @@ gpgme_error_t GpgFrontend::BasicOperator::DecryptVerify(
   return err;
 }
 
-gpgme_error_t GpgFrontend::BasicOperator::EncryptSign(
+gpgme_error_t GpgFrontend::GpgBasicOperator::EncryptSign(
     KeyListPtr keys, KeyListPtr signers, BypeArrayRef in_buffer,
     ByteArrayPtr& out_buffer, GpgEncrResult& encr_result,
     GpgSignResult& sign_result) {
@@ -174,7 +174,7 @@ gpgme_error_t GpgFrontend::BasicOperator::EncryptSign(
   return err;
 }
 
-void GpgFrontend::BasicOperator::SetSigners(KeyArgsList& signers) {
+void GpgFrontend::GpgBasicOperator::SetSigners(KeyArgsList& signers) {
   gpgme_signers_clear(ctx_);
   for (const GpgKey& key : signers) {
     DLOG(INFO) << "key" << key.GetFingerprint();
@@ -189,7 +189,7 @@ void GpgFrontend::BasicOperator::SetSigners(KeyArgsList& signers) {
 }
 
 std::unique_ptr<GpgFrontend::KeyArgsList>
-GpgFrontend::BasicOperator::GetSigners() {
+GpgFrontend::GpgBasicOperator::GetSigners() {
   auto count = gpgme_signers_count(ctx_);
   auto signers = std::make_unique<std::vector<GpgKey>>();
   for (auto i = 0u; i < count; i++) {
@@ -199,7 +199,7 @@ GpgFrontend::BasicOperator::GetSigners() {
   return signers;
 }
 
-gpg_error_t GpgFrontend::BasicOperator::EncryptSymmetric(
+gpg_error_t GpgFrontend::GpgBasicOperator::EncryptSymmetric(
     GpgFrontend::ByteArray& in_buffer, GpgFrontend::ByteArrayPtr& out_buffer,
     GpgFrontend::GpgEncrResult& result) {
   GpgData data_in(in_buffer.data(), in_buffer.size()), data_out;
diff --git a/src/gpg/function/BasicOperator.h b/src/gpg/function/GpgBasicOperator.h
index 6ad146c0..d484fa9a 100644
--- a/src/gpg/function/BasicOperator.h
+++ b/src/gpg/function/GpgBasicOperator.h
@@ -40,16 +40,16 @@ namespace GpgFrontend {
  * @brief Basic operation collection
  *
  */
-class BasicOperator : public SingletonFunctionObject<BasicOperator> {
+class GpgBasicOperator : public SingletonFunctionObject<GpgBasicOperator> {
  public:
   /**
    * @brief Construct a new Basic Operator object
    *
    * @param channel Channel corresponding to the context
    */
-  explicit BasicOperator(
+  explicit GpgBasicOperator(
       int channel = SingletonFunctionObject::GetDefaultChannel())
-      : SingletonFunctionObject<BasicOperator>(channel) {}
+      : SingletonFunctionObject<GpgBasicOperator>(channel) {}
 
   /**
    * @brief Call the interface provided by gpgme for encryption operation
diff --git a/src/gpg/function/GpgFileOpera.cpp b/src/gpg/function/GpgFileOpera.cpp
index 4ac4b8bc..f885f5b9 100644
--- a/src/gpg/function/GpgFileOpera.cpp
+++ b/src/gpg/function/GpgFileOpera.cpp
@@ -31,7 +31,7 @@
 #include <string>
 
 #include "GpgConstants.h"
-#include "gpg/function/BasicOperator.h"
+#include "gpg/function/GpgBasicOperator.h"
 
 GpgFrontend::GpgError GpgFrontend::GpgFileOpera::EncryptFile(
     KeyListPtr keys, const std::string& in_path, const std::string& out_path,
@@ -39,7 +39,7 @@ GpgFrontend::GpgError GpgFrontend::GpgFileOpera::EncryptFile(
   std::string in_buffer = read_all_data_in_file(in_path);
   std::unique_ptr<std::string> out_buffer;
 
-  auto err = BasicOperator::GetInstance(_channel).Encrypt(
+  auto err = GpgBasicOperator::GetInstance(_channel).Encrypt(
       std::move(keys), in_buffer, out_buffer, result);
 
   if (check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR)
@@ -57,7 +57,7 @@ GpgFrontend::GpgError GpgFrontend::GpgFileOpera::DecryptFile(
   std::unique_ptr<std::string> out_buffer;
 
   auto err =
-      BasicOperator::GetInstance().Decrypt(in_buffer, out_buffer, result);
+      GpgBasicOperator::GetInstance().Decrypt(in_buffer, out_buffer, result);
 
   assert(check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR);
 
@@ -77,7 +77,7 @@ gpgme_error_t GpgFrontend::GpgFileOpera::SignFile(KeyListPtr keys,
   auto in_buffer = read_all_data_in_file(in_path);
   std::unique_ptr<std::string> out_buffer;
 
-  auto err = BasicOperator::GetInstance(_channel).Sign(
+  auto err = GpgBasicOperator::GetInstance(_channel).Sign(
       std::move(keys), in_buffer, out_buffer, GPGME_SIG_MODE_DETACH, result);
 
   if (check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR)
@@ -97,7 +97,7 @@ gpgme_error_t GpgFrontend::GpgFileOpera::VerifyFile(
     sign_buffer =
         std::make_unique<std::string>(read_all_data_in_file(sign_path));
   }
-  auto err = BasicOperator::GetInstance(_channel).Verify(in_buffer, sign_buffer,
+  auto err = GpgBasicOperator::GetInstance(_channel).Verify(in_buffer, sign_buffer,
                                                          result);
   return err;
 }
@@ -109,7 +109,7 @@ gpg_error_t GpgFrontend::GpgFileOpera::EncryptSignFile(
   auto in_buffer = read_all_data_in_file(in_path);
   std::unique_ptr<std::string> out_buffer = nullptr;
 
-  auto err = BasicOperator::GetInstance(_channel).EncryptSign(
+  auto err = GpgBasicOperator::GetInstance(_channel).EncryptSign(
       std::move(keys), std::move(signer_keys), in_buffer, out_buffer, encr_res,
       sign_res);
 
@@ -128,7 +128,7 @@ gpg_error_t GpgFrontend::GpgFileOpera::DecryptVerifyFile(
 
   std::unique_ptr<std::string> out_buffer = nullptr;
 
-  auto err = BasicOperator::GetInstance().DecryptVerify(in_buffer, out_buffer,
+  auto err = GpgBasicOperator::GetInstance().DecryptVerify(in_buffer, out_buffer,
                                                         decr_res, verify_res);
 
   if (check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR)
@@ -144,7 +144,7 @@ unsigned int GpgFrontend::GpgFileOpera::EncryptFileSymmetric(
   std::string in_buffer = read_all_data_in_file(in_path);
   std::unique_ptr<std::string> out_buffer;
 
-  auto err = BasicOperator::GetInstance(_channel).EncryptSymmetric(
+  auto err = GpgBasicOperator::GetInstance(_channel).EncryptSymmetric(
       in_buffer, out_buffer, result);
 
   if (check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR)
diff --git a/src/gpg/function/GpgFileOpera.h b/src/gpg/function/GpgFileOpera.h
index 45d30161..96c24329 100644
--- a/src/gpg/function/GpgFileOpera.h
+++ b/src/gpg/function/GpgFileOpera.h
@@ -37,8 +37,8 @@ namespace GpgFrontend {
 
 /**
  * @brief Executive files related to the basic operations that are provided by
- * BasicOperator
- * @class class: BasicOperator
+ * GpgBasicOperator
+ * @class class: GpgBasicOperator
  */
 class GpgFileOpera : public SingletonFunctionObject<GpgFileOpera> {
  public:
diff --git a/src/gpg/function/GpgKeyManager.cpp b/src/gpg/function/GpgKeyManager.cpp
index 827ce141..448cbfe2 100644
--- a/src/gpg/function/GpgKeyManager.cpp
+++ b/src/gpg/function/GpgKeyManager.cpp
@@ -31,7 +31,7 @@
 #include <boost/date_time/posix_time/conversion.hpp>
 #include <string>
 
-#include "gpg/function/BasicOperator.h"
+#include "gpg/function/GpgBasicOperator.h"
 #include "gpg/function/GpgKeyGetter.h"
 
 bool GpgFrontend::GpgKeyManager::SignKey(
@@ -40,7 +40,7 @@ bool GpgFrontend::GpgKeyManager::SignKey(
     const std::unique_ptr<boost::posix_time::ptime>& expires) {
   using namespace boost::posix_time;
 
-  BasicOperator::GetInstance().SetSigners(keys);
+  GpgBasicOperator::GetInstance().SetSigners(keys);
 
   unsigned int flags = 0;
   unsigned int expires_time_t = 0;
diff --git a/src/gpg/function/UIDOperator.cpp b/src/gpg/function/GpgUIDOperator.cpp
index a63f5923..4042eacc 100644
--- a/src/gpg/function/UIDOperator.cpp
+++ b/src/gpg/function/GpgUIDOperator.cpp
@@ -26,11 +26,11 @@
  *
  */
 
-#include "gpg/function/UIDOperator.h"
+#include "gpg/function/GpgUIDOperator.h"
 
 #include "boost/format.hpp"
 
-bool GpgFrontend::UIDOperator::AddUID(const GpgFrontend::GpgKey& key,
+bool GpgFrontend::GpgUIDOperator::AddUID(const GpgFrontend::GpgKey& key,
                                       const std::string& uid) {
   auto err = gpgme_op_adduid(ctx_, gpgme_key_t(key), uid.c_str(), 0);
   if (check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR)
@@ -39,7 +39,7 @@ bool GpgFrontend::UIDOperator::AddUID(const GpgFrontend::GpgKey& key,
     return false;
 }
 
-bool GpgFrontend::UIDOperator::RevUID(const GpgFrontend::GpgKey& key,
+bool GpgFrontend::GpgUIDOperator::RevUID(const GpgFrontend::GpgKey& key,
                                       const std::string& uid) {
   auto err =
       check_gpg_error(gpgme_op_revuid(ctx_, gpgme_key_t(key), uid.c_str(), 0));
@@ -49,7 +49,7 @@ bool GpgFrontend::UIDOperator::RevUID(const GpgFrontend::GpgKey& key,
     return false;
 }
 
-bool GpgFrontend::UIDOperator::SetPrimaryUID(const GpgFrontend::GpgKey& key,
+bool GpgFrontend::GpgUIDOperator::SetPrimaryUID(const GpgFrontend::GpgKey& key,
                                              const std::string& uid) {
   auto err = check_gpg_error(gpgme_op_set_uid_flag(
       ctx_, gpgme_key_t(key), uid.c_str(), "primary", nullptr));
@@ -58,7 +58,7 @@ bool GpgFrontend::UIDOperator::SetPrimaryUID(const GpgFrontend::GpgKey& key,
   else
     return false;
 }
-bool GpgFrontend::UIDOperator::AddUID(const GpgFrontend::GpgKey& key,
+bool GpgFrontend::GpgUIDOperator::AddUID(const GpgFrontend::GpgKey& key,
                                       const std::string& name,
                                       const std::string& comment,
                                       const std::string& email) {
diff --git a/src/gpg/function/UIDOperator.h b/src/gpg/function/GpgUIDOperator.h
index 916d53d9..69fb288d 100644
--- a/src/gpg/function/UIDOperator.h
+++ b/src/gpg/function/GpgUIDOperator.h
@@ -37,11 +37,11 @@ namespace GpgFrontend {
  * @brief
  *
  */
-class UIDOperator : public SingletonFunctionObject<UIDOperator> {
+class GpgUIDOperator : public SingletonFunctionObject<GpgUIDOperator> {
  public:
-  explicit UIDOperator(
+  explicit GpgUIDOperator(
       int channel = SingletonFunctionObject::GetDefaultChannel())
-      : SingletonFunctionObject<UIDOperator>(channel) {}
+      : SingletonFunctionObject<GpgUIDOperator>(channel) {}
 
   /**
    * create a new uid in certain key pair
diff --git a/src/gpg/result_analyse/DecryptResultAnalyse.cpp b/src/gpg/result_analyse/GpgDecryptResultAnalyse.cpp
index 8fea6ee3..f75d66f8 100644
--- a/src/gpg/result_analyse/DecryptResultAnalyse.cpp
+++ b/src/gpg/result_analyse/GpgDecryptResultAnalyse.cpp
@@ -26,15 +26,15 @@
  *
  */
 
-#include "gpg/result_analyse/DecryptResultAnalyse.h"
+#include "gpg/result_analyse/GpgDecryptResultAnalyse.h"
 
 #include "gpg/function/GpgKeyGetter.h"
 
-GpgFrontend::DecryptResultAnalyse::DecryptResultAnalyse(GpgError m_error,
+GpgFrontend::GpgDecryptResultAnalyse::GpgDecryptResultAnalyse(GpgError m_error,
                                                         GpgDecrResult m_result)
     : error_(m_error), result_(std::move(m_result)) {}
 
-void GpgFrontend::DecryptResultAnalyse::do_analyse() {
+void GpgFrontend::GpgDecryptResultAnalyse::do_analyse() {
   stream_ << "[#] " << _("Decrypt Operation");
 
   if (gpgme_err_code(error_) == GPG_ERR_NO_ERROR) {
@@ -72,7 +72,7 @@ void GpgFrontend::DecryptResultAnalyse::do_analyse() {
   stream_ << std::endl;
 }
 
-void GpgFrontend::DecryptResultAnalyse::print_recipient(
+void GpgFrontend::GpgDecryptResultAnalyse::print_recipient(
     std::stringstream &stream, gpgme_recipient_t recipient) {
   // check
   if (recipient->keyid == nullptr) return;
diff --git a/src/gpg/result_analyse/DecryptResultAnalyse.h b/src/gpg/result_analyse/GpgDecryptResultAnalyse.h
index a4f0d37c..f2b3537d 100644
--- a/src/gpg/result_analyse/DecryptResultAnalyse.h
+++ b/src/gpg/result_analyse/GpgDecryptResultAnalyse.h
@@ -26,10 +26,10 @@
  *
  */
 
-#ifndef GPGFRONTEND_DECRYPTRESULTANALYSE_H
-#define GPGFRONTEND_DECRYPTRESULTANALYSE_H
+#ifndef GPGFRONTEND_GPGDECRYPTRESULTANALYSE_H
+#define GPGFRONTEND_GPGDECRYPTRESULTANALYSE_H
 
-#include "ResultAnalyse.h"
+#include "GpgResultAnalyse.h"
 #include "gpg/GpgConstants.h"
 
 namespace GpgFrontend {
@@ -38,7 +38,7 @@ namespace GpgFrontend {
  * @brief
  *
  */
-class DecryptResultAnalyse : public ResultAnalyse {
+class GpgDecryptResultAnalyse : public GpgResultAnalyse {
  public:
   /**
    * @brief Construct a new Decrypt Result Analyse object
@@ -46,7 +46,7 @@ class DecryptResultAnalyse : public ResultAnalyse {
    * @param m_error
    * @param m_result
    */
-  explicit DecryptResultAnalyse(GpgError m_error, GpgDecrResult m_result);
+  explicit GpgDecryptResultAnalyse(GpgError m_error, GpgDecrResult m_result);
 
  protected:
   /**
@@ -70,4 +70,4 @@ class DecryptResultAnalyse : public ResultAnalyse {
 
 }  // namespace GpgFrontend
 
-#endif  // GPGFRONTEND_DECRYPTRESULTANALYSE_H
+#endif  // GPGFRONTEND_GPGDECRYPTRESULTANALYSE_H
diff --git a/src/gpg/result_analyse/EncryptResultAnalyse.cpp b/src/gpg/result_analyse/GpgEncryptResultAnalyse.cpp
index b466a623..46b5bc61 100644
--- a/src/gpg/result_analyse/EncryptResultAnalyse.cpp
+++ b/src/gpg/result_analyse/GpgEncryptResultAnalyse.cpp
@@ -26,13 +26,13 @@
  *
  */
 
-#include "gpg/result_analyse/EncryptResultAnalyse.h"
+#include "gpg/result_analyse/GpgEncryptResultAnalyse.h"
 
-GpgFrontend::EncryptResultAnalyse::EncryptResultAnalyse(GpgError error,
+GpgFrontend::GpgEncryptResultAnalyse::GpgEncryptResultAnalyse(GpgError error,
                                                         GpgEncrResult result)
     : error_(error), result_(std::move(result)) {}
 
-void GpgFrontend::EncryptResultAnalyse::do_analyse() {
+void GpgFrontend::GpgEncryptResultAnalyse::do_analyse() {
   LOG(INFO) << _("Start Encrypt Result Analyse");
 
   stream_ << "[#] " << _("Encrypt Operation") << " ";
diff --git a/src/gpg/result_analyse/EncryptResultAnalyse.h b/src/gpg/result_analyse/GpgEncryptResultAnalyse.h
index 5e192ca0..d942210b 100644
--- a/src/gpg/result_analyse/EncryptResultAnalyse.h
+++ b/src/gpg/result_analyse/GpgEncryptResultAnalyse.h
@@ -26,10 +26,10 @@
  *
  */
 
-#ifndef GPGFRONTEND_ENCRYPTRESULTANALYSE_H
-#define GPGFRONTEND_ENCRYPTRESULTANALYSE_H
+#ifndef GPGFRONTEND_GPGENCRYPTRESULTANALYSE_H
+#define GPGFRONTEND_GPGENCRYPTRESULTANALYSE_H
 
-#include "ResultAnalyse.h"
+#include "GpgResultAnalyse.h"
 #include "gpg/GpgConstants.h"
 
 namespace GpgFrontend {
@@ -37,7 +37,7 @@ namespace GpgFrontend {
  * @brief
  *
  */
-class EncryptResultAnalyse : public ResultAnalyse {
+class GpgEncryptResultAnalyse : public GpgResultAnalyse {
  public:
   /**
    * @brief Construct a new Encrypt Result Analyse object
@@ -45,7 +45,7 @@ class EncryptResultAnalyse : public ResultAnalyse {
    * @param error
    * @param result
    */
-  explicit EncryptResultAnalyse(GpgError error, GpgEncrResult result);
+  explicit GpgEncryptResultAnalyse(GpgError error, GpgEncrResult result);
 
  protected:
   /**
@@ -60,4 +60,4 @@ class EncryptResultAnalyse : public ResultAnalyse {
 };
 }  // namespace GpgFrontend
 
-#endif  // GPGFRONTEND_ENCRYPTRESULTANALYSE_H
+#endif  // GPGFRONTEND_GPGENCRYPTRESULTANALYSE_H
diff --git a/src/gpg/result_analyse/ResultAnalyse.cpp b/src/gpg/result_analyse/GpgResultAnalyse.cpp
index a5a41baa..309446fe 100644
--- a/src/gpg/result_analyse/ResultAnalyse.cpp
+++ b/src/gpg/result_analyse/GpgResultAnalyse.cpp
@@ -26,19 +26,19 @@
  *
  */
 
-#include "gpg/result_analyse/ResultAnalyse.h"
+#include "gpg/result_analyse/GpgResultAnalyse.h"
 
-const std::string GpgFrontend::ResultAnalyse::GetResultReport() const {
+const std::string GpgFrontend::GpgResultAnalyse::GetResultReport() const {
   return stream_.str();
 }
 
-int GpgFrontend::ResultAnalyse::GetStatus() const { return status_; }
+int GpgFrontend::GpgResultAnalyse::GetStatus() const { return status_; }
 
-void GpgFrontend::ResultAnalyse::set_status(int m_status) {
+void GpgFrontend::GpgResultAnalyse::set_status(int m_status) {
   if (m_status < status_) status_ = m_status;
 }
 
-void GpgFrontend::ResultAnalyse::Analyse() {
+void GpgFrontend::GpgResultAnalyse::Analyse() {
   if (!analysed_) {
     do_analyse();
     analysed_ = true;
diff --git a/src/gpg/result_analyse/ResultAnalyse.h b/src/gpg/result_analyse/GpgResultAnalyse.h
index b1829274..00a1b402 100644
--- a/src/gpg/result_analyse/ResultAnalyse.h
+++ b/src/gpg/result_analyse/GpgResultAnalyse.h
@@ -25,8 +25,8 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  *
  */
-#ifndef GPGFRONTEND_RESULTANALYSE_H
-#define GPGFRONTEND_RESULTANALYSE_H
+#ifndef GPGFRONTEND_GPGRESULTANALYSE_H
+#define GPGFRONTEND_GPGRESULTANALYSE_H
 
 #include <sstream>
 #include <string>
@@ -34,13 +34,13 @@
 #include "gpg/GpgConstants.h"
 namespace GpgFrontend {
 
-class ResultAnalyse {
+class GpgResultAnalyse {
  public:
   /**
    * @brief Construct a new Result Analyse object
    *
    */
-  ResultAnalyse() = default;
+  GpgResultAnalyse() = default;
 
   /**
    * @brief Get the Result Report object
@@ -83,4 +83,4 @@ class ResultAnalyse {
 
 }  // namespace GpgFrontend
 
-#endif  // GPGFRONTEND_RESULTANALYSE_H
+#endif  // GPGFRONTEND_GPGRESULTANALYSE_H
diff --git a/src/gpg/result_analyse/SignResultAnalyse.cpp b/src/gpg/result_analyse/GpgSignResultAnalyse.cpp
index cde1fa4e..b3b05435 100644
--- a/src/gpg/result_analyse/SignResultAnalyse.cpp
+++ b/src/gpg/result_analyse/GpgSignResultAnalyse.cpp
@@ -26,15 +26,15 @@
  *
  */
 
-#include "gpg/result_analyse/SignResultAnalyse.h"
+#include "gpg/result_analyse/GpgSignResultAnalyse.h"
 
 #include "gpg/function/GpgKeyGetter.h"
 
-GpgFrontend::SignResultAnalyse::SignResultAnalyse(GpgError error,
+GpgFrontend::GpgSignResultAnalyse::GpgSignResultAnalyse(GpgError error,
                                                   GpgSignResult result)
     : error_(error), result_(std::move(result)) {}
 
-void GpgFrontend::SignResultAnalyse::do_analyse() {
+void GpgFrontend::GpgSignResultAnalyse::do_analyse() {
   LOG(INFO) << _("Start Sign Result Analyse");
 
   stream_ << "[#] " << _("Sign Operation") << " ";
diff --git a/src/gpg/result_analyse/SignResultAnalyse.h b/src/gpg/result_analyse/GpgSignResultAnalyse.h
index 09ffcf81..d593b33d 100644
--- a/src/gpg/result_analyse/SignResultAnalyse.h
+++ b/src/gpg/result_analyse/GpgSignResultAnalyse.h
@@ -26,10 +26,10 @@
  *
  */
 
-#ifndef GPGFRONTEND_SIGNRESULTANALYSE_H
-#define GPGFRONTEND_SIGNRESULTANALYSE_H
+#ifndef GPGFRONTEND_GPGSIGNRESULTANALYSE_H
+#define GPGFRONTEND_GPGSIGNRESULTANALYSE_H
 
-#include "ResultAnalyse.h"
+#include "GpgResultAnalyse.h"
 
 namespace GpgFrontend {
 
@@ -37,7 +37,7 @@ namespace GpgFrontend {
  * @brief
  *
  */
-class SignResultAnalyse : public ResultAnalyse {
+class GpgSignResultAnalyse : public GpgResultAnalyse {
  public:
   /**
    * @brief Construct a new Sign Result Analyse object
@@ -45,7 +45,7 @@ class SignResultAnalyse : public ResultAnalyse {
    * @param error
    * @param result
    */
-  explicit SignResultAnalyse(GpgError error, GpgSignResult result);
+  explicit GpgSignResultAnalyse(GpgError error, GpgSignResult result);
 
  protected:
   /**
@@ -62,4 +62,4 @@ class SignResultAnalyse : public ResultAnalyse {
 
 }  // namespace GpgFrontend
 
-#endif  // GPGFRONTEND_SIGNRESULTANALYSE_H
+#endif  // GPGFRONTEND_GPGSIGNRESULTANALYSE_H
diff --git a/src/gpg/result_analyse/VerifyResultAnalyse.cpp b/src/gpg/result_analyse/GpgVerifyResultAnalyse.cpp
index 925776f9..64898df3 100644
--- a/src/gpg/result_analyse/VerifyResultAnalyse.cpp
+++ b/src/gpg/result_analyse/GpgVerifyResultAnalyse.cpp
@@ -26,7 +26,7 @@
  *
  */
 
-#include "gpg/result_analyse/VerifyResultAnalyse.h"
+#include "gpg/result_analyse/GpgVerifyResultAnalyse.h"
 
 #include <boost/format.hpp>
 
@@ -34,11 +34,11 @@
 #include "gpg/GpgConstants.h"
 #include "gpg/function/GpgKeyGetter.h"
 
-GpgFrontend::VerifyResultAnalyse::VerifyResultAnalyse(GpgError error,
+GpgFrontend::GpgVerifyResultAnalyse::GpgVerifyResultAnalyse(GpgError error,
                                                       GpgVerifyResult result)
     : error_(error), result_(std::move(result)) {}
 
-void GpgFrontend::VerifyResultAnalyse::do_analyse() {
+void GpgFrontend::GpgVerifyResultAnalyse::do_analyse() {
   LOG(INFO) << _("started");
 
   stream_ << "[#] " << _("Verify Operation") << " ";
@@ -172,7 +172,7 @@ void GpgFrontend::VerifyResultAnalyse::do_analyse() {
   }
 }
 
-bool GpgFrontend::VerifyResultAnalyse::print_signer(std::stringstream &stream,
+bool GpgFrontend::GpgVerifyResultAnalyse::print_signer(std::stringstream &stream,
                                                     gpgme_signature_t sign) {
   bool keyFound = true;
   auto key = GpgFrontend::GpgKeyGetter::GetInstance().GetKey(sign->fpr);
@@ -202,13 +202,13 @@ bool GpgFrontend::VerifyResultAnalyse::print_signer(std::stringstream &stream,
   return keyFound;
 }
 
-gpgme_signature_t GpgFrontend::VerifyResultAnalyse::GetSignatures() const {
+gpgme_signature_t GpgFrontend::GpgVerifyResultAnalyse::GetSignatures() const {
   if (result_)
     return result_->signatures;
   else
     return nullptr;
 }
 GpgFrontend::GpgVerifyResult
-GpgFrontend::VerifyResultAnalyse::TakeChargeOfResult() {
+GpgFrontend::GpgVerifyResultAnalyse::TakeChargeOfResult() {
   return std::move(result_);
 }
diff --git a/src/gpg/result_analyse/VerifyResultAnalyse.h b/src/gpg/result_analyse/GpgVerifyResultAnalyse.h
index b25aa4b1..a65863dc 100644
--- a/src/gpg/result_analyse/VerifyResultAnalyse.h
+++ b/src/gpg/result_analyse/GpgVerifyResultAnalyse.h
@@ -26,10 +26,10 @@
  *
  */
 
-#ifndef GPGFRONTEND_VERIFYRESULTANALYSE_H
-#define GPGFRONTEND_VERIFYRESULTANALYSE_H
+#ifndef GPGFRONTEND_GPGVERIFYRESULTANALYSE_H
+#define GPGFRONTEND_GPGVERIFYRESULTANALYSE_H
 
-#include "ResultAnalyse.h"
+#include "GpgResultAnalyse.h"
 #include "gpg/model/GpgKeySignature.h"
 
 namespace GpgFrontend {
@@ -37,7 +37,7 @@ namespace GpgFrontend {
  * @brief
  *
  */
-class VerifyResultAnalyse : public ResultAnalyse {
+class GpgVerifyResultAnalyse : public GpgResultAnalyse {
  public:
   /**
    * @brief Construct a new Verify Result Analyse object
@@ -45,7 +45,7 @@ class VerifyResultAnalyse : public ResultAnalyse {
    * @param error
    * @param result
    */
-  explicit VerifyResultAnalyse(GpgError error, GpgVerifyResult result);
+  explicit GpgVerifyResultAnalyse(GpgError error, GpgVerifyResult result);
 
   /**
    * @brief Get the Signatures object
@@ -85,4 +85,4 @@ class VerifyResultAnalyse : public ResultAnalyse {
 
 }  // namespace GpgFrontend
 
-#endif  // GPGFRONTEND_VERIFYRESULTANALYSE_H
+#endif  // GPGFRONTEND_GPGVERIFYRESULTANALYSE_H
diff --git a/src/ui/UserInterfaceUtils.cpp b/src/ui/UserInterfaceUtils.cpp
index 52a8d4c0..3b030fa3 100644
--- a/src/ui/UserInterfaceUtils.cpp
+++ b/src/ui/UserInterfaceUtils.cpp
@@ -31,7 +31,7 @@
 #include <utility>
 
 #include "dialog/WaitingDialog.h"
-#include "gpg/result_analyse/ResultAnalyse.h"
+#include "gpg/result_analyse/GpgResultAnalyse.h"
 #include "ui/SignalStation.h"
 #include "ui/mail/SendMailDialog.h"
 #include "ui/settings/GlobalSettingStation.h"
@@ -78,7 +78,7 @@ void show_verify_details(QWidget* parent, InfoBoardWidget* info_board,
 }
 
 void import_unknown_key_from_keyserver(QWidget* parent,
-                                       const VerifyResultAnalyse& verify_res) {
+                                       const GpgVerifyResultAnalyse& verify_res) {
   QMessageBox::StandardButton reply;
   reply = QMessageBox::question(
       parent, _("Public key not found locally"),
@@ -113,15 +113,15 @@ void refresh_info_board(InfoBoardWidget* info_board, int status,
 }
 
 void process_result_analyse(TextEdit* edit, InfoBoardWidget* info_board,
-                            const ResultAnalyse& result_analyse) {
+                            const GpgResultAnalyse& result_analyse) {
   info_board->AssociateTabWidget(edit->tab_widget_);
   refresh_info_board(info_board, result_analyse.GetStatus(),
                      result_analyse.GetResultReport());
 }
 
 void process_result_analyse(TextEdit* edit, InfoBoardWidget* info_board,
-                            const ResultAnalyse& result_analyse_a,
-                            const ResultAnalyse& result_analyse_b) {
+                            const GpgResultAnalyse& result_analyse_a,
+                            const GpgResultAnalyse& result_analyse_b) {
   LOG(INFO) << "process_result_analyse Started";
 
   info_board->AssociateTabWidget(edit->tab_widget_);
diff --git a/src/ui/UserInterfaceUtils.h b/src/ui/UserInterfaceUtils.h
index 6b7e4ca3..83e94aa9 100644
--- a/src/ui/UserInterfaceUtils.h
+++ b/src/ui/UserInterfaceUtils.h
@@ -30,11 +30,11 @@
 #define GPGFRONTEND_USER_INTERFACE_UTILS_H
 
 #include "gpg/GpgModel.h"
-#include "gpg/result_analyse/VerifyResultAnalyse.h"
+#include "gpg/result_analyse/GpgVerifyResultAnalyse.h"
 #include "ui/GpgFrontendUI.h"
 
 namespace GpgFrontend {
-class ResultAnalyse;
+class GpgResultAnalyse;
 }
 
 namespace GpgFrontend::UI {
@@ -72,7 +72,7 @@ void show_verify_details(QWidget* parent, InfoBoardWidget* info_board,
  * @param verify_res
  */
 void import_unknown_key_from_keyserver(QWidget* parent,
-                                       const VerifyResultAnalyse& verify_res);
+                                       const GpgVerifyResultAnalyse& verify_res);
 
 /**
  * @brief
@@ -92,7 +92,7 @@ void refresh_info_board(InfoBoardWidget* info_board, int status,
  * @param result_analyse
  */
 void process_result_analyse(TextEdit* edit, InfoBoardWidget* info_board,
-                            const ResultAnalyse& result_analyse);
+                            const GpgResultAnalyse& result_analyse);
 
 /**
  * @brief
@@ -103,8 +103,8 @@ void process_result_analyse(TextEdit* edit, InfoBoardWidget* info_board,
  * @param result_analyse_b
  */
 void process_result_analyse(TextEdit* edit, InfoBoardWidget* info_board,
-                            const ResultAnalyse& result_analyse_a,
-                            const ResultAnalyse& result_analyse_b);
+                            const GpgResultAnalyse& result_analyse_a,
+                            const GpgResultAnalyse& result_analyse_b);
 
 /**
  * @brief
diff --git a/src/ui/keypair_details/KeyNewUIDDialog.cpp b/src/ui/keypair_details/KeyNewUIDDialog.cpp
index 0e20acd0..46a7dc75 100644
--- a/src/ui/keypair_details/KeyNewUIDDialog.cpp
+++ b/src/ui/keypair_details/KeyNewUIDDialog.cpp
@@ -27,7 +27,7 @@
 #include "ui/keypair_details/KeyNewUIDDialog.h"
 
 #include "gpg/function/GpgKeyGetter.h"
-#include "gpg/function/UIDOperator.h"
+#include "gpg/function/GpgUIDOperator.h"
 #include "ui/SignalStation.h"
 
 namespace GpgFrontend::UI {
@@ -84,7 +84,7 @@ void KeyNewUIDDialog::slot_create_new_uid() {
   }
   auto error_string = error_stream.str();
   if (error_string.empty()) {
-    if (UIDOperator::GetInstance().AddUID(m_key_, name_->text().toStdString(),
+    if (GpgUIDOperator::GetInstance().AddUID(m_key_, name_->text().toStdString(),
                                           comment_->text().toStdString(),
                                           email_->text().toStdString())) {
       emit finished(1);
diff --git a/src/ui/keypair_details/KeyPairUIDTab.cpp b/src/ui/keypair_details/KeyPairUIDTab.cpp
index 474cb055..2e90d1a3 100644
--- a/src/ui/keypair_details/KeyPairUIDTab.cpp
+++ b/src/ui/keypair_details/KeyPairUIDTab.cpp
@@ -28,7 +28,7 @@
 
 #include "gpg/function/GpgKeyGetter.h"
 #include "gpg/function/GpgKeyManager.h"
-#include "gpg/function/UIDOperator.h"
+#include "gpg/function/GpgUIDOperator.h"
 #include "ui/SignalStation.h"
 #include "ui/widgets/TOFUInfoPage.h"
 
@@ -383,7 +383,7 @@ void KeyPairUIDTab::slot_del_uid() {
   if (ret == QMessageBox::Yes) {
     for (const auto& uid : *selected_uids) {
       LOG(INFO) << "KeyPairUIDTab::slot_del_uid UID" << uid;
-      if (!UIDOperator::GetInstance().RevUID(m_key_, uid)) {
+      if (!GpgUIDOperator::GetInstance().RevUID(m_key_, uid)) {
         QMessageBox::critical(
             nullptr, _("Operation Failed"),
             QString(_("An error occurred during the delete %1 operation."))
@@ -418,7 +418,7 @@ void KeyPairUIDTab::slot_set_primary_uid() {
       QMessageBox::No | QMessageBox::Yes);
 
   if (ret == QMessageBox::Yes) {
-    if (!UIDOperator::GetInstance().SetPrimaryUID(m_key_,
+    if (!GpgUIDOperator::GetInstance().SetPrimaryUID(m_key_,
                                                   selected_uids->front())) {
       QMessageBox::critical(nullptr, _("Operation Failed"),
                             _("An error occurred during the operation."));
@@ -515,7 +515,7 @@ void KeyPairUIDTab::slot_del_uid_single() {
       QMessageBox::No | QMessageBox::Yes);
 
   if (ret == QMessageBox::Yes) {
-    if (!UIDOperator::GetInstance().RevUID(m_key_, selected_uids->front())) {
+    if (!GpgUIDOperator::GetInstance().RevUID(m_key_, selected_uids->front())) {
       QMessageBox::critical(nullptr, _("Operation Failed"),
                             _("An error occurred during the operation."));
     } else {
diff --git a/src/ui/main_window/MainWindow.h b/src/ui/main_window/MainWindow.h
index b169a73f..5d93a710 100644
--- a/src/ui/main_window/MainWindow.h
+++ b/src/ui/main_window/MainWindow.h
@@ -30,9 +30,9 @@
 #define __GPGWIN_H__
 
 #include "gpg/GpgConstants.h"
-#include "gpg/result_analyse/DecryptResultAnalyse.h"
-#include "gpg/result_analyse/EncryptResultAnalyse.h"
-#include "gpg/result_analyse/SignResultAnalyse.h"
+#include "gpg/result_analyse/GpgDecryptResultAnalyse.h"
+#include "gpg/result_analyse/GpgEncryptResultAnalyse.h"
+#include "gpg/result_analyse/GpgSignResultAnalyse.h"
 #include "ui/GpgFrontendUI.h"
 #include "ui/KeyMgmt.h"
 #include "ui/dialog/WaitingDialog.h"
@@ -279,7 +279,7 @@ class MainWindow : public QMainWindow {
   void create_dock_windows();
 
   /**
-   * @details Create attachment-dockwindow.
+   * @details Create attachment dock window.
    */
   void create_attachment_dock();
 
diff --git a/src/ui/main_window/MainWindowFileSlotFunction.cpp b/src/ui/main_window/MainWindowFileSlotFunction.cpp
index 83ff3b3c..cf01ef3d 100644
--- a/src/ui/main_window/MainWindowFileSlotFunction.cpp
+++ b/src/ui/main_window/MainWindowFileSlotFunction.cpp
@@ -145,7 +145,7 @@ void MainWindow::SlotFileEncrypt() {
   }
 
   if (!if_error) {
-    auto resultAnalyse = EncryptResultAnalyse(error, std::move(result));
+    auto resultAnalyse = GpgEncryptResultAnalyse(error, std::move(result));
     resultAnalyse.Analyse();
     process_result_analyse(edit_, info_board_, resultAnalyse);
     fileTreeView->update();
@@ -192,7 +192,7 @@ void MainWindow::SlotFileDecrypt() {
   });
 
   if (!if_error) {
-    auto resultAnalyse = DecryptResultAnalyse(error, std::move(result));
+    auto resultAnalyse = GpgDecryptResultAnalyse(error, std::move(result));
     resultAnalyse.Analyse();
     process_result_analyse(edit_, info_board_, resultAnalyse);
 
@@ -276,7 +276,7 @@ void MainWindow::SlotFileSign() {
   });
 
   if (!if_error) {
-    auto resultAnalyse = SignResultAnalyse(error, std::move(result));
+    auto resultAnalyse = GpgSignResultAnalyse(error, std::move(result));
     resultAnalyse.Analyse();
     process_result_analyse(edit_, info_board_, resultAnalyse);
 
@@ -357,7 +357,7 @@ void MainWindow::SlotFileVerify() {
   });
 
   if (!if_error) {
-    auto result_analyse = VerifyResultAnalyse(error, result);
+    auto result_analyse = GpgVerifyResultAnalyse(error, result);
     result_analyse.Analyse();
     process_result_analyse(edit_, info_board_, result_analyse);
 
@@ -458,8 +458,9 @@ void MainWindow::SlotFileEncryptSign() {
   });
 
   if (!if_error) {
-    auto encrypt_result = EncryptResultAnalyse(error, std::move(encr_result));
-    auto sign_res = SignResultAnalyse(error, std::move(sign_result));
+    auto encrypt_result =
+        GpgEncryptResultAnalyse(error, std::move(encr_result));
+    auto sign_res = GpgSignResultAnalyse(error, std::move(sign_result));
     encrypt_result.Analyse();
     sign_res.Analyse();
     process_result_analyse(edit_, info_board_, encrypt_result, sign_res);
@@ -513,8 +514,8 @@ void MainWindow::SlotFileDecryptVerify() {
   });
 
   if (!if_error) {
-    auto decrypt_res = DecryptResultAnalyse(error, std::move(d_result));
-    auto verify_res = VerifyResultAnalyse(error, v_result);
+    auto decrypt_res = GpgDecryptResultAnalyse(error, std::move(d_result));
+    auto verify_res = GpgVerifyResultAnalyse(error, v_result);
     decrypt_res.Analyse();
     verify_res.Analyse();
     process_result_analyse(edit_, info_board_, decrypt_res, verify_res);
diff --git a/src/ui/main_window/MainWindowSlotFunction.cpp b/src/ui/main_window/MainWindowSlotFunction.cpp
index f14598ed..c2ab0df1 100644
--- a/src/ui/main_window/MainWindowSlotFunction.cpp
+++ b/src/ui/main_window/MainWindowSlotFunction.cpp
@@ -39,7 +39,7 @@
 #include "ui/mail/SendMailDialog.h"
 #endif
 
-#include "gpg/function/BasicOperator.h"
+#include "gpg/function/GpgBasicOperator.h"
 #include "gpg/function/GpgKeyGetter.h"
 #include "gpg/function/GpgKeyImportExporter.h"
 #include "ui/UserInterfaceUtils.h"
@@ -75,7 +75,7 @@ void MainWindow::slot_encrypt() {
       try {
         auto buffer =
             edit_->CurTextPage()->GetTextPage()->toPlainText().toStdString();
-        error = GpgFrontend::BasicOperator::GetInstance().EncryptSymmetric(
+        error = GpgFrontend::GpgBasicOperator::GetInstance().EncryptSymmetric(
             buffer, tmp, result);
       } catch (const std::runtime_error& e) {
         if_error = true;
@@ -101,7 +101,7 @@ void MainWindow::slot_encrypt() {
       try {
         auto buffer =
             edit_->CurTextPage()->GetTextPage()->toPlainText().toStdString();
-        error = GpgFrontend::BasicOperator::GetInstance().Encrypt(
+        error = GpgFrontend::GpgBasicOperator::GetInstance().Encrypt(
             std::move(keys), buffer, tmp, result);
       } catch (const std::runtime_error& e) {
         if_error = true;
@@ -111,7 +111,7 @@ void MainWindow::slot_encrypt() {
 
   if (!if_error) {
     LOG(INFO) << "result" << result.get();
-    auto resultAnalyse = EncryptResultAnalyse(error, std::move(result));
+    auto resultAnalyse = GpgEncryptResultAnalyse(error, std::move(result));
     resultAnalyse.Analyse();
     process_result_analyse(edit_, info_board_, resultAnalyse);
 
@@ -169,7 +169,7 @@ void MainWindow::slot_sign() {
                         ->toPlainText()
                         .toUtf8()
                         .toStdString();
-      error = GpgFrontend::BasicOperator::GetInstance().Sign(
+      error = GpgFrontend::GpgBasicOperator::GetInstance().Sign(
           std::move(keys), buffer, tmp, GPGME_SIG_MODE_CLEAR, result);
     } catch (const std::runtime_error& e) {
       if_error = true;
@@ -177,7 +177,7 @@ void MainWindow::slot_sign() {
   });
 
   if (!if_error) {
-    auto resultAnalyse = SignResultAnalyse(error, std::move(result));
+    auto resultAnalyse = GpgSignResultAnalyse(error, std::move(result));
     resultAnalyse.Analyse();
     process_result_analyse(edit_, info_board_, resultAnalyse);
 
@@ -209,7 +209,7 @@ void MainWindow::slot_decrypt() {
   process_operation(this, _("Decrypting"), [&]() {
     try {
       auto buffer = text.toStdString();
-      error = GpgFrontend::BasicOperator::GetInstance().Decrypt(
+      error = GpgFrontend::GpgBasicOperator::GetInstance().Decrypt(
           buffer, decrypted, result);
     } catch (const std::runtime_error& e) {
       if_error = true;
@@ -217,7 +217,7 @@ void MainWindow::slot_decrypt() {
   });
 
   if (!if_error) {
-    auto resultAnalyse = DecryptResultAnalyse(error, std::move(result));
+    auto resultAnalyse = GpgDecryptResultAnalyse(error, std::move(result));
     resultAnalyse.Analyse();
     process_result_analyse(edit_, info_board_, resultAnalyse);
 
@@ -257,7 +257,7 @@ void MainWindow::slot_verify() {
   process_operation(this, _("Verifying"), [&]() {
     try {
       auto buffer = text.toStdString();
-      error = GpgFrontend::BasicOperator::GetInstance().Verify(
+      error = GpgFrontend::GpgBasicOperator::GetInstance().Verify(
           buffer, sig_buffer, result);
     } catch (const std::runtime_error& e) {
       if_error = true;
@@ -265,7 +265,7 @@ void MainWindow::slot_verify() {
   });
 
   if (!if_error) {
-    auto result_analyse = VerifyResultAnalyse(error, result);
+    auto result_analyse = GpgVerifyResultAnalyse(error, result);
     result_analyse.Analyse();
     process_result_analyse(edit_, info_board_, result_analyse);
 
@@ -333,7 +333,7 @@ void MainWindow::slot_encrypt_sign() {
                         ->toPlainText()
                         .toUtf8()
                         .toStdString();
-      error = GpgFrontend::BasicOperator::GetInstance().EncryptSign(
+      error = GpgFrontend::GpgBasicOperator::GetInstance().EncryptSign(
           std::move(keys), std::move(signer_keys), buffer, tmp, encr_result,
           sign_result);
     } catch (const std::runtime_error& e) {
@@ -355,9 +355,9 @@ void MainWindow::slot_encrypt_sign() {
       }
     }
 #endif
-    LOG(INFO) << "ResultAnalyse Started";
-    auto encrypt_res = EncryptResultAnalyse(error, std::move(encr_result));
-    auto sign_res = SignResultAnalyse(error, std::move(sign_result));
+    LOG(INFO) << "GpgResultAnalyse Started";
+    auto encrypt_res = GpgEncryptResultAnalyse(error, std::move(encr_result));
+    auto sign_res = GpgSignResultAnalyse(error, std::move(sign_result));
     encrypt_res.Analyse();
     sign_res.Analyse();
     process_result_analyse(edit_, info_board_, encrypt_res, sign_res);
@@ -428,7 +428,7 @@ void MainWindow::slot_decrypt_verify() {
   process_operation(this, _("Decrypting and Verifying"), [&]() {
     try {
       auto buffer = text.toStdString();
-      error = BasicOperator::GetInstance().DecryptVerify(buffer, decrypted,
+      error = GpgBasicOperator::GetInstance().DecryptVerify(buffer, decrypted,
                                                          d_result, v_result);
     } catch (const std::runtime_error& e) {
       if_error = true;
@@ -436,8 +436,8 @@ void MainWindow::slot_decrypt_verify() {
   });
 
   if (!if_error) {
-    auto decrypt_res = DecryptResultAnalyse(error, std::move(d_result));
-    auto verify_res = VerifyResultAnalyse(error, v_result);
+    auto decrypt_res = GpgDecryptResultAnalyse(error, std::move(d_result));
+    auto verify_res = GpgVerifyResultAnalyse(error, v_result);
     decrypt_res.Analyse();
     verify_res.Analyse();
     process_result_analyse(edit_, info_board_, decrypt_res, verify_res);
diff --git a/src/ui/thread/SMTPSendMailThread.cpp b/src/ui/thread/SMTPSendMailThread.cpp
index 1d46f4ef..5364f634 100644
--- a/src/ui/thread/SMTPSendMailThread.cpp
+++ b/src/ui/thread/SMTPSendMailThread.cpp
@@ -28,7 +28,7 @@
 
 #include <boost/format.hpp>
 
-#include "gpg/function/BasicOperator.h"
+#include "gpg/function/GpgBasicOperator.h"
 #include "gpg/function/GpgKeyGetter.h"
 #include "gpg/function/GpgKeyImportExporter.h"
 
@@ -66,7 +66,7 @@ void SMTPSendMailThread::run() {
       GpgEncrResult result;
       auto in_buffer = std::make_unique<ByteArray>(plain_text);
       auto keys = GpgKeyGetter::GetInstance().GetKeys(public_key_ids_);
-      auto err = BasicOperator::GetInstance().Encrypt(
+      auto err = GpgBasicOperator::GetInstance().Encrypt(
           std::move(keys), *in_buffer, out_buffer, result);
 
       if (check_gpg_error_2_err_code(err) != GPG_ERR_NO_ERROR) {
@@ -128,7 +128,7 @@ void SMTPSendMailThread::run() {
 
       //   The signature MUST be generated detached from the signed data
       //   so that the process does not alter the signed data in any way.
-      auto err = BasicOperator::GetInstance().Sign(
+      auto err = GpgBasicOperator::GetInstance().Sign(
           std::move(keys), *in_buffer, out_buffer, GPGME_SIG_MODE_DETACH,
           result);
 
diff --git a/src/ui/widgets/InfoBoardWidget.h b/src/ui/widgets/InfoBoardWidget.h
index 3d68215a..c92d5981 100644
--- a/src/ui/widgets/InfoBoardWidget.h
+++ b/src/ui/widgets/InfoBoardWidget.h
@@ -30,7 +30,7 @@
 #define __VERIFYNOTIFICATION_H__
 
 #include "PlainTextEditorPage.h"
-#include "gpg/result_analyse/VerifyResultAnalyse.h"
+#include "gpg/result_analyse/GpgVerifyResultAnalyse.h"
 #include "ui/details/VerifyDetailsDialog.h"
 
 class Ui_InfoBoard;
diff --git a/test/GpgCoreTestBasicOpera.cpp b/test/GpgCoreTestBasicOpera.cpp
index 1429a7bf..57339453 100644
--- a/test/GpgCoreTestBasicOpera.cpp
+++ b/test/GpgCoreTestBasicOpera.cpp
@@ -33,9 +33,9 @@
 
 #include "GpgFrontendTest.h"
 #include "gpg/GpgConstants.h"
-#include "gpg/function/BasicOperator.h"
+#include "gpg/function/GpgBasicOperator.h"
 #include "gpg/function/GpgKeyGetter.h"
-#include "gpg/result_analyse/DecryptResultAnalyse.h"
+#include "gpg/result_analyse/GpgDecryptResultAnalyse.h"
 
 using namespace GpgFrontend;