use crate::error::Error;
const MAGIC: &[u8; 4] = b"JRGD";
const FORMAT_VERSION: u16 = 1;
pub(crate) struct Pref {
pub code: u8,
pub name: String,
}
pub(crate) struct City {
pub code: u32,
pub pref_idx: u8,
pub name: String,
}
pub(crate) struct Record {
pub city_idx: u16,
pub town_name_idx: u32,
pub town_code: u64,
pub lat_micro: i32,
pub lon_micro: i32,
}
impl Record {
pub fn lat(&self) -> f64 {
self.lat_micro as f64 / 1e6
}
pub fn lon(&self) -> f64 {
self.lon_micro as f64 / 1e6
}
}
pub(crate) struct MeshEntry {
pub mesh: u32,
pub start: u32,
pub len: u32,
}
pub(crate) struct Store {
pub data_version: String,
pub prefs: Vec<Pref>,
pub cities: Vec<City>,
pub town_names: Vec<String>,
pub records: Vec<Record>,
pub mesh_index: Vec<MeshEntry>,
}
impl Store {
pub fn from_compressed(compressed: &[u8]) -> Result<Self, Error> {
let payload = miniz_oxide::inflate::decompress_to_vec(compressed)
.map_err(|e| Error::InvalidData(format!("decompression failed: {e}")))?;
Self::from_payload(&payload)
}
fn from_payload(payload: &[u8]) -> Result<Self, Error> {
let mut cur = Cursor {
buf: payload,
pos: 0,
};
if cur.bytes(4)? != MAGIC {
return Err(Error::InvalidData("magic mismatch".into()));
}
let version = cur.u16()?;
if version != FORMAT_VERSION {
return Err(Error::InvalidData(format!(
"unsupported format version: {version} (supported: {FORMAT_VERSION})"
)));
}
let data_version = cur.str8()?;
let pref_count = cur.u8()? as usize;
let mut prefs = Vec::with_capacity(pref_count);
for _ in 0..pref_count {
let code = cur.u8()?;
let name = cur.str16()?;
prefs.push(Pref { code, name });
}
let city_count = cur.u16()? as usize;
let mut cities = Vec::with_capacity(city_count);
for _ in 0..city_count {
let code = cur.u32()?;
let pref_idx = cur.u8()?;
if pref_idx as usize >= prefs.len() {
return Err(Error::InvalidData(format!(
"pref_idx out of range: {pref_idx}"
)));
}
let name = cur.str16()?;
cities.push(City {
code,
pref_idx,
name,
});
}
let town_name_count = cur.u32()? as usize;
let mut town_names = Vec::with_capacity(town_name_count);
for _ in 0..town_name_count {
town_names.push(cur.str16()?);
}
let record_count = cur.u32()? as usize;
let mut records = Vec::with_capacity(record_count);
for _ in 0..record_count {
let city_idx = cur.u16()?;
let town_name_idx = cur.u32()?;
let town_code = cur.u64()?;
let lat_micro = cur.i32()?;
let lon_micro = cur.i32()?;
if city_idx as usize >= cities.len() {
return Err(Error::InvalidData(format!(
"city_idx out of range: {city_idx}"
)));
}
if town_name_idx as usize >= town_names.len() {
return Err(Error::InvalidData(format!(
"town_name_idx out of range: {town_name_idx}"
)));
}
records.push(Record {
city_idx,
town_name_idx,
town_code,
lat_micro,
lon_micro,
});
}
let mesh_count = cur.u32()? as usize;
let mut mesh_index: Vec<MeshEntry> = Vec::with_capacity(mesh_count);
for _ in 0..mesh_count {
let mesh = cur.u32()?;
let start = cur.u32()?;
let len = cur.u32()?;
let end = (start as usize)
.checked_add(len as usize)
.ok_or_else(|| Error::InvalidData("mesh range overflow".into()))?;
if end > records.len() {
return Err(Error::InvalidData(format!(
"mesh range out of bounds: start={start} len={len}"
)));
}
if let Some(prev) = mesh_index.last() {
if prev.mesh >= mesh {
return Err(Error::InvalidData("mesh index is not sorted".into()));
}
}
mesh_index.push(MeshEntry { mesh, start, len });
}
if cur.pos != payload.len() {
return Err(Error::InvalidData("trailing bytes in payload".into()));
}
Ok(Store {
data_version,
prefs,
cities,
town_names,
records,
mesh_index,
})
}
}
struct Cursor<'a> {
buf: &'a [u8],
pos: usize,
}
impl<'a> Cursor<'a> {
fn bytes(&mut self, n: usize) -> Result<&'a [u8], Error> {
let end = self
.pos
.checked_add(n)
.filter(|&e| e <= self.buf.len())
.ok_or_else(|| Error::InvalidData("unexpected end of data".into()))?;
let s = &self.buf[self.pos..end];
self.pos = end;
Ok(s)
}
fn u8(&mut self) -> Result<u8, Error> {
Ok(self.bytes(1)?[0])
}
fn u16(&mut self) -> Result<u16, Error> {
Ok(u16::from_le_bytes(self.bytes(2)?.try_into().unwrap()))
}
fn u32(&mut self) -> Result<u32, Error> {
Ok(u32::from_le_bytes(self.bytes(4)?.try_into().unwrap()))
}
fn i32(&mut self) -> Result<i32, Error> {
Ok(i32::from_le_bytes(self.bytes(4)?.try_into().unwrap()))
}
fn u64(&mut self) -> Result<u64, Error> {
Ok(u64::from_le_bytes(self.bytes(8)?.try_into().unwrap()))
}
fn str8(&mut self) -> Result<String, Error> {
let len = self.u8()? as usize;
self.str_of(len)
}
fn str16(&mut self) -> Result<String, Error> {
let len = self.u16()? as usize;
self.str_of(len)
}
fn str_of(&mut self, len: usize) -> Result<String, Error> {
let bytes = self.bytes(len)?;
std::str::from_utf8(bytes)
.map(|s| s.to_string())
.map_err(|_| Error::InvalidData("invalid UTF-8 string".into()))
}
}