Struct word_sensitive::trie::Trie

pub struct Trie<T> {
    pub root: Option<NonNull<Node<T>>>,
    // some fields omitted
}

Fields

root: Option<NonNull<Node<T>>>

Implementations

impl Trie<usize>

pub fn add_key_word_from_file(&mut self, file: &str) -> Result<()>

Add keywords from file

Examples

use word_sensitive::trie;
let mut tree = trie::Trie::default();
tree.add_key_word_from_file("key_words/keywords.txt").unwrap();
tree.build();
let matches = tree.query("回民吃猪肉".as_bytes().as_ref());
assert_eq!(matches[0], "回民".as_bytes().as_ref());
assert_eq!(matches[1], "回民吃猪肉".as_bytes().as_ref());

pub fn add_key_word(&mut self, key_word: Vec<u8>)

Add keyword

Examples

use word_sensitive::trie;
let mut tree = trie::Trie::default();
tree.add_key_word("abc".as_bytes().to_vec());
tree.add_key_word("bcd".as_bytes().to_vec());
tree.build();
let matches = tree.query("hello, abcd".as_bytes().as_ref());
assert_eq!(matches[0], "abc".as_bytes().as_ref());
assert_eq!(matches[1], "bcd".as_bytes().as_ref());

impl<T: NodeExt + Clone> Trie<T>

pub fn add_key_word_ext(&mut self, key_word: Vec<u8>, ext: T)

pub fn build(&mut self)

Build fail pointer for tree

Examples

use word_sensitive::trie;
let mut tree = trie::Trie::default();
tree.add_key_word("abc".as_bytes().to_vec());
tree.add_key_word("bac".as_bytes().to_vec());
tree.add_key_word("aac".as_bytes().to_vec());
tree.add_key_word("bcd".as_bytes().to_vec());
tree.build();
let matches = tree.query("abcdef".as_bytes().as_ref());
assert_eq!(matches[0], "abc".as_bytes().as_ref()) ;
assert_eq!(matches[1], "bcd".as_bytes().as_ref()) ;

pub fn query<'a>(&self, text: &'a [u8]) -> Vec<&'a [u8]>

Query all key_words input text string

Examples

use word_sensitive::trie;
let mut tree = trie::Trie::default();
tree.add_key_word("aaa".as_bytes().to_vec());
tree.add_key_word("aab".as_bytes().to_vec());
tree.add_key_word("aac".as_bytes().to_vec());
tree.add_key_word("aba".as_bytes().to_vec());
tree.add_key_word("abb".as_bytes().to_vec());
tree.add_key_word("abc".as_bytes().to_vec());
tree.add_key_word("aca".as_bytes().to_vec());
tree.add_key_word("acb".as_bytes().to_vec());
tree.add_key_word("acc".as_bytes().to_vec());
tree.add_key_word("baa".as_bytes().to_vec());
tree.add_key_word("bab".as_bytes().to_vec());
tree.add_key_word("bac".as_bytes().to_vec());
tree.add_key_word("bba".as_bytes().to_vec());
tree.add_key_word("bbb".as_bytes().to_vec());
tree.add_key_word("bbc".as_bytes().to_vec());
tree.add_key_word("bca".as_bytes().to_vec());
tree.add_key_word("bcb".as_bytes().to_vec());
tree.add_key_word("bcc".as_bytes().to_vec());
tree.add_key_word("caa".as_bytes().to_vec());
tree.add_key_word("cab".as_bytes().to_vec());
tree.add_key_word("cac".as_bytes().to_vec());
tree.add_key_word("cba".as_bytes().to_vec());
tree.add_key_word("cbb".as_bytes().to_vec());
tree.add_key_word("cbc".as_bytes().to_vec());
tree.add_key_word("cca".as_bytes().to_vec());
tree.add_key_word("ccb".as_bytes().to_vec());
tree.add_key_word("ccc".as_bytes().to_vec());
tree.build();
let matches = tree.query("abcabcbcca".as_bytes().as_ref());
assert_eq!(matches[0], "abc".as_bytes().as_ref());
assert_eq!(matches[1], "bca".as_bytes().as_ref());
assert_eq!(matches[2], "cab".as_bytes().as_ref());
assert_eq!(matches[3], "abc".as_bytes().as_ref());
assert_eq!(matches[4], "bcb".as_bytes().as_ref());
assert_eq!(matches[5], "cbc".as_bytes().as_ref());
assert_eq!(matches[6], "bcc".as_bytes().as_ref());
assert_eq!(matches[7], "cca".as_bytes().as_ref());

