ik-rs 0.2.0

chinese segment, ik-analyzer for rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use crate::core::ik_segmenter::TokenMode;
use crate::core::lexeme::Lexeme;
use crate::core::lexeme_path::LexemePath;
use crate::core::ordered_linked_list::{Node, OrderedLinkedList};
use std::collections::{BTreeSet, HashMap};
use std::ptr::NonNull;

pub struct IKArbitrator {}

impl IKArbitrator {
    pub fn new() -> Self {
        IKArbitrator {}
    }

    pub unsafe fn process(
        &mut self,
        org_lexemes: &mut OrderedLinkedList<Lexeme>,
        mode: TokenMode,
    ) -> HashMap<usize, LexemePath> {
        let mut path_map = HashMap::<usize, LexemePath>::new();
        let mut cross_path = LexemePath::new();
        let mut cur_node = org_lexemes.head_node();
        while cur_node.is_some() {
            let org_lexeme = &(cur_node.as_ref().unwrap().as_ref().val);
            if !cross_path.add_cross_lexeme(org_lexeme) {
                if cross_path.size() == 1 || !(mode == TokenMode::SEARCH) {
                    path_map.insert(cross_path.get_path_begin() as usize, cross_path);
                } else {
                    let judge_result = self.judge(cross_path.get_head());
                    path_map.insert(
                        judge_result.as_ref().unwrap().get_path_begin() as usize,
                        judge_result.unwrap(),
                    );
                }
                cross_path = LexemePath::new();
                cross_path.add_cross_lexeme(org_lexeme);
            }
            cur_node = cur_node.as_ref().unwrap().as_ref().next.as_ref();
        }

        if cross_path.size() == 1 || !(mode == TokenMode::SEARCH) {
            path_map.insert(cross_path.get_path_begin() as usize, cross_path);
        } else {
            let judge_result = self.judge(cross_path.get_head());
            path_map.insert(
                judge_result.as_ref().unwrap().get_path_begin() as usize,
                judge_result.unwrap(),
            );
        }
        path_map
    }

    pub unsafe fn judge(&mut self, cur_node: Option<&NonNull<Node<Lexeme>>>) -> Option<LexemePath> {
        let mut path_options = BTreeSet::new();
        let mut option = LexemePath::new();
        let mut lexeme_stack = self.forward_path(cur_node, &mut option);
        path_options.insert(option.clone());
        let mut c;
        while !lexeme_stack.is_empty() {
            c = lexeme_stack.pop();
            self.back_path(c.unwrap(), &mut option);
            self.forward_path(c.unwrap(), &mut option);
            path_options.insert(option.clone());
        }
        // pick first one
        let mut a = None;
        if !path_options.is_empty() {
            for o in path_options.iter() {
                a = Some(o.clone());
                break;
            }
        }
        return a;
    }

    pub unsafe fn forward_path<'a>(
        &'a self,
        cur_node: Option<&'a NonNull<Node<Lexeme>>>,
        option: &mut LexemePath,
    ) -> Vec<Option<&NonNull<Node<Lexeme>>>> {
        let mut conflict_stack: Vec<Option<&NonNull<Node<Lexeme>>>> = Vec::new();
        let mut cur = cur_node;
        while cur.is_some() {
            let c = &(cur.as_ref().unwrap().as_ref().val);
            if !option.add_not_cross_lexeme(c) {
                conflict_stack.push(cur);
            }
            cur = cur.as_ref().unwrap().as_ref().next.as_ref();
        }
        return conflict_stack;
    }

    pub unsafe fn back_path(&self, l: Option<&NonNull<Node<Lexeme>>>, option: &mut LexemePath) {
        let lexeme = &(l.as_ref().unwrap().as_ref().val);
        while option.check_cross(lexeme) {
            option.remove_tail();
        }
    }
}