chore: use iwyu on ciphers/**.cpp

Author: realstealthninja

ciphers/a1z26_cipher.cpp

@@ -9,14 +9,16 @@
  * @author [Focusucof](https://github.com/Focusucof)
  */
 
-#include <algorithm>  /// for std::transform and std::replace
-#include <cassert>    /// for assert
-#include <cstdint>    /// for uint8_t
-#include <iostream>   /// for IO operations
-#include <map>        /// for std::map
-#include <sstream>    /// for std::stringstream
-#include <string>     /// for std::string
-#include <vector>     /// for std::vector
+#include <ctype.h>    // for tolower, toupper
+#include <algorithm>  // for replace, transform
+#include <cassert>    // for assert
+#include <cstdint>    // for uint8_t
+#include <iostream>   // for basic_ostream, operator<<, basic_istream, cout
+#include <map>        // for map
+#include <sstream>    // for basic_stringstream
+#include <string>     // for basic_string, char_traits, operator<<, string
+#include <vector>     // for vector
+#include <utility>    // for pair
 
 /**
  * @namespace ciphers

ciphers/atbash_cipher.cpp

@@ -12,10 +12,11 @@
  *
  * @author [Focusucof](https://github.com/Focusucof)
  */
-#include <cassert>   /// for assert
-#include <iostream>  /// for IO operations
-#include <map>       /// for std::map
-#include <string>    /// for std::string
+#include <cassert>   // for assert
+#include <iostream>  // for basic_ostream, operator<<, cout, endl
+#include <map>       // for map
+#include <string>    // for basic_string, char_traits, allocator, operator<<
+#include <utility>   // for pair
 
 /** \namespace ciphers
  * \brief Algorithms for encryption and decryption

ciphers/base64_encoding.cpp

@@ -11,10 +11,9 @@
  * digits.
  * @author [Ashish Daulatabad](https://github.com/AshishYUO)
  */
-#include <array>     /// for `std::array`
-#include <cassert>   /// for `assert` operations
-#include <cstdint>   /// for integral typedefs
-#include <iostream>  /// for IO operations
+#include <cassert>  // for assert
+#include <cstdint>  // for uint32_t, uint8_t
+#include <string>   // for basic_string, allocator, string, char_traits, ope...
 
 /**
  * @namespace ciphers

ciphers/elliptic_curve_key_exchange.cpp

@@ -21,10 +21,12 @@
  * alicePubKey * bobPrivKey = bobPubKey * alicePrivKey = secret
  * @author [Ashish Daulatabad](https://github.com/AshishYUO)
  */
-#include <cassert>   /// for assert
-#include <iostream>  /// for IO operations
+#include <cassert>        // for assert
+#include <iostream>       // for basic_ostream, operator<<, char_traits, cout
+#include <string>         // for basic_string
 
-#include "uint256_t.hpp"  /// for 256-bit integer
+#include "uint256_t.hpp"  // for uint256_t, operator<<
+#include "uint128_t.hpp"  // for uint128_t
 
 /**
  * @namespace ciphers

ciphers/morse_code.cpp

@@ -11,10 +11,11 @@
  * and dashes or dits and dahs. Morse code is named after Samuel Morse, an
  * inventor of the telegraph.
  */
