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
113
114
115
116


/*
 * Author: Samuel Resendez
 */

use backend::elements::stacked_bar_chart::*;
use backend::traits::Graphable;

use serde::ser::{Serialize, SerializeStruct, Serializer};


pub struct StackedBarChart {
    identifier: String,
    description: String,
    width: u32,
    height: u32,
    padding: u32,

    data: Vec<StackedBarData>,

    scales: Vec<StackedBarScale>,
    axes: Vec<StackedBarAxis>,
    marks: Vec<StackedBarMark>,
}


impl StackedBarChart {
    pub fn new() -> StackedBarChart {
        StackedBarChart {
            identifier: String::from("stacked_bar_chart"),
            description: String::from("Stacked Bar Chart"),
            width: 500,
            height: 300,
            padding: 5,
            data: vec![StackedBarData::new()],

            scales: vec![
                StackedBarScale::new_xscale(),
                StackedBarScale::new_yscale(),
                StackedBarScale::new_ordinal_scale(),
            ],
            axes: vec![StackedBarAxis::new_xaxis(), StackedBarAxis::new_yaxis()],
            marks: vec![StackedBarMark::new()],
        }
    }

    pub fn set_identifier(&mut self, id: &str) {
        self.identifier = String::from(id);
    }

    pub fn set_description(&mut self, description: &str) {
        self.description = String::from(description);
    }

    /// Sets the dimensions of the graph:
    /// the dimensions are set as (height, width)
    pub fn set_dimensions(&mut self, t: (u32, u32)) {
        self.height = t.0;
        self.width = t.1;
    }
    /// Sets the padding pixel count around the border of the graph
    pub fn set_padding(&mut self, padding: u32) {
        self.padding = padding;
    }

    /// adds data to the stacked_bar chart
    /// x value denotes which bar the value is supposed to be on.
    /// y values denotes the height of the bar
    /// z is the stratification variable, meaning you can separate multiple stacked bars based on
    /// z.
    /// # Example:
    /// ```rust
    ///    use gust::backend::stacked_bar_chart::StackedBarChart;
    ///
    ///    let mut b = StackedBarChart::new();
    ///    for i in 0..10 {
    ///        b.add_data(i, i * i, 1);
    ///        b.add_data(i, i + i, 0);
    ///    }
    /// ```
    /// Here, we see there are two values entered for each i, one with a 1 value for z, and one with
    /// a zero value. This is how gust splits the stacked bars into two.
    pub fn add_data(&mut self, x: i64, y: i64, z: i64) {
        self.data[0].add_data(x, y, z);
    }
}
impl Serialize for StackedBarChart {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_struct("sb_graph", 9)?;
        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 StackedBarChart {
    fn get_description(&self) -> &str {
        &self.description
    }
    fn get_identifier(&self) -> &str {
        &self.identifier
    }
}