Struct shortcut_autotyper::Sequences

pub struct Sequences(/* private fields */);

Structure for collection of defined sequences.

Implementations

impl Sequences

pub fn new(sequences: &[(&str, &str)]) -> ATResult<Sequences>

Create new instance of Sequences if identification name is valid Command::valid_name() and unique. Sequences are list of tuples, where first value is name and second required sequence

let seq = Sequences::new(&[("A", "seq a"), ("B", "seq b")]);
assert!(seq.is_ok());
let seq = Sequences::new(&[("~", "invalid seq")]);
assert_eq!(seq, Err(ErrType::InvalidKeyFormat(String::from("~")).into()));

pub fn get_sequence(&self, key: &str, args: &Vec<String>) -> ATResult<String>

Generate sequence from given key. Returns string with generated sequence or error if key is invalid or sequence key does not exists.

let seq = Sequences::new(&[("A", "seq a,")]).unwrap();
assert_eq!(seq.get_sequence("A3", &Vec::new()).unwrap(), String::from("seq a,seq a,seq a,"));

pub fn get_sequence_cmd( &self, command: &Command, args: &Vec<String> ) -> ATResult<String>

Generate sequence from given Command. Returns string with generated sequence or error if sequence does not constraint value with command name.

pub fn get(&self, key: &str) -> Option<&String>

Returns a reference to the value corresponding to the key. If value does not exists. Then returns None.

pub fn get_errors(&self) -> ATVecResult<()>

Find all keys invalid and returns errors caused by them as ATVecResult. If there are no invalid keys returns Ok(()).

pub fn is_valid(&self) -> bool

Check if all keys in sequence are valid.

pub fn insert(&mut self, key: &str, value: &str) -> ATResult<()>

Insert key and value to sequences. If key is invalid, or is in sequences, error will be returned.

pub fn get_keys(&self) -> Keys<'_, String, String>

Retrieves an iterator over the sequences.

Return Value

An iterator of type Keys<'_, String, String> over the keys of the sequences.

Trait Implementations

impl Debug for Sequences

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

Formats the value using the given formatter.

impl Default for Sequences

fn default() -> Sequences

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Sequences

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Sequences

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Sequences

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Sequences