plot_data.h

Go to the documentation of this file.

#pragma once
#include "interop/util/exception.h"
#include "interop/model/plot/series.h"
#include "interop/model/plot/axes.h"
#include "interop/model/plot/chart_data.h"

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

    template<class Point>
    class plot_data : public chart_data
    {
        typedef series<Point> series_t;
        typedef std::vector<series_t> series_collection_t;
    public:
        typedef typename series_collection_t::const_reference const_reference;
        typedef typename series_collection_t::reference reference;
        typedef typename series_collection_t::size_type size_type;
        typedef typename series_collection_t::iterator iterator;
        typedef typename series_collection_t::const_iterator const_iterator;

    public:
        const series<Point>& at(const size_t index)const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(index,  m_series.size(), "Index out of bounds");
            return m_series[index];
        }
        series<Point>& operator[](const size_t index) INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(index,  m_series.size(), "Index out of bounds");
            return m_series[index];
        }
        const series<Point>& operator[](const size_t index)const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(index,  m_series.size(), "Index out of bounds");
            return m_series[index];
        }
        size_t size()const
        {
            return m_series.size();
        }
        bool empty()const
        {
            return size()==0;
        }
    public:
        void clear()
        {
            m_series.clear();
            chart_data::clear();
        }
        void resize(const size_t n)
        {
            m_series.resize(n);
        }
        void assign(const size_t n, const series<Point>& val)
        {
            m_series.assign(n, val);
        }
        void push_back(const series<Point>& val)
        {
            m_series.push_back(val);
        }
        const_iterator begin()const
        {
            return m_series.begin();
        }
        const_iterator end()const
        {
            return m_series.end();
        }
        friend std::ostream& operator<<(std::ostream& out, const plot_data& data)
        {
            out << static_cast<const chart_data&>(data);
            out << data.m_series.size() << ",";
            for(size_t i=0;i<data.m_series.size();++i)
                out << data.m_series[i];
            return out;
        }
        friend std::istream& operator>>(std::istream& in, plot_data& data)
        {
            std::string tmp;
            in >> static_cast<chart_data&>(data);
            std::getline(in, tmp, ',');
            size_t n = util::lexical_cast<size_t>(tmp);
            data.m_series.resize(n);
            for(size_t i=0;i<data.m_series.size();++i)
                in >> data.m_series[i];
            return in;
        }

    private:
        series_collection_t m_series;
    };


}}}}