base_read_metric.h

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include "interop/util/type_traits.h"
#include "interop/model/metric_base/base_metric.h"

namespace illumina { namespace interop { namespace model { namespace metric_base
{
    class base_read_metric;

    class base_read_metric_header : public empty_header
    {
    public:
        typedef constants::base_read_t base_t;

    public:
        base_read_metric_header() { }

    public:
        static base_read_metric_header default_header()
        {
            return base_read_metric_header();
        }

    protected:
        void clear(){}
        void update_max_cycle(const base_read_metric &) { }
    };

    class base_read_metric : public base_metric
    {
    public:
        typedef base_read_metric_header header_type;
        typedef constants::base_read_t base_t;
        typedef uint8_t read_t;
    public:
        base_read_metric(const uint_t lane, const uint_t tile, const uint_t read) :
                base_metric(lane, tile), m_read(static_cast<read_t>(read)) { }

    public:
        void set_base(const uint_t lane, const uint_t tile)
        {
            base_metric::set_base(lane, tile);
        }
        void set_base(const uint_t lane, const uint_t tile, const uint_t read)
        {
            base_metric::set_base(lane, tile);
            m_read = static_cast<read_t>(read);
        }
        template<class BaseReadMetric>
        void set_base(const BaseReadMetric &base)
        {
            base_metric::set_base(base);
            m_read = static_cast<read_t>(base.read);
        }

        uint_t read() const { return m_read; }

        id_t id() const
        {
            return create_id(lane(), tile(), m_read);
        }

        static id_t create_id(const id_t lane, const id_t tile, const id_t read)
        {
            return base_metric::create_id(lane, tile) | (read << READ_BIT_SHIFT);
        }
        static id_t read_from_id(const id_t id)
        {
            // 1. Shift off lane and tile bits
            // 2. Shift back, while shifting off reserved bits
            return (id << (LANE_BIT_COUNT+TILE_BIT_COUNT)) >> (LANE_BIT_COUNT+TILE_BIT_COUNT+RESERVED_BIT_COUNT);
        }
        bool operator< (const base_read_metric& metric2) const
        {
            return id() < metric2.id();
        }

    private:
        read_t m_read;
    };

    template<>
    struct metric_attributes<base_read_metric> : public metric_attributes<base_metric>{};


}}}}