gust 0.1.4

A small charting library for generating d3 and html charts using Rust 
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
103
104
105
106
107
108
109
110
111
112


/*
 *  Author: Samuel Resendez
 */
use backend::elements::bar_chart::*;
use backend::traits::Graphable;
use serde::ser::{Serialize, SerializeStruct, Serializer};


pub struct BarChart {
    identifier: String,
    description: String,
    width: i32,
    height: i32,
    padding: i32,

    data: Vec<BarChartData>,
    scales: Vec<BarChartScale>,
    axes: Vec<BarChartAxis>,
    marks: Vec<BarChartMark>,
}

impl BarChart {
    pub fn new() -> BarChart {
        BarChart {
            identifier: String::from("barchart"),
            description: String::from("A barchart"),
            width: 500,
            height: 300,
            padding: 5,

            data: vec![BarChartData::new()],
            scales: vec![
                BarChartScale::create_xscale(),
                BarChartScale::create_yscale(),
            ],
            axes: vec![BarChartAxis::create_xaxis(), BarChartAxis::create_yaxis()],
            marks: vec![BarChartMark::create_mark()],
        }
    }
    /// Bar Chart accept data in the following format:
    /// { String, Integer }, which represent the category (aka Bar), as well as the value of that bar
    /// (i.e. it's height).
    pub fn add_data(&mut self, category: String, amount: i32) {
        self.data[0].add_data(category, amount);
    }

    /// Sets the description that is used to title the chart when rendering
    pub fn set_description(&mut self, description: &str) {
        self.description = String::from(description);
    }

    ///Sets the identifier for the graph. This is the value used when
    /// actually naming the file, so you can expect files rendered to fit
    /// the following format: <identifier>.<extension>
    pub fn set_identifier(&mut self, id: &str) {
        self.identifier = String::from(id);
    }

    ///This sets the size of the overal graph to be rendered
    /// The tuple it takes represents the (height, width)
    pub fn set_dimension(&mut self, t: (i32, i32)) {
        self.height = t.0;
        self.width = t.1;
    }

    /// Sets the number of padding pixels around the chart
    pub fn set_padding(&mut self, pad: i32) {
        self.padding = pad;
    }

    /// clear_data empties out all of the data entries
    /// that currently exist in the given graph
    pub fn clear_data(&mut self) {
        self.data[0].clear()
    }

    /// set_color sets the default color of the bars in the bar chart
    pub fn set_color(&mut self, color: &str) {
        self.marks[0].set_color(color);
    }
}

impl Serialize for BarChart {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_struct("graph", 10)?;
        s.serialize_field(
            "$schema",
            "https://vega.github.io/schema/vega/v3.0.json",
        )?;
        s.serialize_field("width", &self.width)?;
        s.serialize_field("height", &self.height)?;
        s.serialize_field("padding", &self.padding)?;
        s.serialize_field("data", &self.data)?;
        s.serialize_field("scales", &self.scales)?;
        s.serialize_field("axes", &self.axes)?;
        s.serialize_field("marks", &self.marks)?;
        s.end()
    }
}

impl Graphable for BarChart {
    fn get_description(&self) -> &str {
        &self.description
    }
    fn get_identifier(&self) -> &str {
        &self.identifier
    }
}