Struct Morse

pub struct Morse { /* private fields */ }

Main library struct.

All magic going here

Implementations

impl Morse

pub fn new( language: String, from_char: fn(_: char) -> MorseResult<Vec<MorseUnit>>, into_char: fn(_: Vec<MorseUnit>) -> MorseResult<char>, ) -> Morse

Creates extended Morse Code struct.

Examples

use morse_lib::{Morse, MorseUnit, MorseError, MorseResult};
use MorseUnit::{Dot, Line, Whitespace};

fn from_char(letter: char) -> MorseResult<Vec<MorseUnit>>{
    match letter {
        'a' => Ok(vec![Dot, Line]),
        'б' => Ok(vec![Line, Dot, Dot, Dot]),
        'в' => Ok(vec![Dot, Line, Line]),
        'г' => Ok(vec![Dot, Dot, Dot, Dot]),
        ' ' => Ok(vec![Whitespace]),
          _ => Err(MorseError::InvalidChar)
    }
}

fn into_char(letter: Vec<MorseUnit>) -> MorseResult<char> {
    if letter.len() == 1 && letter[0] == Whitespace {
        return Ok(' ');
    } else if letter.len() == 2 && letter[0] == Dot && letter[1] == Line {
        return Ok('а')
    } else if letter.len() == 3 && letter[0] == Dot && letter[1] == Line && letter[2] == Line {
        return Ok('в');
    } else if letter.len() == 4 {
        if letter[0] == Line && letter[1] == Dot && letter[2] == Dot && letter[3] == Dot {
            return Ok('б');
        } else {
            return Ok('г');
        }
    } else {
        Err(MorseError::InvalidMorseSequence)
    }
}

let morse = Morse::new("Ukrainian".to_string(), from_char, into_char);

pub fn from_int_text(text: &str) -> MorseResult<Morse>

Creates International Morse Code struct from text.

Examples

use morse_lib::Morse;

let morse = Morse::from_int_text("sos").unwrap();

assert_eq!(
       morse.to_string(),
       ". . .   ⚊ ⚊ ⚊   . . ."
   );

pub fn parse_text(&mut self, text: &str) -> MorseResult<()>

Parse text into Morse Code.

pub fn from_int_bin(bin: &str) -> MorseResult<Morse>

Creates International Morse Code struct from binary.

Examples

use morse_lib::Morse;

let morse = Morse::from_int_bin("101010001110111011100010101").unwrap();

assert_eq!(
       morse.to_string(),
       ". . .   ⚊ ⚊ ⚊   . . ."
   );

pub fn parse_bin(&mut self, bin: &str) -> MorseResult<()>

Parse binary into Morse Code.

pub fn to_beep(&self)

Play sound that represent Morse Code.

pub fn get_language(&self) -> String

Return String value that contains stored language label.

pub fn dot_as(&mut self, alias: &str)

Creates alias for dot in output string.

Examples

use morse_lib::Morse;

let mut morse = Morse::from_int_text("sos").unwrap();
morse.dot_as("🔥");

assert_eq!(
       morse.to_string(),
       "🔥 🔥 🔥   ⚊ ⚊ ⚊   🔥 🔥 🔥"
   );

pub fn line_as(&mut self, alias: &str)

Creates alias for line in output string.

Examples

use morse_lib::Morse;

let mut morse = Morse::from_int_text("sos").unwrap();
morse.line_as("➖");

assert_eq!(
       morse.to_string(),
       ". . .   ➖ ➖ ➖   . . ."
   );

pub fn whitespace_as(&mut self, alias: &str)

Creates alias for whitespace in output string.

Examples

use morse_lib::Morse;

let mut morse = Morse::from_int_text("s o").unwrap();
morse.whitespace_as("🚧");

assert_eq!(
       morse.to_string(),
       ". . .   🚧   ⚊ ⚊ ⚊"
   );

pub fn frequency(&mut self, frequency: f32)

Set sound frequency in MHz.

Examples

use morse_lib::Morse;

let mut morse = Morse::from_int_text("s o").unwrap();
morse.frequency(643.0);

pub fn play_speed(&mut self, speed: f32)

Set sound speed. 1 - normal speed

1 - faster < 1 - slower

Examples

use morse_lib::Morse;

let mut morse = Morse::from_int_text("s o").unwrap();
morse.play_speed(2.0);

pub fn to_bin_str(&self) -> String

Creates binary-formatted Morse Code.

Examples

use morse_lib::Morse;

let morse = Morse::from_int_text("sos").unwrap();

assert_eq!(
       morse.to_bin_str(),
       "101010001110111011100010101"
   );

pub fn to_text(&self) -> String

Convert Morse Code back to text.

Examples

use morse_lib::Morse;

let morse = Morse::from_int_bin("101010001110111011100010101").unwrap();
let text = morse.to_text();

assert_eq!(
       text,
       "sos"
   );

pub fn iter(&self) -> MorseIterator<'_>

Now we can iterate:

use morse_lib::Morse;

let morse = Morse::from_int_text("sos").unwrap();
for char in morse.iter() {
    println!("{}", char);
}

Trait Implementations

impl Clone for Morse

fn clone(&self) -> Morse

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Morse

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Morse

fn default() -> Self

Returns the “default value” for a type.

impl IntoIterator for Morse

fn into_iter(self) -> MorseIntoIterator

use morse_lib::Morse;

let morse = Morse::from_int_text("sos").unwrap();
for char in morse {
println!("{}", char);
}

type Item = MorseChar

The type of the elements being iterated over.

type IntoIter = MorseIntoIterator

Which kind of iterator are we turning this into?

impl PartialEq for Morse

fn eq(&self, other: &Morse) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToString for Morse

fn to_string(&self) -> String

Return String value of Morse Code.

impl StructuralPartialEq for Morse