C++, , morse_code.cpp

/**
 * @file
 * @author [Deep Raval](https://github.com/imdeep2905)
 *
 * @brief Implementation of [Morse Code]
 * (https://en.wikipedia.org/wiki/Morse_code).
 *
 * @details
 * Morse code is a method used in telecommunication to encode text characters
 * as standardized sequences of two different signal durations, called dots
 * 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>

/** \namespace ciphers
 * \brief Algorithms for encryption and decryption
 */
namespace ciphers {
/** \namespace morse
 * \brief Functions for [Morse Code]
 * (https://en.wikipedia.org/wiki/Morse_code).
 */
namespace morse {
/**
 * Get the morse representation for given character.
 * @param c Character
 * @returns morse representation string of character
 */
std::string char_to_morse(const char &c) {
    // return corresponding morse code
    switch (c) {
        case 'a':
            return ".-";
        case 'b':
            return "-...";
        case 'c':
            return "-.-.";
        case 'd':
            return "-..";
        case 'e':
            return ".";
        case 'f':
            return "..-.";
        case 'g':
            return "--.";
        case 'h':
            return "....";
        case 'i':
            return "..";
        case 'j':
            return ".---";
        case 'k':
            return "-.-";
        case 'l':
            return ".-..";
        case 'm':
            return "--";
        case 'n':
            return "-.";
        case 'o':
            return "---";
        case 'p':
            return ".--.";
        case 'q':
            return "--.-";
        case 'r':
            return ".-.";
        case 's':
            return "...";
        case 't':
            return "-";
        case 'u':
            return "..-";
        case 'v':
            return "...-";
        case 'w':
            return ".--";
        case 'x':
            return "-..-";
        case 'y':
            return "-.--";
        case 'z':
            return "--..";
        case '1':
            return ".----";
        case '2':
            return "..---";
        case '3':
            return "...--";
        case '4':
            return "....-";
        case '5':
            return ".....";
        case '6':
            return "-....";
        case '7':
            return "--...";
        case '8':
            return "---..";
        case '9':
            return "----.";
        case '0':
            return "-----";
        default:
            std::cerr << "Found invalid character: " << c << ' ' << std::endl;
            std::exit(0);
    }
}
/**
 * Get character from the morse representation.
 * @param s Morse representation
 * @returns corresponding character
 */
char morse_to_char(const std::string &s) {
    // return corresponding character
    if (s == ".-") {
        return 'a';
    } else if (s == "-...") {
        return 'b';
    } else if (s == "-.-.") {
        return 'c';
    } else if (s == "-..") {
        return 'd';
    } else if (s == ".") {
        return 'e';
    } else if (s == "..-.") {
        return 'f';
    } else if (s == "--.") {
        return 'g';
    } else if (s == "....") {
        return 'h';
    } else if (s == "..") {
        return 'i';
    } else if (s == ".---") {
        return 'j';
    } else if (s == "-.-") {
        return 'k';
    } else if (s == ".-..") {
        return 'l';
    } else if (s == "--") {
        return 'm';
    } else if (s == "-.") {
        return 'n';
    } else if (s == "---") {
        return 'o';
    } else if (s == ".--.") {
        return 'p';
    } else if (s == "--.-") {
        return 'q';
    } else if (s == ".-.") {
        return 'r';
    } else if (s == "...") {
        return 's';
    } else if (s == "-") {
        return 't';
    } else if (s == "..-") {
        return 'u';
    } else if (s == "...-") {
        return 'v';
    } else if (s == ".--") {
        return 'w';
    } else if (s == "-..-") {
        return 'x';
    } else if (s == "-.--") {
        return 'y';
    } else if (s == "--..") {
        return 'z';
    } else if (s == ".----") {
        return '1';
    } else if (s == "..---") {
        return '2';
    } else if (s == "...--") {
        return '3';
    } else if (s == "....-") {
        return '4';
    } else if (s == ".....") {
        return '5';
    } else if (s == "-....") {
        return '6';
    } else if (s == "--...") {
        return '7';
    } else if (s == "---..") {
        return '8';
    } else if (s == "----.") {
        return '9';
    } else if (s == "-----") {
        return '0';
    } else {
        std::cerr << "Found invalid Morse code: " << s << ' ' << std::endl;
        std::exit(0);
    }
}
/**
 * Encrypt given text using morse code.
 * @param text text to be encrypted
 * @returns new encrypted text
 */
std::string encrypt(const std::string &text) {
    std::string encrypted_text = "";  // Empty string to store encrypted text
    // Going through each character of text and converting it
    // to morse representation
    for (const char &c : text) {
        encrypted_text += ciphers::morse::char_to_morse(c) + " ";
    }
    return encrypted_text;  // Returning encrypted text
}
/**
 * Decrypt given morse coded text.
 * @param text text to be decrypted
 * @returns new decrypted text
 */
std::string decrypt(const std::string &text) {
    // Going through each character of text and converting it
    // back to normal representation.
    std::string decrypted_text = "";  // Empty string to store decrypted text
    // Spliting string (with delimiter = " ") and storing it
    // in vector
    std::size_t pos_start = 0, pos_end = 0, delim_len = 1;
    std::vector<std::string> splits;
    while ((pos_end = text.find(' ', pos_start)) != std::string::npos) {
        std::string token = text.substr(pos_start, pos_end - pos_start);
        pos_start = pos_end + delim_len;
        splits.push_back(token);
    }

    // Traversing through each morse code string
    for (const std::string &s : splits) {
        // Add corresponding character
        decrypted_text += ciphers::morse::morse_to_char(s);
    }

    return decrypted_text;  // Returning decrypted text
}
}  // namespace morse
}  // namespace ciphers

/**
 * @brief Function to test above algorithm
 * @returns void
 */
static void test() {
    // Test 1
    std::string text1 = "01234567890";
    std::string encrypted1 = ciphers::morse::encrypt(text1);
    std::string decrypted1 = ciphers::morse::decrypt(encrypted1);
    assert(text1 == decrypted1);
    std::cout << "Original text : " << text1 << std::endl;
    std::cout << "Encrypted text : " << encrypted1 << std::endl;
    std::cout << "Decrypted text : " << decrypted1 << std::endl;
    // Test 2
    std::string text2 = "abcdefghijklmnopqrstuvwxyz";
    std::string encrypted2 = ciphers::morse::encrypt(text2);
    std::string decrypted2 = ciphers::morse::decrypt(encrypted2);
    assert(text2 == decrypted2);
    std::cout << "Original text : " << text2 << std::endl;
    std::cout << "Encrypted text : " << encrypted2 << std::endl;
    std::cout << "Decrypted text : " << decrypted2 << std::endl;
}

/**
 * @brief Main function
 * @returns 0 on exit
 */
int main() {
    // Testing
    test();
    return 0;
}