<doc>(core): Start adding comments to code

3 files changed, 122 insertions, 23 deletions

diff --git a/src/gpg/function/BasicOperator.cpp b/src/gpg/function/BasicOperator.cpp
index 0383f8ab..4f88b34f 100644
--- a/src/gpg/function/BasicOperator.cpp
+++ b/src/gpg/function/BasicOperator.cpp
@@ -75,7 +75,7 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Verify(
     BypeArrayRef& in_buffer, ByteArrayPtr& sig_buffer,
     GpgVerifyResult& result) const {
   gpgme_error_t err;
-  
+
   GpgData data_in(in_buffer.data(), in_buffer.size());
   GpgData data_out;
 
@@ -91,7 +91,7 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Verify(
   return err;
 }
 
-GpgFrontend::GpgError GpgFrontend::BasicOperator::Sign(KeyListPtr keys,
+GpgFrontend::GpgError GpgFrontend::BasicOperator::Sign(KeyListPtr signers,
                                                        BypeArrayRef in_buffer,
                                                        ByteArrayPtr& out_buffer,
                                                        gpgme_sig_mode_t mode,
@@ -99,23 +99,10 @@ GpgFrontend::GpgError GpgFrontend::BasicOperator::Sign(KeyListPtr keys,
   gpgme_error_t err;
 
   // Set Singers of this opera
-  SetSigners(*keys);
+  SetSigners(*signers);
 
   GpgData data_in(in_buffer.data(), in_buffer.size()), data_out;
 
-  /**
-      `GPGME_SIG_MODE_NORMAL'
-            A normal signature is made, the output includes the plaintext
-            and the signature.
-
-      `GPGME_SIG_MODE_DETACH'
-            A detached signature is made.
-
-      `GPGME_SIG_MODE_CLEAR'
-            A clear text signature is made.  The ASCII armor and text
-            mode settings of the context are ignored.
-  */
-
   err = check_gpg_error(gpgme_op_sign(ctx, data_in, data_out, mode));
 
   auto temp_data_out = data_out.Read2Buffer();
@@ -183,9 +170,9 @@ gpgme_error_t GpgFrontend::BasicOperator::EncryptSign(
   return err;
 }
 
-void GpgFrontend::BasicOperator::SetSigners(KeyArgsList& keys) {
+void GpgFrontend::BasicOperator::SetSigners(KeyArgsList& signers) {
   gpgme_signers_clear(ctx);
-  for (const GpgKey& key : keys) {
+  for (const GpgKey& key : signers) {
     DLOG(INFO) << "key" << key.fpr();
     if (key.CanSignActual()) {
       DLOG(INFO) << "signer";
@@ -193,7 +180,7 @@ void GpgFrontend::BasicOperator::SetSigners(KeyArgsList& keys) {
       check_gpg_error(error);
     }
   }
-  if (keys.size() != gpgme_signers_count(ctx))
+  if (signers.size() != gpgme_signers_count(ctx))
     DLOG(INFO) << "No All Signers Added";
 }
 
@@ -207,6 +194,7 @@ GpgFrontend::BasicOperator::GetSigners() {
   }
   return signers;
 }
+
 gpg_error_t GpgFrontend::BasicOperator::EncryptSymmetric(
     GpgFrontend::ByteArray& in_buffer, GpgFrontend::ByteArrayPtr& out_buffer,
     GpgFrontend::GpgEncrResult& result) {
diff --git a/src/gpg/function/BasicOperator.h b/src/gpg/function/BasicOperator.h
index 41bd9b7f..440e6e1f 100644
--- a/src/gpg/function/BasicOperator.h
+++ b/src/gpg/function/BasicOperator.h
@@ -32,44 +32,143 @@
 
 namespace GpgFrontend {
 
+/**
+ * @brief Basic operation collection
+ *
+ */
 class BasicOperator : public SingletonFunctionObject<BasicOperator> {
  public:
+  /**
+   * @brief Construct a new Basic Operator object
+   *
+   * @param channel Channel corresponding to the context
+   */
   explicit BasicOperator(
       int channel = SingletonFunctionObject::GetDefaultChannel())
       : SingletonFunctionObject<BasicOperator>(channel) {}
 
+  /**
+   * @brief Call the interface provided by gpgme for encryption operation
+   *
+   * All incoming data pointers out_buffer will be replaced with new valid
+   * values
+   *
+   * @param keys list of public keys
+   * @param in_buffer data that needs to be encrypted
+   * @param out_buffer encrypted data
+   * @param result the result of the operation
+   * @return error code
+   */
   gpg_error_t Encrypt(KeyListPtr keys, BypeArrayRef in_buffer,
                       ByteArrayPtr& out_buffer, GpgEncrResult& result);
 
+  /**
+   * @brief Call the interface provided by GPGME to symmetrical encryption
+   *
+   * @param in_buffer Data for encryption
+   * @param out_buffer Encrypted data
+   * @param result Encrypted results
+   * @return gpg_error_t
+   */
   gpg_error_t EncryptSymmetric(BypeArrayRef in_buffer, ByteArrayPtr& out_buffer,
                                GpgEncrResult& result);
 
+  /**
+   *
+   * @brief  Call the interface provided by gpgme to perform encryption and
+   * signature operations at the same time.
+   *
+   * @param keys List of public keys
+   * @param signers Private key for signatures
+   * @param in_buffer Data for operation
+   * @param out_buffer Encrypted data
+   * @param encr_result Encrypted results
+   * @param sign_result Signature result
+   * @return
+   */
   gpgme_error_t EncryptSign(KeyListPtr keys, KeyListPtr signers,
                             BypeArrayRef in_buffer, ByteArrayPtr& out_buffer,
                             GpgEncrResult& encr_result,
                             GpgSignResult& sign_result);
 
+  /**
+   * @brief Call the interface provided by gpgme for decryption operation
+   *
+   * @param in_buffer data that needs to be decrypted
+   * @param out_buffer decrypted data
+   * @param result the result of the operation
+   * @return error code
+   */
   gpgme_error_t Decrypt(BypeArrayRef in_buffer, ByteArrayPtr& out_buffer,
                         GpgDecrResult& result);
 
+  /**
+   * @brief  Call the interface provided by gpgme to perform decryption and
+   * verification operations at the same time.
+   *
+   * @param in_buffer data to be manipulated
+   * @param out_buffer data resulting from decryption operation
+   * @param decrypt_result the result of the decrypting operation
+   * @param verify_result the result of the verifying operation
+   * @return error code
+   */
   gpgme_error_t DecryptVerify(BypeArrayRef in_buffer, ByteArrayPtr& out_buffer,
                               GpgDecrResult& decrypt_result,
                               GpgVerifyResult& verify_result);
 
+  /**
+   * @brief Call the interface provided by gpgme for verification operation
+   *
+   * @param in_buffer data that needs to be verified
+   * @param out_buffer verified data
+   * @param result the result of the operation
+   * @return error code
+   */
   gpgme_error_t Verify(BypeArrayRef in_buffer, ByteArrayPtr& sig_buffer,
                        GpgVerifyResult& result) const;
 
-  gpg_error_t Sign(KeyListPtr keys, BypeArrayRef in_buffer,
+  /**
+   * @brief  Call the interface provided by gpgme for signing operation
+   *
+   * The signing modes are as follows:
+   * `GPGME_SIG_MODE_NORMAL'
+   *      A normal signature is made, the output includes the plaintext and the
+   *      signature.
+   * `GPGME_SIG_MODE_DETACH'
+   *      A detached signature is made.
+   * `GPGME_SIG_MODE_CLEAR'
+   *      A clear text signature is made. The ASCII armor and text mode settings
+   *      of the context are ignored.
+   *
+   * @param signers private keys for signing operations
+   * @param in_buffer data that needs to be signed
+   * @param out_buffer verified data
+   * @param mode signing mode
+   * @param result the result of the operation
+   * @return error code
+   */
+  gpg_error_t Sign(KeyListPtr signers, BypeArrayRef in_buffer,
                    ByteArrayPtr& out_buffer, gpgme_sig_mode_t mode,
                    GpgSignResult& result);
 
-  void SetSigners(KeyArgsList& keys);
+  /**
+   * @brief  Set the private key for signatures, this operation is a global
+   * operation.
+   *
+   * @param keys
+   */
+  void SetSigners(KeyArgsList& signers);
 
+  /**
+   * @brief Get a global signature private keys that has been set.
+   *
+   * @return Intelligent pointer pointing to the private key list
+   */
   std::unique_ptr<KeyArgsList> GetSigners();
 
  private:
-  GpgContext& ctx =
-      GpgContext::GetInstance(SingletonFunctionObject::GetChannel());
+  GpgContext& ctx = GpgContext::GetInstance(
+      SingletonFunctionObject::GetChannel());  ///< Corresponding context
 };
 }  // namespace GpgFrontend
 
diff --git a/src/gpg/function/GpgCommandExecutor.h b/src/gpg/function/GpgCommandExecutor.h
index dcdd318d..6979d5f6 100644
--- a/src/gpg/function/GpgCommandExecutor.h
+++ b/src/gpg/function/GpgCommandExecutor.h
@@ -33,6 +33,11 @@
 #include "gpg/GpgFunctionObject.h"
 
 namespace GpgFrontend {
+
+/**
+ * @brief
+ *
+ */
 class GpgCommandExecutor : public SingletonFunctionObject<GpgCommandExecutor> {
  public:
   explicit GpgCommandExecutor(
@@ -40,6 +45,13 @@ class GpgCommandExecutor : public SingletonFunctionObject<GpgCommandExecutor> {
       : SingletonFunctionObject<GpgCommandExecutor>(channel) {}
 
 #ifndef WINDOWS
+
+  /**
+   * @brief
+   *
+   * @param arguments
+   * @param interact_func
+   */
   void Execute(StringArgsRef arguments,
                const std::function<void(boost::process::async_pipe &in,
                                         boost::process::async_pipe &out)>