run_summary.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include "interop/util/exception.h"
#include "interop/util/assert.h"
#include "interop/model/run/info.h"
#include "interop/model/summary/read_summary.h"
#include "interop/model/model_exceptions.h"
#include "interop/io/stream_exceptions.h"

namespace illumina { namespace interop { namespace model { namespace summary
{
    class run_summary
    {
    public:
        typedef std::vector<read_summary> read_summary_vector_t;
    public:
        typedef read_summary_vector_t::reference reference;
        typedef read_summary_vector_t::const_reference const_reference;
        typedef read_summary_vector_t::iterator iterator;
        typedef read_summary_vector_t::const_iterator const_iterator;
        typedef read_summary_vector_t::size_type size_type;
    public:
        run_summary() : m_surface_count(0),
                        m_lane_count(0),
                        m_read_count(0),
                        m_channel_count(0),
                        m_total_summary(0),
                        m_nonindex_summary(0)
        {
        }

        template<typename I>
        run_summary(I beg, I end, const size_t lane_count, const size_t surface_count, const size_t channel_count) :
                m_surface_count(surface_count),
                m_lane_count(lane_count),
                m_read_count(static_cast<size_t>(std::distance(beg, end))),
                m_channel_count(channel_count),
                m_total_summary(channel_count),
                m_nonindex_summary(channel_count),
                m_summary_by_read(beg, end)
        {
            preallocate_memory();
        }

        run_summary(const std::vector<run::read_info> &reads,
                    const size_t lane_count,
                    const size_t surface_count,
                    const size_t channel_count) :
                m_surface_count(surface_count),
                m_lane_count(lane_count),
                m_read_count(reads.size()),
                m_channel_count(channel_count),
                m_total_summary(channel_count),
                m_nonindex_summary(channel_count),
                m_summary_by_read(reads.begin(), reads.end())
        {
            preallocate_memory();
        }

    public:
        void initialize(const run::info& run_info)
        {
            initialize(run_info.reads(), run_info.flowcell().lane_count(), run_info.flowcell().surface_count(), run_info.channels().size());
        }
        void initialize(const std::vector<run::read_info> &reads,
                        const size_t lane_count,
                        const size_t surface_count,
                        const size_t channel_count)
        {
            m_total_summary = metric_summary(channel_count);
            m_nonindex_summary = metric_summary(channel_count);
            m_cycle_state = cycle_state_summary();
            m_channel_count = channel_count;
            m_read_count = reads.size();
            m_summary_by_read.clear();
            m_summary_by_read.reserve(reads.size());
            for (size_t read = 0; read < reads.size(); ++read)
                m_summary_by_read.push_back(read_summary(reads[read], channel_count));
            m_lane_count = lane_count;
            m_surface_count = surface_count;
            preallocate_memory();
        }
        void copy_reads(std::vector<run::read_info> & dst)
        {
            dst.resize(size());
            for(size_t i=0;i<dst.size();++i) dst[i] = m_summary_by_read[i].read();
        }

    private:
        void preallocate_memory()
        {
            m_total_summary = metric_summary(m_channel_count);
            m_nonindex_summary = metric_summary(m_channel_count);
            m_cycle_state = cycle_state_summary();
            for (iterator b = m_summary_by_read.begin(), e = m_summary_by_read.end(); b != e; ++b)
            {
                b->resize(m_lane_count);
                b->summary().resize(m_channel_count);
                for (size_t lane = 0; lane < m_lane_count; ++lane)
                {
                    b->operator[](lane).lane(lane + 1);
                    b->operator[](lane).resize_stat(m_channel_count);
                    if(m_surface_count > 1)
                    {
                        b->operator[](lane).resize(m_surface_count);
                        for (size_t surface = 0; surface < m_surface_count; ++surface)
                        {
                            b->operator[](lane)[surface].surface(surface + 1);
                            b->operator[](lane)[surface].resize_stat(m_channel_count);
                        }
                    }
                }
            }
        }


    public:
        read_summary & operator[](const size_t n) INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(n, m_summary_by_read.size(), "Read index exceeds read count");
            return m_summary_by_read[n];
        }

        const read_summary & operator[](const size_t n) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(n, m_summary_by_read.size(), "Read index exceeds read count");
            return m_summary_by_read[n];
        }

        read_summary &at(const size_t n) INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(n, m_summary_by_read.size(), "Read index exceeds read count");
            return m_summary_by_read[n];
        }

        const_reference at(const size_type n) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(n, m_summary_by_read.size(), "Read index exceeds read count");
            return m_summary_by_read[n];
        }

        size_t size() const
        {
            return m_summary_by_read.size();
        }

        iterator begin()
        {
            return m_summary_by_read.begin();
        }

        iterator end()
        {
            return m_summary_by_read.end();
        }

        const_iterator begin() const
        {
            return m_summary_by_read.begin();
        }

        const_iterator end() const
        {
            return m_summary_by_read.end();
        }

    public:
        size_t lane_count() const
        {
            return m_lane_count;
        }

        void lane_count(const size_t lane_count)
        {
            m_lane_count = lane_count;
        }
        size_t surface_count() const
        {
            return m_surface_count;
        }
        size_t channel_count() const
        {
            return m_channel_count;
        }

        void surface_count(const size_t surface_count)
        {
            m_surface_count = surface_count;
        }

    public:
        const metric_summary &total_summary() const
        {
            return m_total_summary;
        }

        metric_summary &total_summary()
        {
            return m_total_summary;
        }

        void total_summary(const metric_summary &summary)
        {
            m_total_summary = summary;
        }

    public:
        const metric_summary &nonindex_summary() const
        {
            return m_nonindex_summary;
        }

        metric_summary &nonindex_summary()
        {
            return m_nonindex_summary;
        }

        void nonindex_summary(const metric_summary &summary)
        {
            m_nonindex_summary = summary;
        }

    public:
        const cycle_state_summary &cycle_state() const
        {
            return m_cycle_state;
        }

        cycle_state_summary &cycle_state()
        {
            return m_cycle_state;
        }
        void clear()
        {
            m_summary_by_read.clear();
            m_lane_count = 0;
            m_read_count = 0;
            m_surface_count = 0;
            m_channel_count = 0;
            m_total_summary = metric_summary(0);
            m_nonindex_summary = metric_summary(0);
            m_cycle_state = cycle_state_summary();
        }

    private:
        void resize()
        {
            m_summary_by_read.clear();
            m_summary_by_read.resize(m_read_count);
            preallocate_memory();
        }

        friend std::ostream& operator<<(std::ostream& out, const run_summary& summary);
        friend std::istream& operator>>(std::istream& in, run_summary& summary);

    private:
        size_t m_surface_count;
        size_t m_lane_count;
        size_t m_read_count;
        size_t m_channel_count;

    private:
        metric_summary m_total_summary;
        metric_summary m_nonindex_summary;
        cycle_state_summary m_cycle_state;

    private:
        read_summary_vector_t m_summary_by_read;
        template<class MetricType, int Version>
        friend struct io::generic_layout;
    };

}}}}