japan-reverse-geocoder 0.1.0

国土交通省の位置参照情報(大字・町丁目レベル)を同梱した日本の逆ジオコーディングライブラリ / Offline reverse geocoding for Japan using MLIT location reference data
Documentation
//! データバイナリのパース
//!
//! # バイナリ形式(フォーマットバージョン1)
//!
//! ファイル全体がDEFLATE圧縮されており、展開後のペイロードは以下のリトルエンディアン
//! 固定レイアウト。生成側は`tools/build-data`。**形式を変更する場合は両方を同時に更新すること。**
//!
//! ```text
//! magic:            "JRGD" (4バイト)
//! format_version:   u16
//! data_version:     u8長 + UTF-8バイト列(例: "19.0b")
//! 都道府県テーブル:   u8件数 { code: u8, name: u16長 + UTF-8 }
//! 市区町村テーブル:   u16件数 { code: u32, pref_idx: u8, name: u16長 + UTF-8 }
//! 大字町丁目名テーブル: u32件数 { u16長 + UTF-8 }(重複排除済み)
//! レコード:          u32件数 {
//!                      city_idx: u16, town_name_idx: u32, town_code: u64,
//!                      lat_micro: i32, lon_micro: i32   // マイクロ度(1e-6度)
//!                    }(2次メッシュコード順にソート済み)
//! メッシュ索引:       u32件数 { mesh_code: u32, start: u32, len: u32 }
//!                    (mesh_code昇順。start/lenはレコード配列の範囲)
//! ```

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()))
    }
}