lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README | LICENSE

types.rs (2796B)

      1 #[cfg(not(feature = "std"))]
      2 use alloc::string::String;
      3 
      4 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
      5 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
      6 pub struct RadrootsEventsIndexedShardId(pub String);
      7 
      8 #[cfg_attr(feature = "dto-bindgen", derive(dto_bindgen::Dto))]
      9 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
     10 #[derive(Clone, Debug, PartialEq, Eq)]
     11 pub struct RadrootsEventsIndexedIdRange {
     12     pub start: String,
     13     pub end: String,
     14 }
     15 
     16 impl RadrootsEventsIndexedIdRange {
     17     pub fn is_valid(&self) -> bool {
     18         if self.start.is_empty() || self.end.is_empty() {
     19             return false;
     20         }
     21         if self.start.len() != self.end.len() {
     22             return false;
     23         }
     24         if !self.start.chars().all(|c| c.is_ascii_hexdigit())
     25             || !self.end.chars().all(|c| c.is_ascii_hexdigit())
     26         {
     27             return false;
     28         }
     29         self.start <= self.end
     30     }
     31 }
     32 
     33 #[cfg(test)]
     34 mod tests {
     35     use super::RadrootsEventsIndexedIdRange;
     36     #[cfg(not(feature = "std"))]
     37     use alloc::string::String;
     38     #[cfg(feature = "std")]
     39     use std::string::String;
     40 
     41     #[test]
     42     fn id_range_rejects_non_hex() {
     43         let range = RadrootsEventsIndexedIdRange {
     44             start: String::from("zz"),
     45             end: String::from("ff"),
     46         };
     47         assert!(!range.is_valid());
     48     }
     49 
     50     #[test]
     51     fn id_range_rejects_mismatched_length() {
     52         let range = RadrootsEventsIndexedIdRange {
     53             start: String::from("0a"),
     54             end: String::from("0aa"),
     55         };
     56         assert!(!range.is_valid());
     57     }
     58 
     59     #[test]
     60     fn id_range_rejects_reverse_order() {
     61         let range = RadrootsEventsIndexedIdRange {
     62             start: String::from("0f"),
     63             end: String::from("0a"),
     64         };
     65         assert!(!range.is_valid());
     66     }
     67 
     68     #[test]
     69     fn id_range_accepts_hex_order() {
     70         let range = RadrootsEventsIndexedIdRange {
     71             start: String::from("0a"),
     72             end: String::from("0f"),
     73         };
     74         assert!(range.is_valid());
     75     }
     76 
     77     #[test]
     78     fn id_range_rejects_empty_bounds() {
     79         let range = RadrootsEventsIndexedIdRange {
     80             start: String::new(),
     81             end: String::from("0f"),
     82         };
     83         assert!(!range.is_valid());
     84     }
     85 
     86     #[test]
     87     fn id_range_rejects_empty_end() {
     88         let range = RadrootsEventsIndexedIdRange {
     89             start: String::from("0f"),
     90             end: String::new(),
     91         };
     92         assert!(!range.is_valid());
     93     }
     94 
     95     #[test]
     96     fn id_range_rejects_non_hex_end() {
     97         let range = RadrootsEventsIndexedIdRange {
     98             start: String::from("0f"),
     99             end: String::from("zz"),
    100         };
    101         assert!(!range.is_valid());
    102     }
    103 }