series.h

Go to the documentation of this file.

#pragma once
#include "interop/model/plot/data_point_collection.h"

namespace illumina { namespace interop { namespace model { namespace plot {

    template<class Point>
    class series : public data_point_collection<Point>
    {
    public:
        typedef std::vector<std::string> options_t;
        typedef data_point_collection<Point> point_collection_t;
    public:
        typedef typename point_collection_t::const_iterator const_iterator;
        typedef typename point_collection_t::const_reference const_reference;
        typedef typename point_collection_t::reference reference;
        typedef typename point_collection_t::size_type size_type;

    public:
        enum series_types
        {
            Candlestick,
            Line,
            Bar
        };

    public:
        series(const std::string& title="",
               const std::string color="Blue",
               const series_types series_type=Candlestick) :
                m_title(title),
                m_color(color),
                m_series_type(series_type){}

    public:
        const std::string& title()const
        {
            return m_title;
        }
        const std::string& color()const
        {
            return m_color;
        }
        series_types series_type()const
        {
            return m_series_type;
        }
        const options_t& options()const
        {
            return m_options;
        }
    public:
        void add_option(const std::string& option)
        {
            m_options.push_back(option);
        }
        void color(const std::string& color_name)
        {
            m_color = color_name;
        }

        friend std::ostream& operator<<(std::ostream& out, const series& data)
        {
            out << data.m_title << ",";
            out << data.m_color << ",";
            out << data.m_series_type << ",";
            out << data.m_options.size() << ",";
            for(size_t i=0;i<data.m_options.size();++i)
                out << data.m_options[i] << ",";
            out << data.size() << ",";
            for(size_t i=0;i<data.size();++i)
            {
                out << data[i];
            }
            return out;
        }
        friend std::istream& operator>>(std::istream& in, series& data)
        {
            std::string tmp;
            std::getline(in, data.m_title, ',');
            std::getline(in, data.m_color, ',');
            std::getline(in, tmp, ',');
            int series_type = util::lexical_cast<int>(tmp);
            data.m_series_type = static_cast<series_types>(series_type);

            std::getline(in, tmp, ',');
            size_t num_options = util::lexical_cast<size_t>(tmp);
            data.m_options.resize(num_options);
            for(size_t i=0;i<data.m_options.size();++i)
            {
                std::getline(in, data.m_options[i], ',');
            }

            std::getline(in, tmp, ',');
            size_t num_points = util::lexical_cast<size_t>(tmp);
            data.resize(num_points);
            for(size_t i=0;i<data.size();++i)
            {
                in >> data[i];
            }
            return in;
        }

    private:
        std::string m_title;
        std::string m_color;
        series_types m_series_type;
        options_t m_options;
    };


}}}}