use crate::core::char_util::utf8_len;
use crate::core::char_util::CharType;
use crate::core::lexeme::{Lexeme, LexemeType};
use crate::core::ordered_linked_list::OrderedLinkedList;
use crate::core::segmentor::Segmenter;
const SEGMENTER_NAME: &str = "LETTER_SEGMENTER";
const LETTER_CONNECTOR: [char; 7] = ['#', '&', '+', '-', '.', '@', '_'];
const NUM_CONNECTOR: [char; 2] = [',', '.'];
pub struct LetterSegmenter {
start: i32,
end: i32,
english_start: i32,
english_end: i32,
arabic_start: i32,
arabic_end: i32,
}
impl Segmenter for LetterSegmenter {
fn analyze(
&mut self,
input: &str,
cursor: usize,
curr_char_type: CharType,
origin_lexemes: &mut OrderedLinkedList<Lexeme>,
) {
self.process_english_letter(input, cursor, curr_char_type, origin_lexemes);
self.process_arabic_letter(input, cursor, curr_char_type, origin_lexemes);
self.process_mix_letter(input, cursor, curr_char_type, origin_lexemes);
}
fn name(&self) -> &str {
return SEGMENTER_NAME;
}
}
impl LetterSegmenter {
pub fn new() -> Self {
LetterSegmenter {
start: -1,
end: -1,
english_start: -1,
english_end: -1,
arabic_start: -1,
arabic_end: -1,
}
}
fn process_mix_letter(
&mut self,
input: &str,
cursor: usize,
curr_char_type: CharType,
origin_lexemes: &mut OrderedLinkedList<Lexeme>,
) {
let curr_char = input.chars().nth(cursor).unwrap();
let char_count = utf8_len(input);
if self.start == -1 {
if CharType::ARABIC == curr_char_type || CharType::ENGLISH == curr_char_type {
self.start = cursor as i32;
self.end = cursor as i32;
}
} else {
if CharType::ARABIC == curr_char_type || CharType::ENGLISH == curr_char_type {
self.end = cursor as i32;
} else if CharType::USELESS == curr_char_type && self.is_letter_connector(curr_char) {
self.end = cursor as i32;
} else {
let new_lexeme = Lexeme::new(
(self.start as usize)..(self.end + 1) as usize,
LexemeType::LETTER,
);
origin_lexemes.insert(new_lexeme);
self.reset_mix_state();
}
}
if self.end == (char_count - 1) as i32 {
let new_lexeme = Lexeme::new(
(self.start as usize)..(self.end + 1) as usize,
LexemeType::LETTER,
);
origin_lexemes.insert(new_lexeme);
self.reset_mix_state();
}
}
fn process_english_letter(
&mut self,
input: &str,
cursor: usize,
curr_char_type: CharType,
origin_lexemes: &mut OrderedLinkedList<Lexeme>,
) {
let char_count = utf8_len(input);
if self.english_start == -1 {
if CharType::ENGLISH == curr_char_type {
self.english_start = cursor as i32;
self.english_end = cursor as i32;
}
} else {
if CharType::ENGLISH == curr_char_type {
self.english_end = cursor as i32;
} else {
let new_lexeme = Lexeme::new(
(self.english_start as usize)..(self.english_end + 1) as usize,
LexemeType::ENGLISH,
);
origin_lexemes.insert(new_lexeme);
self.reset_english_state();
}
}
if self.english_end == (char_count - 1) as i32 {
let new_lexeme = Lexeme::new(
(self.english_start as usize)..(self.english_end + 1) as usize,
LexemeType::ENGLISH,
);
origin_lexemes.insert(new_lexeme);
self.reset_english_state();
}
}
fn process_arabic_letter(
&mut self,
input: &str,
cursor: usize,
curr_char_type: CharType,
origin_lexemes: &mut OrderedLinkedList<Lexeme>,
) {
let char_count = utf8_len(input);
let curr_char = input.chars().nth(cursor).unwrap();
if self.arabic_start == -1 {
if CharType::ARABIC == curr_char_type {
self.arabic_start = cursor as i32;
self.arabic_end = cursor as i32;
}
} else {
if CharType::ARABIC == curr_char_type {
self.arabic_end = cursor as i32;
} else if CharType::USELESS == curr_char_type && self.is_num_connector(curr_char) {
} else {
let new_lexeme = Lexeme::new(
(self.arabic_start as usize)..(self.arabic_end + 1) as usize,
LexemeType::ARABIC,
);
origin_lexemes.insert(new_lexeme);
self.reset_arabic_state();
}
}
if self.arabic_end == (char_count - 1) as i32 {
let new_lexeme = Lexeme::new(
(self.arabic_start as usize)..(self.arabic_end + 1) as usize,
LexemeType::ARABIC,
);
origin_lexemes.insert(new_lexeme);
self.reset_arabic_state();
}
}
fn reset_mix_state(&mut self) {
self.start = -1;
self.end = -1;
}
fn reset_english_state(&mut self) {
self.english_start = -1;
self.english_end = -1;
}
fn reset_arabic_state(&mut self) {
self.arabic_start = -1;
self.arabic_end = -1;
}
fn is_letter_connector(&self, input: char) -> bool {
LETTER_CONNECTOR.contains(&input)
}
fn is_num_connector(&self, input: char) -> bool {
NUM_CONNECTOR.contains(&input)
}
}