BarChart.h

Go to the documentation of this file.

#ifndef BAR_CHART_H
#define BAR_CHART_H
 
#include <unordered_map>
#include <vector>
#include <string>
#include <DataStructure.h>
#include <JSONutil.h>
 
namespace bridges {
    namespace datastructure {
 
        class BarChart : public DataStructure {
            private:
                std::string cLabel;
                std::string vLabel;
                std::string title;
                std::string subTitle;
                std::string tooltipSuffix;
                std::string orientation;
 
                std::vector<std::pair<string, vector<double >>>  seriesData; //name, data
                std::vector<std::string> categories;
 
            public:
                BarChart() {
                    title = "";
                    subTitle = "";
                    vLabel = "";
                    cLabel = "";
                    tooltipSuffix = "";
                    orientation = "horizontal";
                }
 
                virtual const string getDStype() const override {
                    return "BarChart";
                }
 
                void setTitle(std::string t) {
                    title = t;
                }
 
                std::string getTitle() const {
                    return title;
                }
 
                void setSubTitle(const std::string& s) {
                    subTitle = s;
                }
 
                std::string getSubTitle() const {
                    return subTitle;
                }
 
                void setValueLabel(const std::string& vAxisName) {
                    vLabel = vAxisName;
                }
 
                std::string getValueLabel() const {
                    return vLabel;
                }
 
                void setCategoriesLabel(const std::string& cAxisName) {
                    cLabel = cAxisName;
                }
 
                std::string getCategoriesLabel() const {
                    return cLabel;
                }
 
                void setBarOrientation(const std::string& orient) {
                    if (orient != "horizontal" && orient != "vertical")
                        throw std::invalid_argument("Orientation should be \"horizontal\" or \"vertical\".");
                    orientation = orient;
                }
 
                std::string getBarOrientation() const {
                    return orientation;
                }
 
                void setTooltipSuffix(const std::string& suffix) {
                    tooltipSuffix = suffix;
                }
 
                std::string getTooltipSuffix() const {
                    return tooltipSuffix;
                }
 
                void setCategories(std::vector<std::string> categories) {
                    if (seriesData.size() > 0)
                        throw std::runtime_error ("Can't change categoriess after series have been added.");
                    this->categories = categories;
                }
 
                void addDataSeries(std::string seriesName, std::vector<double> data) {
                    if (data.size() != categories.size())
                        throw std::runtime_error ("The data vector should have the same size as the number of categories.");
 
                    for (auto& entry : seriesData) {
                        std::string key = entry.first;
                        if (key == seriesName)
                            throw std::runtime_error ("Can't have two series with the same name.");
                    }
 
                    seriesData.push_back(std::make_pair(seriesName, data));
                }
 
                virtual const std::string getDataStructureRepresentation() const override {
                    using bridges::JSONUtil::JSONencode;
                    std::string bins = "";
                    bins += JSONencode("xAxis") + COLON + OPEN_CURLY + JSONencode("categories") + COLON + OPEN_BOX;
                    for (auto& entry : categories) {
                        bins += JSONencode(entry) + COMMA;
                    }
                    bins = bins.erase(bins.length() - 1);
                    bins += CLOSE_BOX + CLOSE_CURLY;
 
                    std::string series = "";
                    series += JSONencode("series") + COLON + OPEN_BOX;
                    for (auto& entry : seriesData) {
                        series += OPEN_CURLY;
                        std::string key = entry.first;
                        std::vector<double> value = entry.second;
 
                        series += JSONencode("name") + COLON + JSONencode(key) + COMMA + JSONencode("data") + COLON + OPEN_BOX;
                        for (int i = 0; i < value.size(); i++) {
                            series += JSONencode(value[i]) + COMMA;
                        }
                        series = series.erase(series.length() - 1);
                        series += CLOSE_BOX + CLOSE_CURLY + COMMA;
                    }
                    series = series.erase(series.length() - 1);
                    series += CLOSE_BOX;
 
                    std::string json_str = JSONencode("plot_title") + COLON +  JSONencode(getTitle()) + COMMA +
                        JSONencode("subtitle") + COLON + JSONencode(getSubTitle())  + COMMA +
                        JSONencode("xLabel") + COLON + JSONencode(getCategoriesLabel()) +  COMMA +
                        JSONencode("yLabel") + COLON + JSONencode(getValueLabel()) + COMMA +
                        JSONencode("tooltipSuffix") + COLON + JSONencode(getTooltipSuffix()) + COMMA +
                        JSONencode("alignment") + COLON + JSONencode(getBarOrientation()) + COMMA +
                        JSONencode("xaxis_data") + COLON + OPEN_CURLY + bins + CLOSE_CURLY + COMMA +
                        JSONencode("yaxis_data") + COLON + OPEN_CURLY + series + CLOSE_CURLY + CLOSE_CURLY;
 
                    return json_str;
                }
        };
    };
}
#endif