tsp-solver 0.0.1

use crate::{common::TspRecord, TspDistance, TspResult, TspSolver};
use serde::{ser::SerializeMap, Serialize, Serializer};
use serde_json::ser::PrettyFormatter;
use std::{fs::File, path::Path};

impl<T: TspDistance> TspSolver<T> {
    pub fn save<P: AsRef<Path>>(&self, dir: P) -> TspResult<()>
    where
        T: Serialize,
    {
        let path = dir.as_ref();
        if !path.exists() {
            std::fs::create_dir_all(path)?;
        }
        let main = path.join("main.json");
        self.get_record().save(dir)?;
        save_json(self, &main)
    }
    pub fn get_record(&self) -> TspRecord {
        TspRecord {
            problem: self.problem_id.clone(),
            improves: self.improves,
            steps: self.steps,
            best_distance: self.best_distance,
            best_path: self.best_path.clone(),
        }
    }
}

impl TspRecord {
    pub fn save<P: AsRef<Path>>(&self, dir: P) -> TspResult<()> {
        let file = dir.as_ref().join(format!("step_{}.json", self.improves));
        save_json(self, &file)
    }
}

fn save_json<T: Serialize>(object: T, path: &Path) -> TspResult<()> {
    let file = File::create(path)?;
    let mut ser = serde_json::Serializer::with_formatter(file, PrettyFormatter::with_indent(b"    "));
    Ok(object.serialize(&mut ser)?)
}

impl<T: TspDistance> Serialize for TspSolver<T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(2))?;
        map.serialize_entry("problem_id", &self.problem_id)?;
        map.serialize_entry("objects", &self.objects)?;
        map.serialize_entry("improves", &self.improves)?;
        map.end()
    }
}