7 files changed, 33 insertions, 33 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