Struct rad::processor::Processor

pub struct Processor<'processor> {
    pub storage: Option<Box<dyn RadStorage>>,
    /* private fields */
}

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

Fields

storage: Option<Box<dyn RadStorage>>

Implementations

impl<'processor> Processor<'processor>

pub fn new() -> Self

Creates default processor with default macros

pub fn empty() -> Self

Creates default processor without default 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 purge(self, purge: bool) -> Self

Set purge option

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

Set lenient

pub fn hygiene(self, hygiene: Hygiene) -> Self

Set hygiene variant

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

Set truncate option

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

Set comment type

pub fn silent(self, silent_type: WarningType) -> 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 melt_files(self, paths: Vec<impl AsRef<Path>>) -> RadResult<Self>

Melt rule file

This always melt file into non-volatile form

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

Melt rule as literal input source, or say from byte array

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

Open authorization of processor

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

Open authorization of processor but yield warning

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

Discard output

pub fn storage(self, storage: Box<dyn RadStorage>) -> Self

Build with storage

pub fn insert_queue(&mut self, item: &str)

Set queue object

pub fn set_hygiene(&mut self, hygiene: Hygiene)

Set hygiene type

This also clears volatile runtime macro at the same time.

pub fn clear_volatile(&mut self)

Clear volatile macros

pub fn toggle_hygiene(&mut self, toggle: bool)

Toggle macro hygiene

pub fn set_write_option(&mut self, write_option: WriteOption<'processor>)

Set write option in the process

pub fn on_cache(&self) -> bool

Check if processing is on caching state

pub fn enable_cache(&mut self, truncate: bool) -> RadResult<()>

Toggle cache option

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

pub fn reset_flow_control(&mut self)

Set write option in the process

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 organize_and_clear_cache(&mut self) -> RadResult<Option<String>>

Clear cached and organze multiple jobs

• • clear volatile macors
• • Check if there is any unterminated job Return cached string, if cache was not empty

pub fn set_storage(&mut self, storage: Box<dyn RadStorage>)

Set storage

pub fn extract_storage(
    &mut self,
    serialize: bool
) -> RadResult<Option<StorageOutput>>

Extract from storage

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_ext_macro(&mut self, ext: ExtMacroBuilder)

Add a new macro as an extension

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

Add runtime rules without builder pattern

Args

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

Example

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

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

Add static rules without builder pattern

Args

The order of argument is “name, body”

Example

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

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

Read from string

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

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<Option<String>>

Process contents from a file

pub fn set_documentation(&mut self, macro_name: &str, content: &str) -> bool

pub fn get_current_dir(&self) -> RadResult<PathBuf>

pub fn print_error(&mut self, error: &str) -> RadResult<()>

pub fn get_split_arguments(
    &self,
    target_length: usize,
    source: &str
) -> RadResult<Vec<String>>

pub fn check_auth(&mut self, auth_type: AuthType) -> RadResult<bool>

Check auth information

This will print log_error if auth was enabled with warning

@return If auth is enabled or not

pub fn expand(
    &mut self,
    level: usize,
    source: impl AsRef<str>
) -> RadResult<String>

Expand given text

pub fn contains_macro(&self, macro_name: &str, macro_type: MacroType) -> bool

Check if given macro exists

pub fn undefine_macro(&mut self, macro_name: &str, macro_type: MacroType)

Try undefine macro

pub fn rename_macro(
    &mut self,
    macro_name: &str,
    target_name: &str,
    macro_type: MacroType
)

Rename macro

pub fn append_macro(&mut self, macro_name: &str, target: &str)

Append content into a macro

pub fn replace_macro(&mut self, macro_name: &str, target: &str) -> bool

Replace macro’s content

pub fn add_new_local_macro(
    &mut self,
    level: usize,
    macro_name: &str,
    body: &str
)

Add new local macro

pub fn remove_local_macro(&mut self, level: usize, macro_name: &str)

Remove local macro

pub fn is_true(&self, src: &str) -> RadResult<bool>

Check if given text is boolean-able