imaging_table.h

Go to the documentation of this file.

#pragma once
#include <iosfwd>
#include "interop/util/math.h"
#include "interop/model/table/imaging_column.h"


namespace illumina { namespace interop { namespace model { namespace table
{
    class imaging_table
    {
    public:
        typedef std::vector< imaging_column> column_vector_t;
        typedef std::vector< float > data_vector_t;

    private:
        typedef std::vector< size_t > offset_vector_t;

    public:
        imaging_table() : m_row_count(0), m_col_count(0){}

    public:
        void set_data(const size_t rows, column_vector_t& cols, data_vector_t& data)
        {
            if(cols.empty())
            {
                clear();
                return;
            }
            m_columns.swap(cols);
            m_data.swap(data);
            m_row_count = rows;
            m_col_count = m_columns.back().column_count();
            m_enum_to_index.assign(ImagingColumnCount, static_cast<size_t>(ImagingColumnCount));
            for(size_t i=0;i<m_columns.size();++i)
                m_enum_to_index[m_columns[i].id()] = i;
        }
        float operator()(const size_t r, const column_id c, const size_t subcol=0)const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(static_cast<size_t>(c), m_enum_to_index.size(), "Invalid enum id for column (" << constants::to_string(c) << ")");
            const size_t col = m_enum_to_index[static_cast<size_t>(c)];
            INTEROP_BOUNDS_CHECK(col, m_enum_to_index.size(), "Invalid enum id for column - column not filled: " << constants::to_string(c) << ")");
            return operator()(r, col, subcol);
        }
        float operator()(const size_t row, const size_t col, const size_t subcol=0)const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(row, m_row_count, "Row index out of bounds");
            INTEROP_BOUNDS_CHECK(col, m_columns.size(), "Column index out of bounds");
            const size_t col_index = m_columns[col].offset()+subcol;
            INTEROP_BOUNDS_CHECK(col_index, m_col_count, "Column offset index out of bounds");
            const size_t index = row*m_col_count+col_index;
            INTEROP_ASSERT(index < m_data.size());
            return m_data[index];
        }
        const column_vector_t& columns()const
        {
            return m_columns;
        }
        bool empty()const
        {
            return m_data.empty();
        }
        void clear()
        {
            m_data.clear();
            m_columns.clear();
            m_col_count = 0;
            m_row_count = 0;
        }
        const imaging_column& column_at(const size_t col_index)INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(col_index, m_columns.size(), "Column index out of bounds");
            return m_columns[col_index];
        }

    public:
        size_t column_count()const
        {
            return m_columns.size();
        }
        size_t total_column_count()const
        {
            return m_col_count;
        }
        size_t row_count()const
        {
            return m_row_count;
        }

    private:
        friend std::istream& operator>>(std::istream& in, imaging_table& table);
        friend std::ostream& operator<<(std::ostream& out, const imaging_table& table);
    private:
        data_vector_t m_data;
        column_vector_t m_columns;
        offset_vector_t m_enum_to_index;
        size_t m_row_count;
        size_t m_col_count;
    };
    struct imaging_table_id_less
    {
        imaging_table_id_less(const imaging_table& table) : m_table(table){}

        bool operator()(const size_t lhs_row, const size_t rhs_row)const
        {
            const size_t lhs_lane = static_cast<size_t>(m_table(lhs_row, LaneColumn));
            const size_t rhs_lane = static_cast<size_t>(m_table(rhs_row, LaneColumn));
            if(lhs_lane == rhs_lane)
            {
                const size_t lhs_tile = static_cast<size_t>(m_table(lhs_row, TileColumn));
                const size_t rhs_tile = static_cast<size_t>(m_table(rhs_row, TileColumn));
                if(lhs_tile == rhs_tile)
                {
                    const size_t lhs_cycle = static_cast<size_t>(m_table(lhs_row, CycleColumn));
                    const size_t rhs_cycle = static_cast<size_t>(m_table(rhs_row, CycleColumn));
                    return lhs_cycle < rhs_cycle;
                }
                return lhs_tile < rhs_tile;
            }
            return lhs_lane < rhs_lane;
        }

    private:
        const imaging_table& m_table;
    };

}}}}