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<PathBuf>
) -> Result<&mut Self, RadError>

Set write option to yield output to the file

pub fn error_to_file(
    &mut self,
    target_file: Option<PathBuf>
) -> 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 strict(&mut self, strict: bool) -> &mut Self

Set strict option

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

Set silent option

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

Add custom rules

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

Open authority of processor

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

Open authority of processor but yield warning

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

Discard output

pub fn build(&mut self) -> Self

Creates a unreferenced instance of processor

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

Print the result of a processing

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

Freeze to single file

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

Add new basic rules

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

Add custom rules without builder pattern

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

Read from string

pub fn from_stdin(&mut self) -> Result<String, 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: &Path) -> Result<String, RadError>

Process contents from a file