flowcell_layout.h

Go to the documentation of this file.

#pragma once

#include <string>
#include <vector>
#include "interop/constants/enums.h"

namespace illumina { namespace interop { namespace model { namespace run
{

    class flowcell_layout
    {
    public:
        typedef constants::tile_naming_method tile_naming_method_t;
        typedef std::vector<std::string> str_vector_t;
        typedef ::uint32_t uint_t;

    public:
        flowcell_layout(const uint_t lane_count = 1,
                        const uint_t surface_count = 1,
                        const uint_t swath_count = 1,
                        const uint_t tile_count = 1,
                        const uint_t sections_per_lane = 1,
                        const uint_t lanes_per_section = 1,
                        const str_vector_t &tiles = str_vector_t(),
                        const tile_naming_method_t naming_method = constants::UnknownTileNamingMethod,
                        const std::string &barcode = "") :
                m_naming_method(naming_method), m_lane_count(lane_count), m_surface_count(surface_count)
                , m_swath_count(swath_count), m_tile_count(tile_count), m_sections_per_lane(sections_per_lane)
                , m_lanes_per_section(lanes_per_section), m_tiles(tiles), m_barcode(barcode)
        {
            for(uint_t surface_index = 1; surface_index <= m_surface_count; ++surface_index)
            {
                m_surface_list.push_back(surface_index);
            }
        }

    public:
        uint_t lane_count() const
        { return m_lane_count; }

        uint_t surface_count() const
        { return m_surface_count; }

        bool supports_multisurface() const
        {
            return m_surface_list.size() > 1;
        }

        const std::vector<uint_t> &surface_list() const
        {
            return m_surface_list;
        }

        uint_t swath_count() const
        { return m_swath_count; }

        uint_t tile_count() const
        { return m_tile_count; }

        uint_t sections_per_lane() const
        { return m_sections_per_lane; }

        uint_t lanes_per_section() const
        { return m_lanes_per_section; }

        uint_t total_number_of_sections() const
        {
            if(m_naming_method == constants::FiveDigit)
                return m_lane_count/m_lanes_per_section * m_sections_per_lane;
            return 0;
        }

        tile_naming_method_t naming_method() const
        { return m_naming_method; }

        const str_vector_t &tiles() const
        { return m_tiles; }

        const std::string &barcode() const
        { return m_barcode; }
        size_t total_swaths(const bool all_surfaces) const
        {
            if (all_surfaces) return swath_count() * 2;
            return swath_count();
        }

        size_t tiles_per_lane() const
        {
            return tile_count() * sections_per_lane();
        }

        size_t total_tiles()const
        {
            return tiles_per_lane()*swath_count()*surface_count()*lane_count();
        }

        void set_naming_method(const constants::tile_naming_method naming_method)
        {
            m_naming_method = naming_method;
        }
        void lane_count(const uint_t lane_count)
        { m_lane_count = lane_count; }
        void surface_count(const uint_t surface_count)
        { m_surface_count = surface_count; }

        void swath_count(const uint_t swath_count)
        { m_swath_count = swath_count; }
        void tile_count(const uint_t tile_count)
        { m_tile_count = tile_count; }
        void sections_per_lane(const uint_t count)
        { m_sections_per_lane = count; }
        void lanes_per_section(const uint_t count)
        { m_lanes_per_section = count; }

    private:
        tile_naming_method_t m_naming_method;
        uint_t m_lane_count;
        uint_t m_surface_count;
        uint_t m_swath_count;
        uint_t m_tile_count;
        uint_t m_sections_per_lane;
        uint_t m_lanes_per_section;
        str_vector_t m_tiles;
        std::string m_barcode;
        std::vector<uint_t> m_surface_list;

        friend class info;
    };
}}}}