clean

src/data.rs

 use bincode::{Decode, Encode};
 use itertools::{EitherOrBoth, Itertools};
 use serde::{Deserialize, Serialize};
-use std::{collections::BTreeMap, sync::OnceLock};
+use std::{
+    collections::BTreeMap,
+    fmt::{Debug, Display},
+    sync::OnceLock,
+};
 use string_interner::{StringInterner, Symbol, backend::StringBackend};
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -96,7 +100,7 @@ pub struct Database {
 }
 
 pub static DATABASE: std::sync::LazyLock<Database> = std::sync::LazyLock::new(|| Database {
-    routers: register(load_file("import/data/Router.json"), |r| r.id.0, |r| r.name.clone(), &ROUTER_ID_REGISTRY),
+    routers: register(load_file("import/data/Router.json"), |r| r.id, |r| r.name.clone(), &ROUTER_ID_REGISTRY),
     gateways: load_file("import/data/Gateway.json"),
     gateway_groups: load_file("import/data/GatewayGroup.json"),
     regions: load_file("import/data/Region.json"),
@@ -109,28 +113,24 @@ fn load_file<T: serde::de::DeserializeOwned>(path: &str) -> T {
     serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap()
 }
 
-pub fn register<T, I, N, S, Sym>(mut data: Vec<T>, num: N, str: S, registry: &OnceLock<StringInterner<StringBackend<Sym>>>) -> Vec<T>
+pub fn register<T, N, S, Sym>(mut data: Vec<T>, num: N, str: S, registry: &OnceLock<StringInterner<StringBackend<Sym>>>) -> Vec<T>
 where
     T: serde::de::DeserializeOwned,
-    N: Fn(&T) -> I,
+    N: Fn(&T) -> Sym,
     S: Fn(&T) -> String,
-    I: Ord + Copy + std::fmt::Display + From<u8>,
-    std::ops::RangeInclusive<I>: Iterator<Item = I>,
-    Sym: Symbol + std::fmt::Debug,
+    Sym: Symbol + Debug + Ord,
 {
     data.sort_by_key(&num);
 
     let mut interner = StringInterner::<StringBackend<Sym>>::new();
     if let Some(max_id) = data.last().map(&num) {
-        for item in (I::from(0)..=max_id).merge_join_by(data.iter(), |i, r| i.cmp(&num(r))) {
+        for item in (0..=max_id.to_usize()).merge_join_by(data.iter(), |i, r| i.cmp(&num(r).to_usize())) {
             let name = match item {
                 EitherOrBoth::Both(_, r) => str(r),
                 EitherOrBoth::Left(i) => i.to_string(),
                 EitherOrBoth::Right(_) => unreachable!(),
             };
-            let symbol = interner.get_or_intern(name);
-
-            println!("{:?} = {}", symbol, item.left().unwrap());
+            interner.get_or_intern(name);
         }
     }
     interner.shrink_to_fit();