Struct rad::processor::Processor

pub struct Processor { /* fields omitted */ }

Processor that parses(lexes) given input and print out to desginated output

Implementations

impl Processor

pub fn new() -> Self

Creates default processor with basic macros

pub fn empty() -> Self

Creates default processor without basic macros

pub fn write_to_file(
    &mut self,
    target_file: Option<impl AsRef<Path>>
) -> Result<&mut Self, RadError>

Set write option to yield output to the file

pub fn error_to_file(
    &mut self,
    target_file: Option<impl AsRef<Path>>
) -> Result<&mut Self, RadError>

Yield error to the file

pub fn unix_new_line(&mut self, use_unix_new_line: bool) -> &mut Self

Use unix line ending instead of operating system’s default one

pub fn greedy(&mut self, greedy: bool) -> &mut Self

Set greedy option

pub fn purge(&mut self, purge: bool) -> &mut Self

Set purge option

pub fn lenient(&mut self, lenient: bool) -> &mut Self

Set lenient

pub fn comment(&mut self, comment: bool) -> &mut Self

Use comment

pub fn silent(&mut self, silent: bool) -> &mut Self

Set silent option

pub fn nopanic(&mut self, nopanic: bool) -> &mut Self

Set nopanic

pub fn assert(&mut self, assert: bool) -> &mut Self

Set assertion mode

pub fn custom_rules(
    &mut self,
    paths: Option<Vec<impl AsRef<Path>>>
) -> Result<&mut Self, RadError>

Add custom rules

pub fn allow(&mut self, auth_types: Option<Vec<AuthType>>) -> &mut Self

Open authority of processor

pub fn allow_with_warning(
    &mut self,
    auth_types: Option<Vec<AuthType>>
) -> &mut Self

Open authority of processor but yield warning

pub fn discard(&mut self, discard: bool) -> &mut Self

Discard output

pub fn build(&mut self) -> Self

Creates an unreferenced instance of processor

pub fn print_permission(&mut self) -> Result<(), RadError>

Print current permission status

pub fn print_result(&mut self) -> Result<(), RadError>

Print the result of a processing

pub fn freeze_to_file(&self, path: impl AsRef<Path>) -> Result<(), RadError>

Freeze to single file

Frozen file is a bincode encoded binary format file.

pub fn add_basic_rules(&mut self, basic_rules: Vec<(&str, MacroType)>)

Add new basic rules

pub fn add_closure_rule(
    &mut self,
    name: &'static str,
    arg_count: usize,
    closure: Box<dyn FnMut(Vec<String>) -> Option<String>>
)

Add new closure rule

Accessing index bigger or equal to the length of argument vector is panicking error while “insufficient arguments” will simply prints error without panicking and stop evaluation.

Args

• name - Name of the macro to add
• arg_count - Count of macro’s argument
• closure - Vector of string is an parsed arguments with given length.

Example

processor.add_closure_rule(
    "test",                                                       
    2,                                                            
    Box::new(|args: Vec<String>| -> Option<String> {              
        Some(format!("First : {}\nSecond: {}", args[0], args[1]))
    })
);

pub fn add_custom_rules(&mut self, rules: Vec<(&str, &str, &str)>)

Add custom rules without builder pattern

Args

The order of argument is “name, args, body”

Example

processor.add_custom_rules(vec![("macro_name","macro_arg1 macro_arg2","macro_body=$macro_arg1()")]);

pub fn from_string(&mut self, content: &str) -> Result<(), RadError>

Read from string

pub fn from_stdin(&mut self) -> Result<(), RadError>

Read from standard input

If debug mode is enabled this, doesn’t read stdin line by line but by chunk because user input is also a standard input and processor cannot distinguish the two

pub fn from_file(&mut self, path: impl AsRef<Path>) -> Result<(), RadError>

Process contents from a file