pub fn query_total_weight(&self, text: &[u8]) -> usize

Query total weight for text

Examples

use word_sensitive::trie;
let mut tree = trie::Trie::default();
tree.add_key_word("abc".as_bytes().to_vec());
tree.add_key_word("bc".as_bytes().to_vec());
tree.build();
assert_eq!(2, tree.query_total_weight("abc".as_bytes().as_ref()));


#[derive(Clone)]
struct Ext {
cate: usize,
weight: usize,
len: usize,
}
impl trie::NodeExt for Ext {
fn get_len(&self) -> usize {
    self.len
}
fn eq(&self, other: &Self) -> bool {
    self.len == other.len
}
fn get_weight(&self) -> usize {
    self.weight
}
fn get_cate(&self) -> usize {
    self.cate
}
}
let mut tree = trie::Trie::default();
tree.add_key_word_ext(
    "abc".as_bytes().to_vec(),
    Ext {
        cate: 1,
        weight: 2,
        len: 3,
    },
);
tree.add_key_word_ext(
    "bc".as_bytes().to_vec(),
    Ext {
        cate: 1,
        weight: 1,
        len: 2,
    },
);
tree.build();
assert_eq!(3, tree.query_total_weight("abc".as_bytes().as_ref()));

pub fn query_cate_weight(&self, text: &[u8]) -> HashMap<usize, usize>

Query Category weight for text

Examples

use word_sensitive::trie;
let mut tree = trie::Trie::default();
tree.add_key_word("abc".as_bytes().to_vec());
tree.add_key_word("bc".as_bytes().to_vec());
tree.build();
assert_eq!(
    Some(&2),
    tree.query_cate_weight("abc".as_bytes().as_ref()).get(&1)
);
#[derive(Clone)]
struct Ext {
cate: usize,
weight: usize,
len: usize,
}
impl trie::NodeExt for Ext {
fn get_len(&self) -> usize {
    self.len
}
fn eq(&self, other: &Self) -> bool {
    self.len == other.len
}
fn get_weight(&self) -> usize {
    self.weight
}
fn get_cate(&self) -> usize {
    self.cate
}
}
let mut tree = trie::Trie::default();
tree.add_key_word_ext(
    "abc".as_bytes().to_vec(),
    Ext {
        cate: 1,
        weight: 2,
        len: 3,
    },
);
tree.add_key_word_ext(
    "bc".as_bytes().to_vec(),
    Ext {
        cate: 1,
        weight: 1,
        len: 2,
    },
);
tree.build();
assert_eq!(
    Some(&3),
    tree.query_cate_weight("abc".as_bytes().as_ref()).get(&1)
);
tree.add_key_word_ext(
    "bc".as_bytes().to_vec(),
    Ext {
        cate: 2,
        weight: 1,
        len: 2,
    },
);
tree.build();
tree.add_key_word_ext(
    "ab".as_bytes().to_vec(),
    Ext {
        cate: 2,
        weight: 1,
        len: 2,
    },
);
tree.build();
assert_eq!(
    Some(&2),
    tree.query_cate_weight("abc".as_bytes().as_ref()).get(&1)
);
assert_eq!(
    Some(&2),
    tree.query_cate_weight("abc".as_bytes().as_ref()).get(&2)
);

pub fn query_ext<'a>(&self, text: &'a [u8]) -> Vec<(usize, &T)>

Trait Implementations

impl<T> Default for Trie<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for Trie<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Send for Trie<T>

impl<T> Sync for Trie<T>