-#include <cassert>
-#include <iostream>
-#include <string>
-#include <vector>
+#include <cassert>   // for assert
+#include <iostream>  // for basic_ostream, operator<<, endl, cout, cerr
+#include <string>    // for basic_string, operator==, char_traits, string
+#include <vector>    // for vector
+#include <cstdlib>   // for exit, size_t
 
 /** \namespace ciphers
  * \brief Algorithms for encryption and decryption

ciphers/vigenere_cipher.cpp

@@ -1,109 +1,126 @@
 /**
  * @file vigenere_cipher.cpp
- * @brief Implementation of [Vigenère cipher](https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher) algorithm.
+ * @brief Implementation of [Vigenère
+ * cipher](https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher) algorithm.
  *
  * @details
- * The Vigenère cipher is a method of encrypting alphabetic text by using a series of interwoven vigenere 
- * ciphers, based on the letters of a keyword. It employs a form of polyalphabetic substitution. 
+ * The Vigenère cipher is a method of encrypting alphabetic text by using a
+ * series of interwoven vigenere ciphers, based on the letters of a keyword. It
+ * employs a form of polyalphabetic substitution.
  *
  * ### Algorithm
- * The encryption can also be represented using modular arithmetic by first transforming 
- * the letters into numbers, according to the scheme, A → 0, B → 1, ..., Z → 25.
- * Encryption of \f$i^{th}\f$ character in Message M by key K can be described mathematically as,
- * 
+ * The encryption can also be represented using modular arithmetic by first
+ * transforming the letters into numbers, according to the scheme, A → 0, B → 1,
+ * ..., Z → 25. Encryption of \f$i^{th}\f$ character in Message M by key K can
+ * be described mathematically as,
+ *
  * \f[ E_{K}(M_{i}) = (M_{i} + K_{i})\;\mbox{mod}\; 26\f]
- * 
- * while decryption of \f$i^{th}\f$ character in Cipher C by key K can be described mathematically as,
+ *
+ * while decryption of \f$i^{th}\f$ character in Cipher C by key K can be
+ * described mathematically as,
  *
  * \f[ D_{k}(C_{i}) = (C_{i} - K_{i} + 26)\;\mbox{mod}\; 26\f]
- * 
- * Where \f$K_{i}\f$ denotes corresponding character in key. If \f$|key| < |text|\f$ than
- * same key is repeated untill their lengths are equal.
- * 
+ *
+ * Where \f$K_{i}\f$ denotes corresponding character in key. If \f$|key| <
+ * |text|\f$ than same key is repeated untill their lengths are equal.
+ *
  * For Example,
  * If M = "ATTACKATDAWN" and K = "LEMON" than K becomes "LEMONLEMONLE".
- * 
- * \note Rather than creating new key of equal length this program does this by using modular index for key
- * (i.e. \f$(j + 1) \;\mbox{mod}\; |\mbox{key}|\f$)
- * 
- * \note This program implements Vigenère cipher for only uppercase English alphabet characters (i.e. A-Z). 
- * 
+ *
+ * \note Rather than creating new key of equal length this program does this by
+ * using modular index for key (i.e. \f$(j + 1) \;\mbox{mod}\; |\mbox{key}|\f$)
+ *
+ * \note This program implements Vigenère cipher for only uppercase English
+ * alphabet characters (i.e. A-Z).
+ *
  * @author [Deep Raval](https://github.com/imdeep2905)
  */
