Struct Process

pub struct Process {

    process_file: String,
    number: String,
    all_revisions: Vec<(String, String)>,
    title: String,
    process_type: String,
    author: String,
    reviewer: String,
    subject: String,
    subject_image: String,
    product: String,
    product_image: String,
    all_objectives: Vec<(String, String)>,
    all_out_of_scopes: Vec<(String, String)>,
    all_sections: Vec<Section>,
    all_resources: Vec<(Resource, String)>,
    all_calibrated_resources: Vec<Resource>,
    all_verifications: Vec<(Requirement, String)>,
    all_templates: Vec<String>,
    full_source: Vec<String>,
}

Top-level struct containing all information read from the markup file

All fields are private, but are accessible with “get” functions, e.g. Process.get_number() returns a reference to the Process’s number (&String).

Fields

process_file: String

Path to the EBML file for this process

number: String

Document Number, in whatever format makes sense for the organization’s document control system

all_revisions: Vec<(String, String)>

A stack of Revision lines, with an important assumption that the first Revision line represents the current Rev of the document, and the last Revision line represents the first released Rev of the document

• First String: “Rev” text, e.g. “A” for a document’s Revision A
• Second String: “What changed?” text, e.g. “New section added to initialize the system prior to start”

title: String

Human-readable Title of the process document, hopefully with enough meaning for the team to understand the purpose of the process

process_type: String

Human-readable category of process document, such as “Test Procedure” or “Work Instruction” or “Maintenance Procedure” etc.

author: String

Human that composed the markup file in its current Revision, i.e. who currently owns the knowledge in this process

reviewer: String

Human responsible for being the second set of eyes for this Revision, and who is the gatekeeper to publishing this Revision prior to its use in the field

subject: String

The thing that this process applies to, i.e. the primary input into the Process, be it tangible or abstract

subject_image: String

File name for an image of the Subject

product: String

If this process changes the Subject into something else, then that something else is the Product

product_image: String

File name for an image of the Product

all_objectives: Vec<(String, String)>

Compiled list of Objective statements found throughout the document when they are achieved

all_out_of_scopes: Vec<(String, String)>

Compiled list of Out-of-Scope statements found throughout the document when they are achieved

all_sections: Vec<Section>

Ordered set of all Step-filled sections of the document

all_resources: Vec<(Resource, String)>

Cummulative list of all Resources identified in all Steps

all_calibrated_resources: Vec<Resource>

Unique list of all resources that need calibration to be used in this process

all_verifications: Vec<(Requirement, String)>

Cummulative list of all Verifications of Requirements performed in all Steps

all_templates: Vec<String>

File names for custom templates (CSS) to use that augment the vanilla template

• Company-specific
• Project-specific
• Security environment-specific
• etc.

full_source: Vec<String>

Entire source EBML file for this Process, stored unprocessed in a Vec of Strings (one per line of text)

Implementations

impl Process

Functions necessary to create ::new() structs, as well as “get” every private field publicly, and to change or append private fields publicly

pub fn new() -> Process

Return Process struct with placeholder text in String fields, and empty vectors for Vec fields

pub fn get_process_file(&self) -> &String

Return reference to the Process File string

pub fn get_number(&self) -> &String

Return reference to the Document Number string

pub fn get_revision(&self) -> &String

Return reference to the LATEST Revision (first listed in the markup file)

pub fn get_all_revisions(&self) -> &Vec<(String, String)>

Return reference to the vector of touples describing each Revision and what changed

pub fn get_title(&self) -> &String

Return reference to the Title string

pub fn get_process_type(&self) -> &String

Return reference to the Process Type string

pub fn get_author(&self) -> &String

Return reference to the Author string

pub fn get_reviewer(&self) -> &String

Return reference to the Reviewer string

pub fn get_subject(&self) -> &String

Return reference to the Subject string

pub fn get_subject_image(&self) -> &String

Return reference to the file name of an Image of the Subject as string

pub fn get_product(&self) -> &String

Return reference to the Product string

pub fn get_product_image(&self) -> &String

Return reference to the file name of an Image of the Product as string

pub fn get_all_sections(&self) -> &Vec<Section>

Return reference to a Vector of Sections, in the order they appear in the markup

pub fn get_step_count(&self) -> usize

Return the total number of Steps throughout the process, including all Sections and Section References

pub fn get_all_verifications(&self) -> &Vec<(Requirement, String)>

