base_cycle_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_cycle_metric_header : public empty_header
    {
    public:
        typedef constants::base_cycle_t base_t;
    public:
        base_cycle_metric_header() : m_max_cycle(0)
        { }

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

    public:
        base_metric::uint_t max_cycle() const
        { return m_max_cycle; }
        void clear()
        {
            m_max_cycle=0;
        }

    protected:
        template<class Metric>
        inline void update_max_cycle(const Metric &metric)
        {
            m_max_cycle = std::max(m_max_cycle, metric.cycle());
        }

    private:
        base_metric::uint_t m_max_cycle;
    };
    class base_cycle_metric : public base_metric
    {
    public:
        typedef base_cycle_metric_header header_type;
        typedef constants::base_cycle_t base_t;
        typedef uint16_t cycle_t;
    public:
        base_cycle_metric(const uint_t lane=0, const uint_t tile=0, const uint_t cycle=0) :
                base_metric(lane, tile), m_cycle(static_cast<cycle_t>(cycle))
        { }

    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 cycle)
        {
            base_metric::set_base(lane, tile);
            m_cycle = static_cast<cycle_t>(cycle);
        }
        template<class BaseCycleMetric>
        void set_base(const BaseCycleMetric &base)
        {
            base_metric::set_base(base);
            m_cycle = static_cast<cycle_t>(base.cycle);
        }

        uint_t cycle() const
        { return m_cycle; }

        id_t id() const
        {
            return create_id(lane(), tile(), m_cycle);
        }
        id_t cycle_hash() const
        {
            return create_id(lane(), tile(), m_cycle);
        }
        static id_t cycle_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);
        }
        static id_t reserved_from_id(const id_t id)
        {
            // 1. Shift off lane, tile and cycle bits
            // 2. Shift back
            return (id << (LANE_BIT_COUNT+TILE_BIT_COUNT+CYCLE_BIT_COUNT)) >> (LANE_BIT_COUNT+TILE_BIT_COUNT+CYCLE_BIT_COUNT);
        }

        static id_t create_id(const id_t lane, const id_t tile, const id_t cycle)
        {
            return base_metric::create_id(lane, tile) | (cycle << CYCLE_BIT_SHIFT);
        }

        bool operator< (const base_cycle_metric& metric2) const
        {
            return id() < metric2.id();
        }

    private:
        cycle_t m_cycle;
    };



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

}}}}