Struct test_data_generation::engine::Fact

pub struct Fact {
    pub key: char,
    pub prior_key: Option<char>,
    pub next_key: Option<char>,
    pub pattern_placeholder: char,
    pub starts_with: u32,
    pub ends_with: u32,
    pub index_offset: u32,
}

Represents a Fact for a character in a sample data entity that has been analyzed

Fields

key: char

the char that the fact defines (.e.g: ‘a’, ‘1’, ‘%’, etc.)

prior_key: Option<char>

the char that appears before (-1) the key in the entity

next_key: Option<char>

the char that appears after (+1) the key in the entity

pattern_placeholder: char

the PatternPlaceholder symbol that represents the type of key

starts_with: u32

indicates if the key is the first char in the entity (0=no, 1=yes)

ends_with: u32

indicates if the key is the last char in the entity (0=no, 1=yes)

index_offset: u32

indicates the number of positions from the index zero (where the char is located in the entity from the first position)

Implementations

impl Fact

pub fn new(k: char, pp: char, sw: u32, ew: u32, idx_off: u32) -> Fact

Constructs a new Fact

Arguments

• k: char - The char that the Fact represents (also known as the key).
  
• pp: char - The char that represents the patter placeholder for the key.
  
• sw: u32 - Indicates is the key is the first char in the entity. (0=no, 1=yes)
  
• ew: u32 - Indicates is the key is the last char in the entity. (0=no, 1=yes)
  
• idx_off: u32 - The index that represents the postion of the key from the beginning of the entity (zero based).
  

Example

extern crate test_data_generation;

use test_data_generation::engine::Fact;

fn main() {
	//fact created for the character 'r' in the string "word"
   	let mut fact =  Fact::new('r','c',0,0,2);
}

pub fn from_serialized(serialized: &str) -> Fact

Constructs a new Fact from a serialized (JSON) string of the Fact object. This is used when restoring from “archive”

Arguments

• serialized: &str - The JSON string that represents the archived Fact object.
  

Example

extern crate test_data_generation;

use test_data_generation::engine::Fact;

fn main() {
	let serialized = "{\"key\":\"r\",\"prior_key\":null,\"next_key\":null,\"pattern_placeholder\":\"c\",\"starts_with\":0,\"ends_with\":0,\"index_offset\":2}";
	let mut fact = Fact::from_serialized(&serialized);
    fact.set_prior_key('a');
	fact.set_next_key('e');

	assert_eq!(fact.pattern_placeholder, 'c');
}

pub fn serialize(&mut self) -> String

This function converts the Fact to a serialize JSON string.

Example

extern crate test_data_generation;

use test_data_generation::engine::Fact;

fn main() {
	//fact created for the character 'r' in the string "word"
   	let mut fact =  Fact::new('r','c',0,0,2);

    println!("{}", fact.serialize());
    // {"key":"r","prior_key":null,"next_key":null,"pattern_placeholder":"c","starts_with":0,"ends_with":0,"index_offset":2}
}

pub fn set_next_key(&mut self, nk: char)

This function sets the next key attribute to the specified char.

Arguments

• nk: char - The character that represents the next character in the entity

Example

extern crate test_data_generation;

use test_data_generation::engine::Fact;

fn main() {
	//fact created for the character 'r' in the string "word"
   	let mut fact =  Fact::new('r','c',0,0,2);
    fact.set_next_key('d');
}

pub fn set_prior_key(&mut self, pk: char)

This function sets the prior key attribute to the specified char.

Arguments

• pk: char - The character that represents the prior character in the entity

Example

extern crate test_data_generation;

use test_data_generation::engine::Fact;

fn main() {
	//fact created for the character 'r' in the string "word"
   	let mut fact =  Fact::new('r','c',0,0,2);
    fact.set_prior_key('o');
}

Trait Implementations

impl Clone for Fact

fn clone(&self) -> Fact

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Fact

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Fact

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Fact

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

Serialize this value into the given Serde serializer.