Struct binjs::io::entropy::dictionary::Dictionary

pub struct Dictionary<T> { /* fields omitted */ }

Methods

impl<T> Dictionary<T>

pub fn new(Options) -> Dictionary<T>

Create a new dictionary using paths of depth depth and windows of width width.

pub fn bool_by_path(&self) -> Ref<PathPredict<Option<bool>, T>>

pub fn string_enum_by_path(&self) -> Ref<PathPredict<SharedString, T>>

pub fn interface_name_by_path(&self) -> Ref<PathPredict<InterfaceName, T>>

pub fn float_by_path(&self) -> Ref<PathPredict<Option<F64>, T>>

pub fn unsigned_long_by_path(&self) -> Ref<PathPredict<u32, T>>

pub fn property_key_by_path(&self) -> Ref<PathPredict<Option<PropertyKey>, T>>

pub fn identifier_name_by_path(
    &self
) -> Ref<PathPredict<Option<IdentifierName>, T>>

pub fn string_literal_by_path(
    &self
) -> Ref<PathPredict<Option<SharedString>, T>>

pub fn list_length_by_path(&self) -> Ref<PathPredict<Option<u32>, T>>

pub fn property_key_by_window(
    &self
) -> Ref<WindowPredict<Option<PropertyKey>, T>>

pub fn identifier_name_by_window(
    &self
) -> Ref<WindowPredict<Option<IdentifierName>, T>>

pub fn string_literal_by_window(
    &self
) -> Ref<WindowPredict<Option<SharedString>, T>>

pub fn unsigned_longs(&self) -> Ref<LinearTable<u32>>

pub fn string_literals(&self) -> Ref<LinearTable<Option<SharedString>>>

pub fn identifier_names(&self) -> Ref<LinearTable<Option<IdentifierName>>>

pub fn property_keys(&self) -> Ref<LinearTable<Option<PropertyKey>>>

pub fn list_lengths(&self) -> Ref<LinearTable<Option<u32>>>

pub fn floats(&self) -> Ref<LinearTable<Option<F64>>>

pub fn depth(&self) -> usize

Return the depth of the current dictionary.

pub fn len(&self) -> usize

Return the number of states in this dictionary.

impl Dictionary<Instances>

pub fn bool_by_path_mut(
    &mut self
) -> RefMut<PathPredict<Option<bool>, Instances>>

pub fn string_enum_by_path_mut(
    &mut self
) -> RefMut<PathPredict<SharedString, Instances>>

pub fn interface_name_by_path_mut(
    &mut self
) -> RefMut<PathPredict<InterfaceName, Instances>>

pub fn float_by_path_mut(
    &mut self
) -> RefMut<PathPredict<Option<F64>, Instances>>

pub fn unsigned_long_by_path_mut(
    &mut self
) -> RefMut<PathPredict<u32, Instances>>

pub fn property_key_by_path_mut(
    &mut self
) -> RefMut<PathPredict<Option<PropertyKey>, Instances>>

pub fn identifier_name_by_path_mut(
    &mut self
) -> RefMut<PathPredict<Option<IdentifierName>, Instances>>

pub fn string_literal_by_path_mut(
    &mut self
) -> RefMut<PathPredict<Option<SharedString>, Instances>>

pub fn list_length_by_path_mut(
    &mut self
) -> RefMut<PathPredict<Option<u32>, Instances>>

pub fn property_key_by_window_mut(
    &mut self
) -> RefMut<WindowPredict<Option<PropertyKey>, Instances>>

pub fn identifier_name_by_window_mut(
    &mut self
) -> RefMut<WindowPredict<Option<IdentifierName>, Instances>>

pub fn string_literal_by_window_mut(
    &mut self
) -> RefMut<WindowPredict<Option<SharedString>, Instances>>

pub fn with_grammar_fallback(
    &self,
    fallback: Dictionary<Instances>
) -> Dictionary<Instances>

Combine a dictionary obtained by sampling (self) and a baseline dictionary (obtained by entropy::baseline) to produce a dictionary able to handle values that grammatically correct but have not been witnessed during sampling.

Trait Implementations

impl<T> Clone for Dictionary<T> where
    T: Clone, 

fn clone(&self) -> Dictionary<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Dictionary<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Dictionary<T> where
    T: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl InstancesToProbabilities for Dictionary<Instances>

type AsProbabilities = Dictionary<SymbolInfo>

fn instances_to_probabilities(
    &self,
    _description: &str
) -> Dictionary<SymbolInfo>

Convert a dictionary counting instances into a dictionary that counts probabilities.

impl<T> Serialize for Dictionary<T> where
    T: Serialize, 

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

Serialize this value into the given Serde serializer.