Return reference to a Vector of Requirement Tuples, each with a Requirement struct and a string containing the Step number

pub fn get_all_objectives(&self) -> &Vec<(String, String)>

Return reference to a Vector of Tuples describing each objective and at what step it is achieved

pub fn get_all_out_of_scopes(&self) -> &Vec<(String, String)>

Return reference to a Vector of Tuples describing each out-of-scope declaration and at from which step

pub fn get_all_templates(&self) -> &Vec<String>

Return reference to a Vector of Templates as strings, one for each CSS file needed for the process

pub fn get_all_resources(&self) -> &Vec<(Resource, String)>

Return reference to a Vector of Resource Tuples, each with a Resource struct and a string containing the Step number

pub fn get_all_calibrated_resources(&self) -> &Vec<Resource>

Return reference to a Vector of Resources (a unique set of only those that need calibration)

pub fn get_tpv_count(&self) -> usize

Return the total number of Action lines that require Two-Party Verification (TPV)

pub fn get_non_tpv_count(&self) -> usize

Return the total number of Action lines that don’t require Two-Party Verification (no TPV)

pub fn get_all_command_lines(&self) -> Vec<(String, String)>

Return a vector of string tuples, with every “Command” line’s text (first element), with the step number (second element) in order of appearance in the process

pub fn get_all_context_lines(&self) -> Vec<(String, String)>

Return a vector of string tuples, with every “Context” line’s text (first element), with the step number (second element) in order of appearance in the process

pub fn get_all_images(&self) -> Vec<(String, String)>

Return extracted information from all SubStep “Image” variants as Vec of String tuples: (image file, caption text)

pub fn get_unique_image_count(&self) -> usize

Return a count of the number of unique image files invoked in this EBML file, including native “Image” lines, Subject Image, Product Image, and SECREFed “Image” lines

pub fn get_missing_images(&self) -> Vec<String>

Check to see if each image file needed for this process exists in the file system, and return a Vec of Strings of those that don’t

pub fn get_missing_image_count(&self) -> usize

Check to see if each image file needed for this process exists in the file system, and return a count of those that don’t

pub fn get_section_reference_count(&self) -> usize

Return a count of “Section Reference” or “SECREF” lines in this Process, prior to evaluating them into sections

pub fn get_full_source(&self) -> &Vec<String>

Return the full source EBML of this process as a Vec of Strings, one String per line of EBML

pub fn display_process_to_stdout(&self)

Used in verbose mode to display contents of the struct to stdout

pub fn set_process_file(&mut self, file_name: &str)

Change the stored location of the EBML file for this process

pub fn set_number(&mut self, doc_num: &str)

Change the Document Number

pub fn add_revision(&mut self, rev_line: &str)

Add a Revision Tuple to the Vector “all_revisions”

pub fn set_title(&mut self, title: &str)

Change the Document Title

pub fn set_process_type(&mut self, process_type: &str)

Change the Process Type

pub fn set_author(&mut self, author: &str)

Change the Document Author

pub fn set_reviewer(&mut self, reviewer: &str)

Change the Document Reviewer

pub fn set_subject(&mut self, subject: &str)

Change the Document Subject

pub fn set_subject_image(&mut self, subject_image: &str)

Change the Image file name of the Document Subject

pub fn set_product(&mut self, product: &str)

Change the Document Product

pub fn set_product_image(&mut self, product_image: &str)

Change the Image file name of the Document Product

pub fn add_template(&mut self, template: &str)

Add a Template file to the Vector of Template files (strings)

pub fn add_section(&mut self, section: Section)

Add a Section to the Vector of Section structs

pub fn add_verification(&mut self, requirement: Requirement, step: String)

Add a Verification tuple to the Vector of Verification tuples

pub fn add_objective(&mut self, objective: String, step: String)

Add an Objective tuple to the Vector of Objective tuples

pub fn add_out_of_scope(&mut self, out_of_scope: String, step: String)

Add an Out-of-Scope tuple to the Vector of Out-of-Scope tuples

pub fn add_resource(&mut self, resource: Resource, step: String)

Add a Resource struct to the Vector of Resource structs

pub fn add_calibrated_resource(&mut self, resource: Resource)

Add a Resource struct to the Vector of calibrated Resource structs

pub fn set_full_source(&mut self, full_source: Vec<String>)

Store the full text of the EBML file for this process as a Vec of Strings, one String per line of EBML