-#include <iostream>
-#include <string>
-#include <cassert>
+#include <cassert>   // for assert
+#include <cstddef>   // for size_t
+#include <iostream>  // for basic_ostream, operator<<, cout, endl
+#include <string>    // for basic_string, char_traits, string, operator<<
 
 /** \namespace ciphers
  * \brief Algorithms for encryption and decryption
  */
 namespace ciphers {
-    /** \namespace vigenere
-     * \brief Functions for [vigenère cipher](https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher) algorithm.
-     */
-    namespace vigenere {   
-        namespace {
-            /**
-             * This function finds character for given value (i.e.A-Z)
-             * @param x value for which we want character 
-             * @return  corresponding character for perticular value
-             */        
-            inline char get_char(const int x) {
-                // By adding 65 we are scaling 0-25 to 65-90. 
-                // Which are in fact ASCII values of A-Z. 
-                return char(x + 65); 
-            }
-            /**
-             * This function finds value for given character (i.e.0-25)
-             * @param c character for which we want value
-             * @return returns corresponding value for perticular character
-             */  
-            inline int get_value(const char c) {
-                // A-Z have ASCII values in range 65-90.
-                // Hence subtracting 65 will scale them to 0-25.
-                return int(c - 65);
-            }
-        } // Unnamed namespace
-        /**
-         * Encrypt given text using vigenere cipher.
-         * @param text text to be encrypted
-         * @param key to be used for encryption
-         * @return new encrypted text
-         */
-        std::string encrypt (const std::string &text, const std::string &key) {
-            std::string encrypted_text = ""; // Empty string to store encrypted text
-            // Going through each character of text and key
-            // Note that key is visited in circular way hence  j = (j + 1) % |key|
-            for(size_t i = 0, j = 0; i < text.length(); i++, j = (j + 1) % key.length()) {
-                int place_value_text = get_value(text[i]); // Getting value of character in text
-                int place_value_key = get_value(key[j]); // Getting value of character in key
-                place_value_text = (place_value_text + place_value_key) % 26; // Applying encryption
-                char encrypted_char = get_char(place_value_text); // Getting new character from encrypted value
-                encrypted_text += encrypted_char; // Appending encrypted character
-            }
-            return encrypted_text; // Returning encrypted text
-        }
-        /**
-         * Decrypt given text using vigenere cipher.
-         * @param text text to be decrypted
-         * @param key key to be used for decryption
-         * @return new decrypted text
-         */        
-        std::string decrypt (const std::string &text, const std::string &key) {
-            // Going through each character of text and key
-            // Note that key is visited in circular way hence  j = (j + 1) % |key|
-            std::string decrypted_text = ""; // Empty string to store decrypted text
-            for(size_t i = 0, j = 0; i < text.length(); i++, j = (j + 1) % key.length()) {
-                int place_value_text = get_value(text[i]); // Getting value of character in text
-                int place_value_key = get_value(key[j]); // Getting value of character in key
-                place_value_text = (place_value_text - place_value_key + 26) % 26; // Applying decryption
-                char decrypted_char = get_char(place_value_text); // Getting new character from decrypted value
-                decrypted_text += decrypted_char; // Appending decrypted character
-            }        
-            return decrypted_text; // Returning decrypted text
-        }
-    } // namespace vigenere
-} // namespace ciphers
+/** \namespace vigenere
+ * \brief Functions for [vigenère
+ * cipher](https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher) algorithm.
+ */
+namespace vigenere {
+namespace {
+/**
+ * This function finds character for given value (i.e.A-Z)
+ * @param x value for which we want character
+ * @return  corresponding character for perticular value
+ */
+inline char get_char(const int x) {
+    // By adding 65 we are scaling 0-25 to 65-90.
+    // Which are in fact ASCII values of A-Z.
+    return char(x + 65);
+}
+/**
+ * This function finds value for given character (i.e.0-25)
+ * @param c character for which we want value
+ * @return returns corresponding value for perticular character
+ */
+inline int get_value(const char c) {
+    // A-Z have ASCII values in range 65-90.
+    // Hence subtracting 65 will scale them to 0-25.
+    return int(c - 65);
+}
+}  // Unnamed namespace
+/**
+ * Encrypt given text using vigenere cipher.
+ * @param text text to be encrypted
+ * @param key to be used for encryption
+ * @return new encrypted text
+ */
+std::string encrypt(const std::string &text, const std::string &key) {
+    std::string encrypted_text = "";  // Empty string to store encrypted text
+    // Going through each character of text and key
+    // Note that key is visited in circular way hence  j = (j + 1) % |key|
+    for (size_t i = 0, j = 0; i < text.length();
+         i++, j = (j + 1) % key.length()) {
+        int place_value_text =
+            get_value(text[i]);  // Getting value of character in text
+        int place_value_key =
+            get_value(key[j]);  // Getting value of character in key
+        place_value_text =
+            (place_value_text + place_value_key) % 26;  // Applying encryption
+        char encrypted_char = get_char(
+            place_value_text);  // Getting new character from encrypted value
+        encrypted_text += encrypted_char;  // Appending encrypted character
+    }
+    return encrypted_text;  // Returning encrypted text
+}
+/**
+ * Decrypt given text using vigenere cipher.
+ * @param text text to be decrypted
+ * @param key key to be used for decryption
+ * @return new decrypted text
+ */
+std::string decrypt(const std::string &text, const std::string &key) {
+    // Going through each character of text and key
+    // Note that key is visited in circular way hence  j = (j + 1) % |key|
+    std::string decrypted_text = "";  // Empty string to store decrypted text
+    for (size_t i = 0, j = 0; i < text.length();
+         i++, j = (j + 1) % key.length()) {
+        int place_value_text =
+            get_value(text[i]);  // Getting value of character in text
+        int place_value_key =
+            get_value(key[j]);  // Getting value of character in key
+        place_value_text = (place_value_text - place_value_key + 26) %
+                           26;  // Applying decryption
+        char decrypted_char = get_char(
+            place_value_text);  // Getting new character from decrypted value
+        decrypted_text += decrypted_char;  // Appending decrypted character
+    }
+    return decrypted_text;  // Returning decrypted text
+}
+}  // namespace vigenere
+}  // namespace ciphers
 
 /**
  * Function to test above algorithm
@@ -116,15 +133,15 @@ void test() {
     assert(text1 == decrypted1);
     std::cout << "Original text : " << text1;
     std::cout << " , Encrypted text (with key = TESLA) : " << encrypted1;
-    std::cout << " , Decrypted text : "<< decrypted1 << std::endl;
+    std::cout << " , Decrypted text : " << decrypted1 << std::endl;
     // Test 2
     std::string text2 = "GOOGLEIT";
     std::string encrypted2 = ciphers::vigenere::encrypt(text2, "REALLY");
     std::string decrypted2 = ciphers::vigenere::decrypt(encrypted2, "REALLY");
     assert(text2 == decrypted2);
     std::cout << "Original text : " << text2;
     std::cout << " , Encrypted text (with key = REALLY) : " << encrypted2;
-    std::cout << " , Decrypted text : "<< decrypted2 << std::endl;
+    std::cout << " , Decrypted text : " << decrypted2 << std::endl;
 }
 
 /** Driver Code */