Struct MorseCustom

pub struct MorseCustom { /* private fields */ }

Custom language Morse Code (feature).

Implementations

impl MorseCustom

pub fn new( from_char: fn(char) -> MorseResult<Vec<MorseUnit>>, into_char: fn(Vec<MorseUnit>) -> MorseResult<char>, ) -> MorseCustom

Creates custom language Morse Code struct.

Examples

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

fn from_char(letter: char) -> MorseResult<Vec<MorseUnit>>{
    match letter {
        'а' | 'А' => 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_ua = MorseCustom::new(from_char, into_char);

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

Creates alias for dot in output string.

Examples

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

fn from_char(letter: char) -> MorseResult<Vec<MorseUnit>>{
    match letter {
        'а' | 'А' => 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 mut morse = MorseCustom::new(from_char, into_char);

morse.parse_text("ба").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::{MorseCustom, MorseUnit, MorseError, MorseResult, TMorse};
use MorseUnit::{Dot, Line, Whitespace};

fn from_char(letter: char) -> MorseResult<Vec<MorseUnit>>{
    match letter {
        'а' | 'А' => 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 mut morse = MorseCustom::new( from_char, into_char);

morse.parse_text("ба").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::{MorseCustom, MorseUnit, MorseError, MorseResult, TMorse};
use MorseUnit::{Dot, Line, Whitespace};

fn from_char(letter: char) -> MorseResult<Vec<MorseUnit>>{
    match letter {
        'а' | 'А' => 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 mut morse = MorseCustom::new( from_char, into_char);

morse.parse_text("б а").unwrap();
morse.whitespace_as("🚧");

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

pub fn to_beep(&self)

Play sound that represent Morse Code.

Only available if “audio” feature is enabled.

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

Set sound frequency in MHz.

Only available if “audio” feature is enabled.

Examples

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

fn from_char(letter: char) -> MorseResult<Vec<MorseUnit>>{
    match letter {
        'а' | 'А' => 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 mut morse = MorseCustom::new(from_char, into_char);

morse.parse_text("б а").unwrap();
morse.frequency(643.0);

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

Set sound speed.

Only available if “audio” feature is enabled.

• ‘1’ - normal speed
• ‘> 1’ - faster
• ‘< 1’ - slower

Examples

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

fn from_char(letter: char) -> MorseResult<Vec<MorseUnit>>{
    match letter {
        'а' | 'А' => 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 mut morse = MorseCustom::new( from_char, into_char);

morse.parse_text("б а").unwrap();
morse.play_speed(2.0);

pub fn to_bin_str(&self) -> String

Creates binary-formatted Morse Code.

Examples

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

fn from_char(letter: char) -> MorseResult<Vec<MorseUnit>>{
    match letter {
        'а' | 'А' => 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 mut morse = MorseCustom::new(from_char, into_char);

morse.parse_text("б а").unwrap();

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

pub fn to_text(&self) -> String

Convert Morse Code back to text.

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

Trait Implementations

impl Clone for MorseCustom

fn clone(&self) -> MorseCustom

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MorseCustom

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

Formats the value using the given formatter.

impl Index<usize> for MorseCustom

type Output = MorseChar

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IntoIterator for MorseCustom

type Item = MorseChar

The type of the elements being iterated over.

type IntoIter = MorseIntoIterator

Which kind of iterator are we turning this into?

fn into_iter(self) -> MorseIntoIterator

Creates an iterator from a value.

impl PartialEq for MorseCustom

fn eq(&self, other: &MorseCustom) -> 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 TMorse for MorseCustom

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

Parse text into Morse Code.

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

Parse binary into Morse Code.

fn len(&self) -> usize

Morse Code string length.

fn remove(&mut self, idx: usize) -> MorseChar

Remove Morse Code character by index.

impl ToString for MorseCustom

fn to_string(&self) -> String

Return String value of Morse Code.

impl StructuralPartialEq for MorseCustom