Struct rad::processor::Processor

pub struct Processor<'processor> { /* private fields */ }

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

Implementations

impl<'processor> Processor<'processor>

pub fn new() -> Self

Creates default processor with basic macros

pub fn empty() -> Self

Creates default processor without basic macros

pub fn clear_custom_macros(&mut self)

Clear custom macros

pub fn write_to_file(
    self,
    target_file: Option<impl AsRef<Path>>
) -> RadResult<Self>

Set write option to yield output to the file

pub fn write_to_variable(self, value: &'processor mut String) -> Self

Write to variable

pub fn error_to_file(
    self,
    target_file: Option<impl AsRef<Path>>
) -> RadResult<Self>

Yield error to the file

pub fn error_to_variable(self, value: &'processor mut String) -> Self

Yield error to the file

pub fn custom_comment_char(self, character: char) -> RadResult<Self>

Custom comment character

pub fn custom_macro_char(self, character: char) -> RadResult<Self>

Custom macro character

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

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

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

Set greedy option

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

Set purge option

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

Set lenient

pub fn pipe_truncate(self, truncate: bool) -> Self

Set truncate option

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

👎 Deprecated since 1.2:

Comment is deprecated and will be removed in 2.0 version.

Use comment

This is deprecated and will be removed in 2.0 version. Use set_comment_type instead.

pub fn set_comment_type(self, comment_type: CommentType) -> Self

Set comment type

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

Set silent option

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

Set nopanic

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

Set assertion mode

pub fn rule_files(self, paths: Option<Vec<impl AsRef<Path>>>) -> RadResult<Self>

Melt rule file

pub fn rule_literal(self, literal: &Vec<u8>) -> RadResult<Self>

Melt rule as literal input source

pub fn custom_rules(
    self,
    paths: Option<Vec<impl AsRef<Path>>>
) -> RadResult<Self>

👎 Deprecated since 1.5:

Use “rule_files” instead.This method will be removed in 2.0

Add custom rules

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

Open authority of processor

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

Open authority of processor but yield warning

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

Discard output

pub fn build(self) -> Self

👎 Deprecated since 1.3:

Build method is deprecated in favor of more ergonomic builder pattern. It will be removed in 2.0

Creates an unreferenced instance of processor

pub fn print_permission(&mut self) -> RadResult<()>

Print current permission status

pub fn print_result(&mut self) -> RadResult<()>

Print the result of a processing

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

Freeze to a 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<(impl AsRef<str>, &str, &str)>
) -> RadResult<()>

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 add_static_rules(
    &mut self,
    rules: Vec<(impl AsRef<str>, &str)>
) -> RadResult<()>

Add static rules without builder pattern

Args

The order of argument is “name, body”

Example

processor.add_custom_rules(vec![("macro_name","Macro body without arguments")]);

pub fn undefine_rules(&mut self, rules: Vec<impl AsRef<str>>)

Remove rules from map

pub fn undefine_custom_rules(&mut self, rules: Vec<impl AsRef<str>>)

Remove rules from map but only custom macro

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

Read from string

pub fn from_stdin(&mut self) -> RadResult<()>

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>) -> RadResult<()>

Process contents from a file