<doc, refactor>(ci): Tidy up code in gpg/function

1. Rename related entities.
2. Add a comments.

17 files changed, 189 insertions, 96 deletions

diff --git a/src/gpg/function/BasicOperator.cpp b/src/gpg/function/BasicOperator.cpp
index 4f88b34f..6c699df1 100644
--- a/src/gpg/function/BasicOperator.cpp
+++ b/src/gpg/function/BasicOperator.cpp
@@ -43,12 +43,12 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Encrypt(
   GpgData data_in(in_buffer.data(), in_buffer.size()), data_out;
 
   gpgme_error_t err = check_gpg_error(gpgme_op_encrypt(
-      ctx, recipients, GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
+      ctx_, recipients, GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
 
   auto temp_data_out = data_out.Read2Buffer();
   std::swap(temp_data_out, out_buffer);
 
-  auto temp_result = _new_result(gpgme_op_encrypt_result(ctx));
+  auto temp_result = _new_result(gpgme_op_encrypt_result(ctx_));
   std::swap(result, temp_result);
 
   return err;
@@ -60,12 +60,12 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Decrypt(
   gpgme_error_t err;
 
   GpgData data_in(in_buffer.data(), in_buffer.size()), data_out;
-  err = check_gpg_error(gpgme_op_decrypt(ctx, data_in, data_out));
+  err = check_gpg_error(gpgme_op_decrypt(ctx_, data_in, data_out));
 
   auto temp_data_out = data_out.Read2Buffer();
   std::swap(temp_data_out, out_buffer);
 
-  auto temp_result = _new_result(gpgme_op_decrypt_result(ctx));
+  auto temp_result = _new_result(gpgme_op_decrypt_result(ctx_));
   std::swap(result, temp_result);
 
   return err;
@@ -81,11 +81,11 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Verify(
 
   if (sig_buffer != nullptr) {
     GpgData sig_data(sig_buffer->data(), sig_buffer->size());
-    err = check_gpg_error(gpgme_op_verify(ctx, sig_data, data_in, nullptr));
+    err = check_gpg_error(gpgme_op_verify(ctx_, sig_data, data_in, nullptr));
   } else
-    err = check_gpg_error(gpgme_op_verify(ctx, data_in, nullptr, data_out));
+    err = check_gpg_error(gpgme_op_verify(ctx_, data_in, nullptr, data_out));
 
-  auto temp_result = _new_result(gpgme_op_verify_result(ctx));
+  auto temp_result = _new_result(gpgme_op_verify_result(ctx_));
   std::swap(result, temp_result);
 
   return err;
@@ -103,12 +103,12 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Sign(KeyListPtr signers,
 
   GpgData data_in(in_buffer.data(), in_buffer.size()), data_out;
 
-  err = check_gpg_error(gpgme_op_sign(ctx, data_in, data_out, mode));
+  err = check_gpg_error(gpgme_op_sign(ctx_, data_in, data_out, mode));
 
   auto temp_data_out = data_out.Read2Buffer();
   std::swap(temp_data_out, out_buffer);
 
-  auto temp_result = _new_result(gpgme_op_sign_result(ctx));
+  auto temp_result = _new_result(gpgme_op_sign_result(ctx_));
 
   std::swap(result, temp_result);
 
@@ -122,15 +122,15 @@ gpgme_error_t GpgFrontend::BasicOperator::DecryptVerify(
 
   GpgData data_in(in_buffer.data(), in_buffer.size()), data_out;
 
-  err = check_gpg_error(gpgme_op_decrypt_verify(ctx, data_in, data_out));
+  err = check_gpg_error(gpgme_op_decrypt_verify(ctx_, data_in, data_out));
 
   auto temp_data_out = data_out.Read2Buffer();
   std::swap(temp_data_out, out_buffer);
 
-  auto temp_decr_result = _new_result(gpgme_op_decrypt_result(ctx));
+  auto temp_decr_result = _new_result(gpgme_op_decrypt_result(ctx_));
   std::swap(decrypt_result, temp_decr_result);
 
-  auto temp_verify_result = _new_result(gpgme_op_verify_result(ctx));
+  auto temp_verify_result = _new_result(gpgme_op_verify_result(ctx_));
   std::swap(verify_result, temp_verify_result);
 
   return err;
@@ -157,39 +157,39 @@ gpgme_error_t GpgFrontend::BasicOperator::EncryptSign(
 
   // If the last parameter isnt 0, a private copy of data is made
   err = check_gpg_error(gpgme_op_encrypt_sign(
-      ctx, recipients, GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
+      ctx_, recipients, GPGME_ENCRYPT_ALWAYS_TRUST, data_in, data_out));
 
   auto temp_data_out = data_out.Read2Buffer();
   std::swap(temp_data_out, out_buffer);
 
-  auto temp_encr_result = _new_result(gpgme_op_encrypt_result(ctx));
+  auto temp_encr_result = _new_result(gpgme_op_encrypt_result(ctx_));
   swap(encr_result, temp_encr_result);
-  auto temp_sign_result = _new_result(gpgme_op_sign_result(ctx));
+  auto temp_sign_result = _new_result(gpgme_op_sign_result(ctx_));
   swap(sign_result, temp_sign_result);
 
   return err;
 }
 
 void GpgFrontend::BasicOperator::SetSigners(KeyArgsList& signers) {
-  gpgme_signers_clear(ctx);
+  gpgme_signers_clear(ctx_);
   for (const GpgKey& key : signers) {
     DLOG(INFO) << "key" << key.fpr();
     if (key.CanSignActual()) {
       DLOG(INFO) << "signer";
-      auto error = gpgme_signers_add(ctx, gpgme_key_t(key));
+      auto error = gpgme_signers_add(ctx_, gpgme_key_t(key));
       check_gpg_error(error);
     }
   }
-  if (signers.size() != gpgme_signers_count(ctx))
+  if (signers.size() != gpgme_signers_count(ctx_))
     DLOG(INFO) << "No All Signers Added";
 }
 
 std::unique_ptr<GpgFrontend::KeyArgsList>
 GpgFrontend::BasicOperator::GetSigners() {
-  auto count = gpgme_signers_count(ctx);
+  auto count = gpgme_signers_count(ctx_);
   auto signers = std::make_unique<std::vector<GpgKey>>();
   for (auto i = 0u; i < count; i++) {
-    auto key = GpgKey(gpgme_signers_enum(ctx, i));
+    auto key = GpgKey(gpgme_signers_enum(ctx_, i));
     signers->push_back(GpgKey(std::move(key)));
   }
   return signers;
@@ -201,14 +201,14 @@ gpg_error_t GpgFrontend::BasicOperator::EncryptSymmetric(
   GpgData data_in(in_buffer.data(), in_buffer.size()), data_out;
 
   gpgme_error_t err = check_gpg_error(gpgme_op_encrypt(
-      ctx, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
+      ctx_, nullptr, GPGME_ENCRYPT_SYMMETRIC, data_in, data_out));
 
   auto temp_data_out = data_out.Read2Buffer();
   std::swap(temp_data_out, out_buffer);
 
   // TODO(Saturneric): maybe a bug of gpgme
   if (gpgme_err_code(err) == GPG_ERR_NO_ERROR) {
-    auto temp_result = _new_result(gpgme_op_encrypt_result(ctx));
+    auto temp_result = _new_result(gpgme_op_encrypt_result(ctx_));
     std::swap(result, temp_result);
   }
 
diff --git a/src/gpg/function/BasicOperator.h b/src/gpg/function/BasicOperator.h
index 440e6e1f..725be764 100644
--- a/src/gpg/function/BasicOperator.h
+++ b/src/gpg/function/BasicOperator.h
@@ -167,7 +167,7 @@ class BasicOperator : public SingletonFunctionObject<BasicOperator> {
   std::unique_ptr<KeyArgsList> GetSigners();
 
  private:
-  GpgContext& ctx = GpgContext::GetInstance(
+  GpgContext& ctx_ = GpgContext::GetInstance(
       SingletonFunctionObject::GetChannel());  ///< Corresponding context
 };
 }  // namespace GpgFrontend
diff --git a/src/gpg/function/GpgCommandExecutor.cpp b/src/gpg/function/GpgCommandExecutor.cpp
index 9b99b400..4098fdb6 100644
--- a/src/gpg/function/GpgCommandExecutor.cpp
+++ b/src/gpg/function/GpgCommandExecutor.cpp
@@ -42,7 +42,7 @@ void GpgFrontend::GpgCommandExecutor::Execute(
   async_pipe in_pipe_stream(ios);
   async_pipe out_pipe_stream(ios);
 
-  child child_process(ctx.GetInfo().AppPath.c_str(), arguments,
+  child child_process(ctx_.GetInfo().AppPath.c_str(), arguments,
                       std_out > in_pipe_stream, std_in < out_pipe_stream);
 
   boost::asio::async_read(
diff --git a/src/gpg/function/GpgCommandExecutor.h b/src/gpg/function/GpgCommandExecutor.h
index 5e8c19c1..66f7c1f9 100644
--- a/src/gpg/function/GpgCommandExecutor.h
+++ b/src/gpg/function/GpgCommandExecutor.h
@@ -64,7 +64,7 @@ class GpgCommandExecutor : public SingletonFunctionObject<GpgCommandExecutor> {
 #endif
 
  private:
-  GpgContext &ctx = GpgContext::GetInstance(
+  GpgContext &ctx_ = GpgContext::GetInstance(
       SingletonFunctionObject::GetChannel());  ///< Corresponding context
 };
 
diff --git a/src/gpg/function/GpgKeyGetter.cpp b/src/gpg/function/GpgKeyGetter.cpp
index 8a26dcd9..4c036a46 100644
--- a/src/gpg/function/GpgKeyGetter.cpp
+++ b/src/gpg/function/GpgKeyGetter.cpp
@@ -30,7 +30,7 @@
 
 GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetKey(const std::string& fpr) {
   gpgme_key_t _p_key = nullptr;
-  gpgme_get_key(ctx, fpr.c_str(), &_p_key, 1);
+  gpgme_get_key(ctx_, fpr.c_str(), &_p_key, 1);
   if (_p_key == nullptr) {
     DLOG(WARNING) << "GpgKeyGetter GetKey Private _p_key Null fpr" << fpr;
     return GetPubkey(fpr);
@@ -42,7 +42,7 @@ GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetKey(const std::string& fpr) {
 GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetPubkey(
     const std::string& fpr) {
   gpgme_key_t _p_key = nullptr;
-  gpgme_get_key(ctx, fpr.c_str(), &_p_key, 0);
+  gpgme_get_key(ctx_, fpr.c_str(), &_p_key, 0);
   if (_p_key == nullptr)
     DLOG(WARNING) << "GpgKeyGetter GetKey _p_key Null" << fpr;
   return GpgKey(std::move(_p_key));
@@ -53,17 +53,17 @@ GpgFrontend::KeyLinkListPtr GpgFrontend::GpgKeyGetter::FetchKey() {
 
   auto keys_list = std::make_unique<GpgKeyLinkList>();
 
-  err = gpgme_op_keylist_start(ctx, nullptr, 0);
+  err = gpgme_op_keylist_start(ctx_, nullptr, 0);
   assert(check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR);
 
   gpgme_key_t key;
-  while ((err = gpgme_op_keylist_next(ctx, &key)) == GPG_ERR_NO_ERROR) {
+  while ((err = gpgme_op_keylist_next(ctx_, &key)) == GPG_ERR_NO_ERROR) {
     keys_list->push_back(GetKey(key->fpr));
   }
 
   assert(check_gpg_error_2_err_code(err, GPG_ERR_EOF) == GPG_ERR_EOF);
 
-  err = gpgme_op_keylist_end(ctx);
+  err = gpgme_op_keylist_end(ctx_);
 
   assert(check_gpg_error_2_err_code(err, GPG_ERR_EOF) == GPG_ERR_NO_ERROR);
 
diff --git a/src/gpg/function/GpgKeyGetter.h b/src/gpg/function/GpgKeyGetter.h
index e4700d5a..2668ce4a 100644
--- a/src/gpg/function/GpgKeyGetter.h
+++ b/src/gpg/function/GpgKeyGetter.h
@@ -98,7 +98,7 @@ class GpgKeyGetter : public SingletonFunctionObject<GpgKeyGetter> {
    * @brief
    *
    */
-  GpgContext& ctx =
+  GpgContext& ctx_ =
       GpgContext::GetInstance(SingletonFunctionObject::GetChannel());
 };
 }  // namespace GpgFrontend
diff --git a/src/gpg/function/GpgKeyImportExporter.cpp b/src/gpg/function/GpgKeyImportExporter.cpp
index dd027eab..0ea6a460 100644
--- a/src/gpg/function/GpgKeyImportExporter.cpp
+++ b/src/gpg/function/GpgKeyImportExporter.cpp
@@ -37,11 +37,11 @@ GpgFrontend::GpgImportInformation GpgFrontend::GpgKeyImportExporter::ImportKey(
   if (in_buffer->empty()) return {};
 
   GpgData data_in(in_buffer->data(), in_buffer->size());
-  auto err = check_gpg_error(gpgme_op_import(ctx, data_in));
+  auto err = check_gpg_error(gpgme_op_import(ctx_, data_in));
   if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return {};
 
   gpgme_import_result_t result;
-  result = gpgme_op_import_result(ctx);
+  result = gpgme_op_import_result(ctx_);
   gpgme_import_status_t status = result->imports;
   auto import_info = std::make_unique<GpgImportInformation>(result);
   while (status != nullptr) {
@@ -79,7 +79,7 @@ bool GpgFrontend::GpgKeyImportExporter::ExportKeys(KeyIdArgsListPtr& uid_list,
   keys_array[index] = nullptr;
 
   GpgData data_out;
-  auto err = gpgme_op_export_keys(ctx, keys_array, _mode, data_out);
+  auto err = gpgme_op_export_keys(ctx_, keys_array, _mode, data_out);
   if (gpgme_err_code(err) != GPG_ERR_NO_ERROR) return false;
 
   delete[] keys_array;
@@ -122,8 +122,8 @@ bool GpgFrontend::GpgKeyImportExporter::ExportSecretKey(
 
   GpgData data_out;
   // export private key to outBuffer
-  gpgme_error_t err =
-      gpgme_op_export_keys(ctx, target_key, GPGME_EXPORT_MODE_SECRET, data_out);
+  gpgme_error_t err = gpgme_op_export_keys(ctx_, target_key,
+                                           GPGME_EXPORT_MODE_SECRET, data_out);
 
   auto temp_out_buffer = data_out.Read2Buffer();
   std::swap(out_buffer, temp_out_buffer);
@@ -135,7 +135,7 @@ bool GpgFrontend::GpgKeyImportExporter::ExportKey(
     const GpgFrontend::GpgKey& key,
     GpgFrontend::ByteArrayPtr& out_buffer) const {
   GpgData data_out;
-  auto err = gpgme_op_export(ctx, key.id().c_str(), 0, data_out);
+  auto err = gpgme_op_export(ctx_, key.id().c_str(), 0, data_out);
 
   DLOG(INFO) << "exportKeys read_bytes"
              << gpgme_data_seek(data_out, 0, SEEK_END);
@@ -150,7 +150,7 @@ bool GpgFrontend::GpgKeyImportExporter::ExportKeyOpenSSH(
     GpgFrontend::ByteArrayPtr& out_buffer) const {
   GpgData data_out;
   auto err =
-      gpgme_op_export(ctx, key.id().c_str(), GPGME_EXPORT_MODE_SSH, data_out);
+      gpgme_op_export(ctx_, key.id().c_str(), GPGME_EXPORT_MODE_SSH, data_out);
 
   DLOG(INFO) << "read_bytes" << gpgme_data_seek(data_out, 0, SEEK_END);
 
@@ -163,7 +163,7 @@ bool GpgFrontend::GpgKeyImportExporter::ExportSecretKeyShortest(
     const GpgFrontend::GpgKey& key,
     GpgFrontend::ByteArrayPtr& out_buffer) const {
   GpgData data_out;
-  auto err = gpgme_op_export(ctx, key.id().c_str(), GPGME_EXPORT_MODE_MINIMAL,
+  auto err = gpgme_op_export(ctx_, key.id().c_str(), GPGME_EXPORT_MODE_MINIMAL,
                              data_out);
 
   DLOG(INFO) << "read_bytes" << gpgme_data_seek(data_out, 0, SEEK_END);
diff --git a/src/gpg/function/GpgKeyImportExporter.h b/src/gpg/function/GpgKeyImportExporter.h
index 52de8091..51758c0a 100644
--- a/src/gpg/function/GpgKeyImportExporter.h
+++ b/src/gpg/function/GpgKeyImportExporter.h
@@ -55,7 +55,7 @@ class GpgImportInformation {
   GpgImportInformation() = default;
 
   /**
-   * @brief Construct a new Gpg Import Information object/**
+   * @brief Construct a new Gpg Import Information object
    *
    * @param result
    */
@@ -182,7 +182,7 @@ class GpgKeyImportExporter
                                ByteArrayPtr& outBuffer) const;
 
  private:
-  GpgContext& ctx =
+  GpgContext& ctx_ =
       GpgContext::GetInstance(SingletonFunctionObject::GetChannel());  ///<
 };
 
diff --git a/src/gpg/function/GpgKeyManager.cpp b/src/gpg/function/GpgKeyManager.cpp
index 998c27a7..d25c3130 100644
--- a/src/gpg/function/GpgKeyManager.cpp
+++ b/src/gpg/function/GpgKeyManager.cpp
@@ -30,7 +30,7 @@
 #include "gpg/function/BasicOperator.h"
 #include "gpg/function/GpgKeyGetter.h"
 
-bool GpgFrontend::GpgKeyManager::signKey(
+bool GpgFrontend::GpgKeyManager::SignKey(
     const GpgFrontend::GpgKey& target, GpgFrontend::KeyArgsList& keys,
     const std::string& uid,
     const std::unique_ptr<boost::posix_time::ptime>& expires) {
@@ -47,12 +47,12 @@ bool GpgFrontend::GpgKeyManager::signKey(
     expires_time_t = to_time_t(*expires);
 
   auto err = check_gpg_error(gpgme_op_keysign(
-      ctx, gpgme_key_t(target), uid.c_str(), expires_time_t, flags));
+      ctx_, gpgme_key_t(target), uid.c_str(), expires_time_t, flags));
 
   return check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR;
 }
 
-bool GpgFrontend::GpgKeyManager::revSign(
+bool GpgFrontend::GpgKeyManager::RevSign(
     const GpgFrontend::GpgKey& key,
     const GpgFrontend::SignIdArgsListPtr& signature_id) {
   auto& key_getter = GpgKeyGetter::GetInstance();
@@ -60,7 +60,7 @@ bool GpgFrontend::GpgKeyManager::revSign(
   for (const auto& sign_id : *signature_id) {
     auto signing_key = key_getter.GetKey(sign_id.first);
     assert(signing_key.good());
-    auto err = check_gpg_error(gpgme_op_revsig(ctx, gpgme_key_t(key),
+    auto err = check_gpg_error(gpgme_op_revsig(ctx_, gpgme_key_t(key),
                                                gpgme_key_t(signing_key),
                                                sign_id.second.c_str(), 0));
     if (check_gpg_error_2_err_code(err) != GPG_ERR_NO_ERROR) return false;
@@ -68,7 +68,7 @@ bool GpgFrontend::GpgKeyManager::revSign(
   return true;
 }
 
-bool GpgFrontend::GpgKeyManager::setExpire(
+bool GpgFrontend::GpgKeyManager::SetExpire(
     const GpgFrontend::GpgKey& key, std::unique_ptr<GpgSubKey>& subkey,
     std::unique_ptr<boost::posix_time::ptime>& expires) {
   using namespace boost::posix_time;
@@ -82,7 +82,7 @@ bool GpgFrontend::GpgKeyManager::setExpire(
   if (subkey != nullptr) sub_fprs = subkey->fpr().c_str();
 
   auto err = check_gpg_error(
-      gpgme_op_setexpire(ctx, gpgme_key_t(key), expires_time, sub_fprs, 0));
+      gpgme_op_setexpire(ctx_, gpgme_key_t(key), expires_time, sub_fprs, 0));
 
   return check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR;
 }
diff --git a/src/gpg/function/GpgKeyManager.h b/src/gpg/function/GpgKeyManager.h
index b2444e8d..ee8b4f6c 100644
--- a/src/gpg/function/GpgKeyManager.h
+++ b/src/gpg/function/GpgKeyManager.h
@@ -31,31 +31,57 @@
 
 namespace GpgFrontend {
 
+/**
+ * @brief
+ *
+ */
 class GpgKeyManager : public SingletonFunctionObject<GpgKeyManager> {
  public:
+  /**
+   * @brief Construct a new Gpg Key Manager object
+   *
+   * @param channel
+   */
   explicit GpgKeyManager(
       int channel = SingletonFunctionObject::GetDefaultChannel())
       : SingletonFunctionObject<GpgKeyManager>(channel) {}
 
   /**
-   * Sign a key pair(actually a certain uid)
+   * @brief Sign a key pair(actually a certain uid)
    * @param target target key pair
    * @param uid target
    * @param expires expire date and time of the signature
    * @return if successful
    */
-  bool signKey(const GpgKey& target, KeyArgsList& keys, const std::string& uid,
+  bool SignKey(const GpgKey& target, KeyArgsList& keys, const std::string& uid,
                const std::unique_ptr<boost::posix_time::ptime>& expires);
 
-  bool revSign(const GpgFrontend::GpgKey& key,
+  /**
+   * @brief
+   *
+   * @param key
+   * @param signature_id
+   * @return true
+   * @return false
+   */
+  bool RevSign(const GpgFrontend::GpgKey& key,
                const GpgFrontend::SignIdArgsListPtr& signature_id);
 
-  bool setExpire(const GpgKey& key, std::unique_ptr<GpgSubKey>& subkey,
+  /**
+   * @brief Set the Expire object
+   *
+   * @param key
+   * @param subkey
+   * @param expires
+   * @return true
+   * @return false
+   */
+  bool SetExpire(const GpgKey& key, std::unique_ptr<GpgSubKey>& subkey,
                  std::unique_ptr<boost::posix_time::ptime>& expires);
 
  private:
-  GpgContext& ctx =
-      GpgContext::GetInstance(SingletonFunctionObject::GetChannel());
+  GpgContext& ctx_ =
+      GpgContext::GetInstance(SingletonFunctionObject::GetChannel());  ///<
 };
 
 }  // namespace GpgFrontend
diff --git a/src/gpg/function/GpgKeyOpera.cpp b/src/gpg/function/GpgKeyOpera.cpp
index e9fcbc1d..d3f94c18 100644
--- a/src/gpg/function/GpgKeyOpera.cpp
+++ b/src/gpg/function/GpgKeyOpera.cpp
@@ -48,7 +48,7 @@ void GpgFrontend::GpgKeyOpera::DeleteKeys(
     auto key = GpgKeyGetter::GetInstance().GetKey(tmp);
     if (key.good()) {
       err = check_gpg_error(
-          gpgme_op_delete_ext(ctx, gpgme_key_t(key),
+          gpgme_op_delete_ext(ctx_, gpgme_key_t(key),
                               GPGME_DELETE_ALLOW_SECRET | GPGME_DELETE_FORCE));
       assert(gpg_err_code(err) == GPG_ERR_NO_ERROR);
     } else {
@@ -81,9 +81,9 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::SetExpire(
 
   GpgError err;
   if (key.fpr() == subkey_fpr || subkey_fpr.empty())
-    err = gpgme_op_setexpire(ctx, gpgme_key_t(key), expires_time, nullptr, 0);
+    err = gpgme_op_setexpire(ctx_, gpgme_key_t(key), expires_time, nullptr, 0);
   else
-    err = gpgme_op_setexpire(ctx, gpgme_key_t(key), expires_time,
+    err = gpgme_op_setexpire(ctx_, gpgme_key_t(key), expires_time,
                              subkey_fpr.c_str(), 0);
 
   return err;
@@ -168,7 +168,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
 
   GpgError err;
 
-  if (ctx.GetInfo().GnupgVersion >= "2.1.0") {
+  if (ctx_.GetInfo().GnupgVersion >= "2.1.0") {
     unsigned int flags = 0;
 
     if (!params->isSubKey()) flags |= GPGME_CREATE_CERT;
@@ -180,7 +180,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
 
     LOG(INFO) << "args: " << userid << algo << expires << flags;
 
-    err = gpgme_op_createkey(ctx, userid, algo, 0, expires, nullptr, flags);
+    err = gpgme_op_createkey(ctx_, userid, algo, 0, expires, nullptr, flags);
 
   } else {
     std::stringstream ss;
@@ -209,11 +209,11 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
 
     DLOG(INFO) << "params" << std::endl << ss.str();
 
-    err = gpgme_op_genkey(ctx, ss.str().c_str(), nullptr, nullptr);
+    err = gpgme_op_genkey(ctx_, ss.str().c_str(), nullptr, nullptr);
   }
 
   if (check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR) {
-    auto temp_result = _new_result(gpgme_op_genkey_result(ctx));
+    auto temp_result = _new_result(gpgme_op_genkey_result(ctx_));
     std::swap(temp_result, result);
   }
 
@@ -253,26 +253,26 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateSubkey(
             << algo << expires << flags;
 
   auto err =
-      gpgme_op_createsubkey(ctx, gpgme_key_t(key), algo, 0, expires, flags);
+      gpgme_op_createsubkey(ctx_, gpgme_key_t(key), algo, 0, expires, flags);
   return check_gpg_error(err);
 }
 
 GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::ModifyPassword(
     const GpgFrontend::GpgKey& key) {
-  if (ctx.GetInfo().GnupgVersion < "2.0.15") {
+  if (ctx_.GetInfo().GnupgVersion < "2.0.15") {
     LOG(ERROR) << _("operator not support");
     return GPG_ERR_NOT_SUPPORTED;
   }
-  auto err = gpgme_op_passwd(ctx, gpgme_key_t(key), 0);
+  auto err = gpgme_op_passwd(ctx_, gpgme_key_t(key), 0);
   return check_gpg_error(err);
 }
 GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::ModifyTOFUPolicy(
     const GpgFrontend::GpgKey& key, gpgme_tofu_policy_t tofu_policy) {
-  if (ctx.GetInfo().GnupgVersion < "2.1.10") {
+  if (ctx_.GetInfo().GnupgVersion < "2.1.10") {
     LOG(ERROR) << _("operator not support");
     return GPG_ERR_NOT_SUPPORTED;
   }
-  auto err = gpgme_op_tofu_policy(ctx, gpgme_key_t(key), tofu_policy);
+  auto err = gpgme_op_tofu_policy(ctx_, gpgme_key_t(key), tofu_policy);
   return check_gpg_error(err);
 }
 
diff --git a/src/gpg/function/GpgKeyOpera.h b/src/gpg/function/GpgKeyOpera.h
index 73b8bdb5..ce0acc0d 100644
--- a/src/gpg/function/GpgKeyOpera.h
+++ b/src/gpg/function/GpgKeyOpera.h
@@ -30,37 +30,101 @@
 #include "gpg/GpgModel.h"
 
 namespace GpgFrontend {
+/**
+ * @brief
+ *
+ */
 class GenKeyInfo;
+
+/**
+ * @brief
+ *
+ */
 class GpgKeyOpera : public SingletonFunctionObject<GpgKeyOpera> {
  public:
+  /**
+   * @brief Construct a new Gpg Key Opera object
+   *
+   * @param channel
+   */
   explicit GpgKeyOpera(
       int channel = SingletonFunctionObject::GetDefaultChannel())
       : SingletonFunctionObject<GpgKeyOpera>(channel) {}
 
+  /**
+   * @brief
+   *
+   * @param key_ids
+   */
   void DeleteKeys(KeyIdArgsListPtr key_ids);
 
+  /**
+   * @brief
+   *
+   * @param key_id
+   */
   void DeleteKey(const KeyId& key_id);
 
+  /**
+   * @brief Set the Expire object
+   *
+   * @param key
+   * @param subkey_fpr
+   * @param expires
+   * @return GpgError
+   */
   GpgError SetExpire(const GpgKey& key, const SubkeyId& subkey_fpr,
                      std::unique_ptr<boost::posix_time::ptime>& expires);
 
+  /**
+   * @brief
+   *
+   * @param key
+   * @param output_file_name
+   */
   static void GenerateRevokeCert(const GpgKey& key,
                                  const std::string& output_file_name);
 
+  /**
+   * @brief
+   *
+   * @param key
+   * @return GpgFrontend::GpgError
+   */
   GpgFrontend::GpgError ModifyPassword(const GpgKey& key);
 
+  /**
+   * @brief
+   *
+   * @param key
+   * @param tofu_policy
+   * @return GpgFrontend::GpgError
+   */
   GpgFrontend::GpgError ModifyTOFUPolicy(const GpgKey& key,
                                          gpgme_tofu_policy_t tofu_policy);
-
+  /**
+   * @brief
+   *
+   * @param params
+   * @param result
+   * @return GpgFrontend::GpgError
+   */
   GpgFrontend::GpgError GenerateKey(const std::unique_ptr<GenKeyInfo>& params,
                                     GpgGenKeyResult& result);
 
+  /**
+   * @brief
+   *
+   * @param key
+   * @param params
+   * @return GpgFrontend::GpgError
+   */
   GpgFrontend::GpgError GenerateSubkey(
       const GpgKey& key, const std::unique_ptr<GenKeyInfo>& params);
 
  private:
-  GpgContext& ctx =
-      GpgContext::GetInstance(SingletonFunctionObject::GetChannel());
+  GpgContext& ctx_ =
+      GpgContext::GetInstance(SingletonFunctionObject::GetChannel());  ///<
 };
 }  // namespace GpgFrontend
 
diff --git a/src/gpg/function/UidOperator.cpp b/src/gpg/function/UIDOperator.cpp
index d7acc3b1..8c8f5c27 100644
--- a/src/gpg/function/UidOperator.cpp
+++ b/src/gpg/function/UIDOperator.cpp
@@ -22,43 +22,43 @@
  *
  */
 
-#include "gpg/function/UidOperator.h"
+#include "gpg/function/UIDOperator.h"
 
 #include "boost/format.hpp"
 
-bool GpgFrontend::UidOperator::addUID(const GpgFrontend::GpgKey& key,
+bool GpgFrontend::UIDOperator::AddUID(const GpgFrontend::GpgKey& key,
                                       const std::string& uid) {
-  auto err = gpgme_op_adduid(ctx, gpgme_key_t(key), uid.c_str(), 0);
+  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)
     return true;
   else
     return false;
 }
 
-bool GpgFrontend::UidOperator::revUID(const GpgFrontend::GpgKey& key,
+bool GpgFrontend::UIDOperator::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));
+      check_gpg_error(gpgme_op_revuid(ctx_, gpgme_key_t(key), uid.c_str(), 0));
   if (check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR)
     return true;
   else
     return false;
 }
 
-bool GpgFrontend::UidOperator::setPrimaryUID(const GpgFrontend::GpgKey& key,
+bool GpgFrontend::UIDOperator::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));
+      ctx_, gpgme_key_t(key), uid.c_str(), "primary", nullptr));
   if (check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR)
     return true;
   else
     return false;
 }
-bool GpgFrontend::UidOperator::addUID(const GpgFrontend::GpgKey& key,
+bool GpgFrontend::UIDOperator::AddUID(const GpgFrontend::GpgKey& key,
                                       const std::string& name,
                                       const std::string& comment,
                                       const std::string& email) {
-  LOG(INFO) << "GpgFrontend::UidOperator::addUID" << name << comment << email;
+  LOG(INFO) << "GpgFrontend::UidOperator::AddUID" << name << comment << email;
   auto uid = boost::format("%1%(%2%)<%3%>") % name % comment % email;
-  return addUID(key, uid.str());
+  return AddUID(key, uid.str());
 }
diff --git a/src/gpg/function/UidOperator.h b/src/gpg/function/UIDOperator.h
index d1a92b38..a68fb0e9 100644
--- a/src/gpg/function/UidOperator.h
+++ b/src/gpg/function/UIDOperator.h
@@ -29,12 +29,15 @@
 #include "gpg/GpgModel.h"
 
 namespace GpgFrontend {
-
-class UidOperator : public SingletonFunctionObject<UidOperator> {
+/**
+ * @brief
+ *
+ */
+class UIDOperator : public SingletonFunctionObject<UIDOperator> {
  public:
-  explicit UidOperator(
+  explicit UIDOperator(
       int channel = SingletonFunctionObject::GetDefaultChannel())
-      : SingletonFunctionObject<UidOperator>(channel) {}
+      : SingletonFunctionObject<UIDOperator>(channel) {}
 
   /**
    * create a new uid in certain key pair
@@ -42,7 +45,7 @@ class UidOperator : public SingletonFunctionObject<UidOperator> {
    * @param uid uid args(combine name&comment&email)
    * @return if successful
    */
-  bool addUID(const GpgKey& key, const std::string& uid);
+  bool AddUID(const GpgKey& key, const std::string& uid);
 
   /**
    * create a new uid in certain key pair
@@ -52,7 +55,7 @@ class UidOperator : public SingletonFunctionObject<UidOperator> {
    * @param email
    * @return
    */
-  bool addUID(const GpgKey& key, const std::string& name,
+  bool AddUID(const GpgKey& key, const std::string& name,
               const std::string& comment, const std::string& email);
 
   /**
@@ -61,7 +64,7 @@ class UidOperator : public SingletonFunctionObject<UidOperator> {
    * @param uid target uid
    * @return if successful
    */
-  bool revUID(const GpgKey& key, const std::string& uid);
+  bool RevUID(const GpgKey& key, const std::string& uid);
 
   /**
    * Set one of a uid of a key pair as primary
@@ -69,11 +72,11 @@ class UidOperator : public SingletonFunctionObject<UidOperator> {
    * @param uid target uid
    * @return if successful
    */
-  bool setPrimaryUID(const GpgKey& key, const std::string& uid);
+  bool SetPrimaryUID(const GpgKey& key, const std::string& uid);
 
  private:
-  GpgContext& ctx =
-      GpgContext::GetInstance(SingletonFunctionObject::GetChannel());
+  GpgContext& ctx_ =
+      GpgContext::GetInstance(SingletonFunctionObject::GetChannel());  ///<
 };
 
 }  // namespace GpgFrontend
diff --git a/src/ui/keypair_details/KeyNewUIDDialog.cpp b/src/ui/keypair_details/KeyNewUIDDialog.cpp
index 809a05f8..a4f2bd74 100644
--- a/src/ui/keypair_details/KeyNewUIDDialog.cpp
+++ b/src/ui/keypair_details/KeyNewUIDDialog.cpp
@@ -25,7 +25,7 @@
 #include "ui/keypair_details/KeyNewUIDDialog.h"
 
 #include "gpg/function/GpgKeyGetter.h"
-#include "gpg/function/UidOperator.h"
+#include "gpg/function/UIDOperator.h"
 #include "ui/SignalStation.h"
 
 namespace GpgFrontend::UI {
@@ -81,7 +81,7 @@ void KeyNewUIDDialog::slotCreateNewUID() {
   }
   auto error_string = error_stream.str();
   if (error_string.empty()) {
-    if (UidOperator::GetInstance().addUID(mKey, name->text().toStdString(),
+    if (UIDOperator::GetInstance().AddUID(mKey, 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 92a3c3ea..961068e5 100644
--- a/src/ui/keypair_details/KeyPairUIDTab.cpp
+++ b/src/ui/keypair_details/KeyPairUIDTab.cpp
@@ -26,7 +26,7 @@
 
 #include "gpg/function/GpgKeyGetter.h"
 #include "gpg/function/GpgKeyManager.h"
-#include "gpg/function/UidOperator.h"
+#include "gpg/function/UIDOperator.h"
 #include "ui/SignalStation.h"
 #include "ui/widgets/TOFUInfoPage.h"
 
@@ -376,7 +376,7 @@ void KeyPairUIDTab::slotDelUID() {
   if (ret == QMessageBox::Yes) {
     for (const auto& uid : *selected_uids) {
       LOG(INFO) << "KeyPairUIDTab::slotDelUID UID" << uid;
-      if (!UidOperator::GetInstance().revUID(mKey, uid)) {
+      if (!UIDOperator::GetInstance().RevUID(mKey, uid)) {
         QMessageBox::critical(
             nullptr, _("Operation Failed"),
             QString(_("An error occurred during the delete %1 operation."))
@@ -411,7 +411,7 @@ void KeyPairUIDTab::slotSetPrimaryUID() {
       QMessageBox::No | QMessageBox::Yes);
 
   if (ret == QMessageBox::Yes) {
-    if (!UidOperator::GetInstance().setPrimaryUID(mKey,
+    if (!UIDOperator::GetInstance().SetPrimaryUID(mKey,
                                                   selected_uids->front())) {
       QMessageBox::critical(nullptr, _("Operation Failed"),
                             _("An error occurred during the operation."));
@@ -510,7 +510,7 @@ void KeyPairUIDTab::slotDelUIDSingle() {
       QMessageBox::No | QMessageBox::Yes);
 
   if (ret == QMessageBox::Yes) {
-    if (!UidOperator::GetInstance().revUID(mKey, selected_uids->front())) {
+    if (!UIDOperator::GetInstance().RevUID(mKey, selected_uids->front())) {
       QMessageBox::critical(nullptr, _("Operation Failed"),
                             _("An error occurred during the operation."));
     } else {
@@ -562,7 +562,7 @@ void KeyPairUIDTab::slotDelSign() {
                            QMessageBox::No | QMessageBox::Yes);
 
   if (ret == QMessageBox::Yes) {
-    if (!GpgKeyManager::GetInstance().revSign(mKey, selected_signs)) {
+    if (!GpgKeyManager::GetInstance().RevSign(mKey, selected_signs)) {
       QMessageBox::critical(nullptr, _("Operation Failed"),
                             _("An error occurred during the operation."));
     }
diff --git a/src/ui/keypair_details/KeyUIDSignDialog.cpp b/src/ui/keypair_details/KeyUIDSignDialog.cpp
index b43a119e..c872eb12 100644
--- a/src/ui/keypair_details/KeyUIDSignDialog.cpp
+++ b/src/ui/keypair_details/KeyUIDSignDialog.cpp
@@ -111,7 +111,7 @@ void KeyUIDSignDialog::slotSignKey(bool clicked) {
   for (const auto& uid : *mUids) {
     LOG(INFO) << "Sign UID" << uid;
     // Sign For mKey
-    if (!GpgKeyManager::GetInstance().signKey(mKey, *keys, uid, expires)) {
+    if (!GpgKeyManager::GetInstance().SignKey(mKey, *keys, uid, expires)) {
       QMessageBox::critical(
           nullptr, _("Unsuccessful Operation"),
           QString(_("Signature operation failed for UID %1")).arg(uid.c_str()));