core-dev 0.0.1

core-dev library is an utility library for rust. It contains a lot of useful functions and APIs to speed up development cycle.
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





use core::fmt;
use std::collections::HashMap;
use std::fmt::Display;
use std::fmt::Formatter;
use std::fmt::Result;
use std::hash::Hash;
use std::str::Chars;



pub struct Counter {
    _counter_char: HashMap<char, i32>,
    chars: bool,
    _counter_int: HashMap<i32, i32>,
}


impl Counter {
    fn create_hashmap_from_chars(_char_iter: Chars<'_>) -> HashMap<char, i32> {
        let mut _counter = HashMap::new();
        for _char in _char_iter {
            *_counter.entry(_char).or_insert(0) += 1;
        }
        _counter
    }

    pub fn from_str(_static_string: &str) -> Counter {
        Counter {
            _counter_char: Counter::create_hashmap_from_chars(_static_string.chars()),
            chars: true,
            _counter_int: HashMap::new(),
        }
    }

    pub fn from_string(_string: String) -> Counter {
        Counter {
            _counter_char: Counter::create_hashmap_from_chars(_string.chars()),
            chars: true,
            _counter_int: HashMap::new()
        }
    }

    pub fn from_string_ref(_string_ref: &String) -> Counter {
        Counter {
            _counter_char: Counter::create_hashmap_from_chars(_string_ref.chars()),
            chars: true,
            _counter_int: HashMap::new()
        }
    }

    pub fn from_i32(_i32_number: i32) -> Counter {
        let mut __i32_number: i32 = _i32_number;
        let mut _counter: HashMap<i32, i32> = HashMap::new();

        while __i32_number != 0 {
            let digit = __i32_number % 10;
            *_counter.entry(digit).or_insert(0) += 1;
            __i32_number /= 10;
        }

        Counter {
            _counter_char: HashMap::new(),
            chars: false,
            _counter_int: _counter,
        }
    }
}


impl Display for Counter {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        if self.chars {
            write!(f, "{:?}", self._counter_char)
        } else {
            write!(f, "{:?}", self._counter_int)
        }
    }
}

// impl Iterator for Counter {

//     fn next(&mut self) -> Option<> {
//         let res = self.vals.get(self.count);
//         match res {
//             Some(v) => {
//                 self.count += 1;
//                 Some(*v)
//             },
//             None => None,
//         }
//     }
// }