index_lane_summary.h

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include "interop/util/cstdint.h"
#include "interop/util/exception.h"
#include "interop/io/format/generic_layout.h"
#include "interop/model/summary/index_count_summary.h"

namespace illumina { namespace interop { namespace model { namespace summary {

    class index_lane_summary
    {
    public:
        typedef std::vector<index_count_summary> count_summary_vector_t;
    public:
        typedef count_summary_vector_t::reference reference;
        typedef count_summary_vector_t::const_reference const_reference;
        typedef count_summary_vector_t::iterator iterator;
        typedef count_summary_vector_t::const_iterator const_iterator;
        typedef count_summary_vector_t::size_type size_type;
        typedef ::uint64_t read_count_t;

    public:
        index_lane_summary(const read_count_t total_reads=0,
                           const read_count_t total_pf_reads=0,
                           const float total_fraction_mapped_reads=0,
                           const float mapped_reads_cv=0,
                           const float min_mapped_reads=0,
                           const float max_mapped_reads=0) : m_total_reads(total_reads),
                                                             m_total_pf_reads(total_pf_reads),
                                                             m_total_fraction_mapped_reads(total_fraction_mapped_reads),
                                                             m_mapped_reads_cv(mapped_reads_cv),
                                                             m_min_mapped_reads(min_mapped_reads),
                                                             m_max_mapped_reads(max_mapped_reads)
        {
        }

    public:
        void resize(const size_type n)
        {
            m_count_summaries.resize(n);
        }
        void reserve(const size_type n)
        {
            m_count_summaries.reserve(n);
        }
        void push_back(const index_count_summary& count_summary)
        {
            m_count_summaries.push_back(count_summary);
        }
        size_type size()const
        {
            return m_count_summaries.size();
        }
        iterator begin()
        {
            return m_count_summaries.begin();
        }
        iterator end()
        {
            return m_count_summaries.end();
        }
        const_iterator begin()const
        {
            return m_count_summaries.begin();
        }
        const_iterator end()const
        {
            return m_count_summaries.end();
        }

    public:
        index_count_summary& operator[](const size_type n) INTEROP_THROW_SPEC(( model::index_out_of_bounds_exception ))
        {
            INTEROP_BOUNDS_CHECK(n, m_count_summaries.size(), "Index sequence index exceeds index sequence count");
            return m_count_summaries[n];
        }
        const index_count_summary& operator[](const size_t n)const INTEROP_THROW_SPEC(( model::index_out_of_bounds_exception ))
        {
            INTEROP_BOUNDS_CHECK(n, m_count_summaries.size(), "Index sequence index exceeds index sequence count");
            return m_count_summaries[n];
        }
        index_count_summary& at(const size_t n) INTEROP_THROW_SPEC(( model::index_out_of_bounds_exception ))
        {
            INTEROP_BOUNDS_CHECK(n, m_count_summaries.size(), "Index sequence index exceeds index sequence count");
            return m_count_summaries[n];
        }
        const_reference at(const size_type n)const INTEROP_THROW_SPEC(( model::index_out_of_bounds_exception ))
        {
            INTEROP_BOUNDS_CHECK(n, m_count_summaries.size(), "Index sequence index exceeds index sequence count");
            return m_count_summaries[n];
        }
        read_count_t total_reads()const
        {
            return m_total_reads;
        }
        read_count_t total_pf_reads()const
        {
            return m_total_pf_reads;
        }
        float total_fraction_mapped_reads()const
        {
            return m_total_fraction_mapped_reads;
        }
        float mapped_reads_cv()const
        {
            return m_mapped_reads_cv;
        }
        float min_mapped_reads()const
        {
            return m_min_mapped_reads;
        }
        float max_mapped_reads()const
        {
            return m_max_mapped_reads;
        }
    public:

        void sort()
        {
            std::stable_sort(begin(), end());
        }
        void set(const ::uint64_t total_mapped_reads,
                 const read_count_t pf_cluster_count_total,
                 const read_count_t cluster_count_total,
                 const float min_fraction_mapped,
                 const float max_fraction_mapped,
                 const float cv_fraction_mapped)
        {
            m_total_reads = cluster_count_total;
            m_total_pf_reads = pf_cluster_count_total;
            m_total_fraction_mapped_reads = (pf_cluster_count_total == 0) ? 0 :
                                            roundf(static_cast<float>(100.0*total_mapped_reads/pf_cluster_count_total)*10000)/10000;
            m_mapped_reads_cv = roundf(cv_fraction_mapped*10000)/10000;
            m_min_mapped_reads = (m_total_reads==0) ? 0 : roundf(min_fraction_mapped*10000)/10000;
            m_max_mapped_reads = (m_total_reads==0) ? 0 : roundf(max_fraction_mapped*10000)/10000;
        }
        void clear()
        {
            m_count_summaries.clear();
            m_total_reads = 0;
            m_total_pf_reads = 0;
            m_total_fraction_mapped_reads = 0;
            m_mapped_reads_cv = 0;
            m_min_mapped_reads = 0;
            m_max_mapped_reads = 0;
        }

    private:
        count_summary_vector_t m_count_summaries;

    private:
        read_count_t m_total_reads;
        read_count_t m_total_pf_reads;
        float m_total_fraction_mapped_reads;
        float m_mapped_reads_cv;
        float m_min_mapped_reads;
        float m_max_mapped_reads;

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

}}}}