Struct SDoc

pub struct SDoc {
    pub graph: SGraph,
    pub perms: DocPermissions,
    pub types: CustomTypes,
    pub formats: SFormats,
    pub libraries: SLibraries,
    /* private fields */
}

Stof Document. Holds a Graph, containing the data contained within this document as well as any permissions, libraries, etc… needed for this document to manipulate itself.

Fields

graph: SGraph

perms: DocPermissions

types: CustomTypes

formats: SFormats

Formats that this Doc supports. It is up to the local Doc to provide formats.

libraries: SLibraries

Libraries that this Doc can call when scripting. It is up to the local Doc to provide libraries.

Implementations

impl SDoc

pub fn new(graph: SGraph) -> Self

New document from a graph.

pub fn src(src: &str, format: &str) -> Result<Self, SError>

New document from a string import format.

pub fn file(path: &str, format: &str) -> Result<Self, SError>

New document from a file import.

pub fn bytes(bytes: Bytes, format: &str) -> Result<Self, SError>

New document from bytes.

pub fn text_file_out(&mut self, path: &str, format: &str) -> Result<(), SError>

Export this document to a text file at “path” using “format”.

pub fn bin_file_out(&mut self, path: &str, format: &str) -> Result<(), SError>

Export this document to a binary file at “path” using “format”.

pub fn load_format(&mut self, format: Arc<dyn Format>)

Load a format into this document.

pub fn available_formats(&self) -> HashSet<String>

Available formats

pub fn format_content_type(&self, format: &str) -> Option<String>

Content type for a format.

pub fn header_import( &mut self, pid: &str, format: &str, content_type: &str, bytes: &mut Bytes, as_name: &str, ) -> Result<(), SError>

Header import (content type with bytes).

pub fn string_import( &mut self, pid: &str, format: &str, src: &str, as_name: &str, ) -> Result<(), SError>

String import.

pub fn file_import( &mut self, pid: &str, format: &str, full_path: &str, extension: &str, as_name: &str, ) -> Result<(), SError>

File import. Stof Syntax: ‘import “.” as <as_name>;’ If isn’t supplied, “format” will be “extension”. If <as_name> isn’t supplied, the data should be imported into the current doc scope (or main root).

pub fn export_string( &self, pid: &str, format: &str, node: Option<&SNodeRef>, ) -> Result<String, SError>

Export document string.i

pub fn export_min_string( &self, pid: &str, format: &str, node: Option<&SNodeRef>, ) -> Result<String, SError>

Export document min string.

pub fn export_bytes( &self, pid: &str, format: &str, node: Option<&SNodeRef>, ) -> Result<Bytes, SError>

Export document bytes.

pub fn load_lib(&mut self, library: Arc<dyn Library>)

Load a library into this document.

pub fn library(&self, lib: &str) -> Option<Arc<dyn Library>>

Get a library in this doc.

pub fn available_libraries(&self) -> HashSet<String>

Available libraries

pub fn fs_write_string( &mut self, pid: &str, path: &str, contents: &str, ) -> Result<(), SError>

Write a string to a file using the fs library.

pub fn fs_write_blob( &mut self, pid: &str, path: &str, contents: Vec<u8>, ) -> Result<(), SError>

Write a blob to a file using the fs library.

pub fn fs_read_string( &mut self, pid: &str, path: &str, ) -> Result<String, SError>

Read a file to a string using the fs library.

pub fn fs_read_blob(&mut self, pid: &str, path: &str) -> Result<Bytes, SError>

Read a file to a blob using the fs library.

pub fn get(&mut self, path: &str, start: Option<&SNodeRef>) -> Option<SVal>

Get a value from this document by path. If the path points to a field, the value will be retrieved. If the path points to a function, it will be called.

pub fn field(&self, path: &str, start: Option<&SNodeRef>) -> Option<&SField>

Find a field in this document with a path. Path is dot ‘.’ separated.

pub fn run_file(file: &str, throw: bool)

Run some Stof in a file. Will run all #[main] functions. Set ‘throw’ to true if you want this function to panic if tests fail.

pub fn run( &mut self, context: Option<&SNodeRef>, attribute: Option<String>, ) -> Result<(), String>

Run the main functions on a node or within this document. Main functions are denoted with an #[main] attribute in the text format. This is the default attribute to run.

pub fn func(&self, path: &str, start: Option<&SNodeRef>) -> Option<SDataRef>

Find a function in this document with a path. Path is dot ‘.’ separated.

pub fn call_func( &mut self, path: &str, start: Option<&SNodeRef>, params: Vec<SVal>, ) -> Result<SVal, SError>

Call a function in this document with a path.

pub fn test_file(file: &str, throw: bool)

Test some Stof in a file. Will run all #test functions. Set ‘throw’ to true if you want this function to panic if tests fail.

pub fn test(stof: &str, throw: bool, context: Option<&SNodeRef>)

Test some Stof. Will run all #test functions in ‘stof’. Set ‘throw’ to true if you want this function to panic if tests fail.

pub fn run_tests( &mut self, throw: bool, context: Option<&SNodeRef>, ) -> Result<String, String>

Run the test functions on a node or within this document, throwing an error if any fail. Test functions are denoted with a #[test(<result_expr_eq>)] attribute.

Trait Implementations

impl Clone for SDoc

fn clone(&self) -> SDoc

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for SDoc

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SDoc

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SDoc

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

where __S: Serializer,

Serialize this value into the given Serde serializer.