snark-tool 0.4.0

snark-tool library contains structures and algorithm for (mainly) cubic graph analysis
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use crate::graph::graph::{Graph, GraphConstructor};
use crate::procedure::basic_procedures::write::GraphWithProperties;
use crate::procedure::procedure::GraphProperties;
use crate::service::io::error::ReadError;
use crate::service::io::reader::GraphFileReader;
use crate::service::io::reader_g6::G6Reader;
use crate::service::io::reader_s6::S6Reader;
use std::fs::File;
use std::io::Read;
use std::{fs, marker, result};

type Result<T> = result::Result<T, ReadError>;

pub struct JsonReader<'a, G> {
    file: &'a fs::File,
    parsed: bool,
    position: usize,
    graphs: Vec<GraphWithProperties>,
    _ph: marker::PhantomData<G>,
}

impl<'a, G> GraphFileReader<'a, G> for JsonReader<'a, G>
where
    G: Graph + GraphConstructor,
{
    fn new(file: &'a File) -> Self {
        JsonReader {
            file,
            parsed: false,
            position: 0,
            graphs: vec![],
            _ph: marker::PhantomData,
        }
    }

    fn next(&mut self) -> Option<Result<G>> {
        unimplemented!();

        // if !self.parsed {
        //     self.parse_file();
        // }
        // if self.position < self.graphs.len() {
        //     self.position += 1;
        //     // read graph by format at position
        //     // return graph
        // }
        // None
    }
}

impl<'a, G: Graph + GraphConstructor> JsonReader<'a, G> {
    fn parse_file(&mut self) -> Result<()> {
        let file_string = &mut "".to_string();
        self.file.read_to_string(file_string)?;
        let graphs_res = serde_json::from_str(file_string);
        self.graphs = graphs_res.unwrap();
        self.parsed = true;
        Ok(())
    }

    pub fn next_with_properties(&mut self) -> Option<Result<(G, GraphProperties)>> {
        if !self.parsed {
            let parse_result = self.parse_file();
            if parse_result.is_err() {
                return Some(Err(parse_result.err().unwrap()));
            }
        }
        if self.position < self.graphs.len() {
            let graph_with_properties = &self.graphs[self.position];
            self.position += 1;
            let graph = Self::read_graph(
                &graph_with_properties.graph,
                &graph_with_properties.graph_format,
            );
            if graph.is_err() {
                return Some(Err(graph.err().unwrap()));
            }
            let result = (graph.unwrap(), graph_with_properties.properties.clone());
            return Some(Ok(result));
        }
        None
    }

    fn read_graph(graph: &String, graph_format: &String) -> Result<G> {
        match graph_format.as_str() {
            "g6" => {
                return G6Reader::read_graph(graph);
            }
            "s6" => {
                return S6Reader::read_graph(graph);
            }
            _ => {
                return Err(ReadError {
                    message: format!(
                        "unknown graph format to read from json object: {}",
                        graph_format
                    ),
                });
            }
        }
    }
}