rumtk-core 0.9.6

Core library for providing general functionality to support the other RUMTK crates. See rumtk-hl7-v2 crate as example
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

/*
 * rumtk attempts to implement HL7 and medical protocols for interoperability in medicine.
 * This toolkit aims to be reliable, simple, performant, and standards compliant.
 * Copyright (C) 2025  Luis M. Santos, M.D.
 * Copyright (C) 2025  MedicalMasses L.L.C.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
use crate::strings::rumtk_format;
use crate::strings::RUMString;
pub use smallvec::{smallvec, SmallVec};

///
/// Type used for propagating error messages.
///
pub type RUMResult<T> = Result<T, RUMString>;

pub type RUMVec<T> = Vec<T>;

pub fn is_unique<T: std::cmp::Eq + std::hash::Hash>(data: &Vec<T>) -> bool {
    let mut keys = ahash::AHashSet::with_capacity(data.len());
    for itm in data {
        if !keys.insert(itm) {
            return false;
        }
    }
    true
}

///
/// Take a requested index and the maximum size of the item container.
/// Check if the index is valid and return an error if it is.
/// The purpose of this function is to enable handling of out of bounds without triggering a panic.
/// Also, add negative indices like Python does when doing a reverse search!
///
/// * If the index is 0, return Error
/// * If the index is below 0, return the max - index iff max - index > 0
/// * If the index is bigger than the defined max, return Error.
/// * Otherwise, return the given index.
///
/// # Examples
///
/// ## Min
/// ```
/// use ::rumtk_core::core::clamp_index;
/// use ::rumtk_core::strings::rumtk_format;
/// let max: isize = 5;
/// let i: isize = 1;
/// let result = clamp_index(&i, &max).unwrap();
/// assert_eq!(&1, &result, "{}", rumtk_format!("Expected to receive 0 but got {}", &result))
/// ```
///
/// ## Max
/// ```
/// use ::rumtk_core::core::clamp_index;
/// use ::rumtk_core::strings::rumtk_format;
/// let max: isize = 5;
/// let i: isize = 5;
/// let result = clamp_index(&i, &max).unwrap();
/// assert_eq!(&5, &result, "{}", rumtk_format!("Expected to receive 0 but got {}", &result))
/// ```
///
/// ## Valid
/// ```
/// use ::rumtk_core::core::clamp_index;
/// use ::rumtk_core::strings::rumtk_format;
/// let max: isize = 5;
/// let i: isize = 5;
/// let result = clamp_index(&i, &max).unwrap();
/// assert_eq!(&5, &result, "{}", rumtk_format!("Expected to receive 0 but got {}", &result))
/// ```
///
/// ## Valid Negative Index (reverse lookup)
/// ```
/// use ::rumtk_core::core::clamp_index;
/// use ::rumtk_core::strings::rumtk_format;
/// let max: isize = 5;
/// let i: isize = -1;
/// let result = clamp_index(&i, &max).unwrap();
/// assert_eq!(&5, &result, "{}", rumtk_format!("Expected to receive 0 but got {}", &result))
/// ```
#[inline(always)]
pub fn clamp_index(given_indx: &isize, max_size: &isize) -> RUMResult<usize> {
    let neg_max_indx = *max_size * -1;
    if *given_indx == 0 {
        return Err(rumtk_format!(
            "Index {} is invalid! Use 1-indexed values if using positive indices.",
            given_indx
        ));
    }

    if *given_indx >= neg_max_indx && *given_indx < 0 {
        return Ok((max_size + given_indx + 1) as usize);
    }

    if *given_indx > 0 && given_indx <= max_size {
        return Ok(*given_indx as usize);
    }

    Err(rumtk_format!(
        "Index {} is outside {} < x < {} boundary!",
        given_indx,
        neg_max_indx,
        max_size
    ))
}