base_metric.h

Go to the documentation of this file.

#pragma once

#include <cstddef>
#include "interop/util/static_assert.h"
#include "interop/util/cstdint.h"
#include "interop/constants/typedefs.h"

namespace illumina { namespace interop { namespace io { namespace layout
{
#pragma pack(1)

    struct base_run_metric
    {
        typedef ::uint16_t lane_t;
        typedef ::uint32_t tile_t;
        typedef ::uint8_t record_size_t;
        typedef constants::base_run_t base_t;

        base_run_metric() : m_dummy(0)
        {
        }

        template<class BaseMetric>
        void set(const BaseMetric &/*metric*/)
        {
            m_dummy = 0;
        }

        bool is_valid() const
        {
            return true;
        }

    private:
        lane_t m_dummy;
    };

    template<class T>
    struct base_metric
    {
        typedef ::uint16_t lane_t;
        typedef T tile_t;
        typedef ::uint8_t record_size_t;
        typedef constants::base_tile_t base_t;

        base_metric(const lane_t lane_ = 0, const tile_t tile_ = 0) :
                lane(lane_), tile(tile_)
        {
            static_assert(sizeof(::uint16_t) == 2, "16-bit int not supported");
            static_assert(sizeof(::uint32_t) == 4, "32-bit int not supported");
        }

        template<class BaseMetric>
        void set(const BaseMetric &metric)
        {
            lane = static_cast< lane_t >(metric.lane());
            tile = static_cast< tile_t >(metric.tile());
        }

        bool is_valid() const
        {
            return tile > 0 && lane > 0;
        }

        lane_t lane;
        tile_t tile;
    };

    template<class T>
    struct base_cycle_metric : base_metric<T>
    {
        typedef typename base_metric<T>::lane_t lane_t;
        typedef typename base_metric<T>::tile_t tile_t;
        typedef ::uint16_t cycle_t;
        typedef constants::base_cycle_t base_t;
        base_cycle_metric(const lane_t lane_ = 0, const tile_t tile_ = 0, const cycle_t cycle_ = 0) :
                base_metric<T>(lane_, tile_), cycle(cycle_)
        {
        }

        template<class BaseMetric>
        void set(const BaseMetric &metric)
        {
            base_metric<T>::set(metric);
            cycle = static_cast< cycle_t >(metric.cycle());
        }

        bool is_valid() const
        {
            return base_metric<T>::is_valid() && cycle > 0;
        }

        cycle_t cycle;
    };

    template<class T>
    struct base_read_metric : base_metric<T>
    {
        typedef typename base_metric<T>::lane_t lane_t;
        typedef typename base_metric<T>::tile_t tile_t;
        typedef ::uint16_t read_t;
        typedef constants::base_read_t base_t;
        base_read_metric(const lane_t lane_ = 0, const tile_t tile_ = 0, const read_t read_ = 0) :
                base_metric<T>(lane_, tile_), read(read_)
        {
        }

        template<class BaseMetric>
        void set(const BaseMetric &metric)
        {
            base_metric<T>::set(metric);
            read = static_cast< read_t >(metric.read());
        }

        bool is_valid() const
        {
            return base_metric<T>::is_valid() && read > 0;
        }

        read_t read;
    };

#pragma pack()
}}}}