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
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::str::FromStr;


pub fn chars_to_string(chars: &Vec<char>) -> String {
    //! Convert from `Vec<char>` to `String`.
    //! This function is used in N* and Literal.
    let vec_str: Vec<String> = chars.iter()
        .map(|ref v| v.to_string()).collect();
    let result = vec_str.concat();
    result
}

pub fn create_vvchar(text: &String) -> Vec<Vec<char>>{
    //! This function convert from `String` to `Vec<Vec<char>>`.
    let split_text: Vec<&str> = text.split_whitespace().collect();
    let vvchar: Vec<Vec<char>> = split_text.iter()
        .map(|&x| x.chars().collect()).collect();
    
    vvchar
}

// Create i8 from chars.
pub struct Ni8{pub attr: i8}

impl Ni8 {
    pub fn new(attr: &Vec<char>) -> Ni8 {
        let n = chars_to_string(&attr);
        Ni8 {attr: i8::from_str(&n).unwrap()}
    }
}

// Create u8 from chars.
pub struct Nu8{pub attr: u8}

impl Nu8 {
    pub fn new(attr: &Vec<char>) -> Nu8 {
        let n = chars_to_string(&attr);
        Nu8 {attr: u8::from_str(&n).unwrap()}
    }
}

// Create i16 from chars.
pub struct Ni16{pub attr: i16}

impl Ni16 {
    pub fn new(attr: &Vec<char>) -> Ni16 {
        let n = chars_to_string(&attr);
        Ni16 {attr: i16::from_str(&n).unwrap()}
    }
}

// Create u16 from chars.
pub struct Nu16{pub attr: u16}

impl Nu16 {
    pub fn new(attr: &Vec<char>) -> Nu16 {
        let n = chars_to_string(&attr);
        Nu16 {attr: u16::from_str(&n).unwrap()}
    }
}

// Create i32 from chars.
pub struct Ni32{pub attr: i32}

impl Ni32 {
    pub fn new(attr: &Vec<char>) -> Ni32 {
        let n = chars_to_string(&attr);
        Ni32 {attr: i32::from_str(&n).unwrap()}
    }
}

// Create u32 from chars.
pub struct Nu32{pub attr: u32}

impl Nu32 {
    pub fn new(attr: &Vec<char>) -> Nu32 {
        let n = chars_to_string(&attr);
        Nu32 {attr: u32::from_str(&n).unwrap()}
    }
}

// Create i64 from chars.
pub struct Ni64{pub attr: i64}

impl Ni64 {
    pub fn new(attr: &Vec<char>) -> Ni64 {
        let n = chars_to_string(&attr);
        Ni64 {attr: i64::from_str(&n).unwrap()}
    }
}

// Create u64 from chars.
pub struct Nu64{pub attr: u64}

impl Nu64 {
    pub fn new(attr: &Vec<char>) -> Nu64 {
        let n = chars_to_string(&attr);
        Nu64 {attr: u64::from_str(&n).unwrap()}
    }
}

// Create isize from chars.
pub struct Nisize{pub attr: isize}

impl Nisize {
    pub fn new(attr: &Vec<char>) -> Nisize {
        let n = chars_to_string(&attr);
        Nisize {attr: isize::from_str(&n).unwrap()}
    }
}

// Create usize from chars.
pub struct Nusize{pub attr: usize}

impl Nusize {
    pub fn new(attr: &Vec<char>) -> Nusize {
        let n = chars_to_string(&attr);
        Nusize {attr: usize::from_str(&n).unwrap()}
    }
}

// Create string literal from chars.
pub struct Literal{pub attr: String}

impl Literal {
    pub fn new(attr: &Vec<char>) -> Literal {
        Literal {attr: chars_to_string(&attr)}
    }
}