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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! onigiri::validator contains 4 functions for validating `Vec<char>`.

pub fn is_positive_number(vc: &Vec<char>) -> bool {
    //! Validate `Vec<char>` whether it is positive number.
    //! ```
    //! let test_chars_1 = vec!['1', '2', '3'];
    //! let test_chars_2 = vec!['2', '+', '1'];
    //! let test_chars_3 = vec!['-', '1', '2'];
    //!
    //! assert_eq!(
    //!     onigiri::validator::is_positive_number(&test_chars_1), true);
    //! assert_eq!(
    //!     onigiri::validator::is_positive_number(&test_chars_2), false);
    //! assert_eq!(
    //!     onigiri::validator::is_positive_number(&test_chars_3), false);
    //! ```
    let mut stack: Vec<bool> = vec![];
    for v in vc {
        match &v {
            '0' ... '9' => stack.push(true),
            _ => stack.push(false)
        }
    }
    if stack.iter().all(|&x| x == true) { true }
    else { false }
}

pub fn is_negative_number(vc: &Vec<char>) -> bool {
    //! Validate `Vec<char>` whether it is negative number.
    //! ```
    //! let test_chars_1 = vec!['1', '2', '3'];
    //! let test_chars_2 = vec!['-', '2', '1'];
    //! let test_chars_3 = vec!['2', '-', '1'];
    //! assert_eq!(
    //!     onigiri::validator::is_negative_number(&test_chars_1), false);
    //! assert_eq!(
    //!     onigiri::validator::is_negative_number(&test_chars_2), true);
    //! assert_eq!(
    //!     onigiri::validator::is_negative_number(&test_chars_3), false);
    //! ```
    let head = &vc[0];
    let tail = &vc[1..];
    let mut stack: Vec<bool> = vec![];
    
    if head == &'-' {
        stack.push(true)
    } else {
        stack.push(false)
    }

    let result_tail = is_positive_number(&tail.to_vec());
    stack.push(result_tail);

    if stack.iter().all(|&x| x == true) { true }
    else { false }
}

pub fn is_symbol(vc: &Vec<char>) -> bool {
    //! Validate `Vec<char>` whether it is symbol.
    //! ```
    //! let test_vc = vec!['+'];
    //! assert_eq!(
    //!     onigiri::validator::is_symbol(&test_vc),
    //!     true
    //! );
    //! let test_vc_2 = vec!['2'];
    //! assert_eq!(
    //!     onigiri::validator::is_symbol(&test_vc_2),
    //!     false
    //! );
    //! let test_vc_3 = vec!['+', '+'];
    //! assert_eq!(
    //!     onigiri::validator::is_symbol(&test_vc_3),
    //!     false
    //! );
    //! ```
    if vc.len() == 1_usize {
        match &vc[0] {
            '0' ... '9' => false,
            'a' ... 'z' => false,
            'A' ... 'Z' => false,
            _ => true
        }
    } else {
        false
    }
}

pub fn is_calc_operator(vc: &Vec<char>) -> bool {
    //! Validate `Vec<char>` whether it is calc_operator.
    //! ```
    //! let test_vc = vec!['+'];
    //! assert_eq!(
    //!     onigiri::validator::is_calc_operator(&test_vc),
    //!     true
    //! );
    //! let test_vc_2 = vec!['2'];
    //! assert_eq!(
    //!     onigiri::validator::is_calc_operator(&test_vc_2),
    //!     false
    //! );
    //! let test_vc_3 = vec!['+', '+'];
    //! assert_eq!(
    //!     onigiri::validator::is_calc_operator(&test_vc_3),
    //!     false
    //! );
    //! ```
    if is_symbol(&vc) {
        match &vc[0] {
            '+'|'-'|'*'|'/' => true,
            _ => false
        }
    } else {
        false
    }
}