sudachi/util/
check_params.rs

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
/*
 *  Copyright (c) 2021-2024 Works Applications Co., Ltd.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

use crate::dic::grammar::Grammar;
use crate::error::{SudachiError, SudachiResult};

pub trait CheckParams {
    fn check_left_id<T: Into<i64>>(&self, raw: T) -> SudachiResult<u16>;
    fn check_right_id<T: Into<i64>>(&self, raw: T) -> SudachiResult<u16>;
    fn check_cost<T: Into<i64>>(&self, raw: T) -> SudachiResult<i16>;
}

impl<'a> CheckParams for Grammar<'a> {
    fn check_left_id<T: Into<i64>>(&self, raw: T) -> SudachiResult<u16> {
        let x = raw.into();
        if x < 0 {
            return Err(SudachiError::InvalidDataFormat(
                0,
                format!("leftId was negative ({}), it must be positive", x),
            ));
        }
        let ux = x as usize;
        if ux > self.conn_matrix().num_left() {
            return Err(SudachiError::InvalidDataFormat(
                ux,
                format!("max grammar leftId is {}", self.conn_matrix().num_left()),
            ));
        }
        Ok(x as u16)
    }

    fn check_right_id<T: Into<i64>>(&self, raw: T) -> SudachiResult<u16> {
        let x = raw.into();
        if x < 0 {
            return Err(SudachiError::InvalidDataFormat(
                0,
                format!("rightId was negative ({}), it must be positive", x),
            ));
        }
        let ux = x as usize;
        if ux > self.conn_matrix().num_right() {
            return Err(SudachiError::InvalidDataFormat(
                ux,
                format!("max grammar rightId is {}", self.conn_matrix().num_right()),
            ));
        }
        Ok(x as u16)
    }

    fn check_cost<T: Into<i64>>(&self, raw: T) -> SudachiResult<i16> {
        let x = raw.into();
        if x < (i16::MIN as i64) {
            return Err(SudachiError::InvalidDataFormat(
                0,
                format!(
                    "cost ({}) was lower than the lowest acceptable value ({})",
                    x,
                    i16::MIN
                ),
            ));
        }
        if x > (i16::MAX as i64) {
            return Err(SudachiError::InvalidDataFormat(
                0,
                format!(
                    "cost ({}) was higher than highest acceptable value ({})",
                    x,
                    i16::MAX
                ),
            ));
        }
        Ok(x as i16)
    }
}