morse_code.cpp File Reference

Implementation of Morse Code. More...

`#include <cassert>`
`#include <iostream>`
`#include <string>`
`#include <vector>`
Include dependency graph for morse_code.cpp:

## Namespaces

| ciphers
| Algorithms for encryption and decryption.
| morse
| Functions for Morse Code.

## Functions

std::string | ciphers::morse::char_to_morse (const char &c)
char | ciphers::morse::morse_to_char (const std::string &s)
std::string | ciphers::morse::encrypt (const std::string &text)
std::string | ciphers::morse::decrypt (const std::string &text)
static void | test ()
| Function to test above algorithm. More...
int | main ()
| Main function. More...

## Detailed Description

Implementation of Morse Code.

Author
  Deep Raval

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.

## Function Documentation

## char_to_morse()

std::string ciphers::morse::char_to_morse | ( | const char & | c | ) |

Get the morse representation for given character.

Parameters

  c | Character

Returns
  morse representation string of character

{
// 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);
}
}
std::cerr
std::endl
T endl(T... args)
std::exit
T exit(T... args)
Here is the call graph for this function:

## decrypt()

std::string ciphers::morse::decrypt | ( | const std::string & | text | ) |

Decrypt given morse coded text.

Parameters

  text | text to be decrypted

Returns
  new decrypted 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
}
std::string
std::string::find
T find(T... args)
ciphers::morse::morse_to_char
char morse_to_char(const std::string &s)
Definition: morse_code.cpp:118
std::vector::push_back
T push_back(T... args)
std::size_t
std::string::substr
T substr(T... args)
std::vector
Here is the call graph for this function:

## encrypt()

std::string ciphers::morse::encrypt | ( | const std::string & | text | ) |

Encrypt given text using morse code.

Parameters

  text | text to be encrypted

Returns
  new encrypted 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
}
ciphers::morse::char_to_morse
std::string char_to_morse(const char &c)
Definition: morse_code.cpp:33
Here is the call graph for this function:

## main()

int main | ( | void |  | ) |

Main function.

Returns
  0 on exit

{
// Testing
test();
return 0;
}
test
static void test()
Function to test above algorithm.
Definition: morse_code.cpp:245
Here is the call graph for this function:

## morse_to_char()

char ciphers::morse::morse_to_char | ( | const std::string & | s | ) |

Get character from the morse representation.

Parameters

  s | Morse representation

Returns
  corresponding character

{
// 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);
}
}
Here is the call graph for this function:

## test()

static void test | ( |  | ) |

static

Function to test above algorithm.

Returns
  void

{
// 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;
}
ciphers::morse::encrypt
std::string encrypt(const std::string &text)
Definition: morse_code.cpp:202
ciphers::morse::decrypt
std::string decrypt(const std::string &text)
Definition: morse_code.cpp:216
Here is the call graph for this function: