info.h

Go to the documentation of this file.

#pragma once

#include <string>
#include <vector>
#include "interop/util/exception.h"
#include "interop/util/lexical_cast.h"
#include "interop/model/run/flowcell_layout.h"
#include "interop/model/run/image_dimensions.h"
#include "interop/model/run/read_info.h"
#include "interop/util/xml_exceptions.h"
#include "interop/model/run/run_exceptions.h"

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4290) // MSVC warns that it ignores the exception specification.
#endif

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

    class info
    {
    public:
        typedef ::uint32_t uint_t;
        typedef std::vector<std::string> str_vector_t;
        typedef std::vector<read_info> read_vector_t;
        typedef read_vector_t::const_iterator const_read_iterator;
    public:
        info(const std::string &name = "",
             const std::string &date = "",
             const std::string instrument_name="",
             const size_t run_number=0,
             const uint_t version = 0,
             const flowcell_layout &flowcell = flowcell_layout(),
             const str_vector_t &channels = str_vector_t(),
             const image_dimensions &image_dim = image_dimensions(),
             const read_vector_t &reads = read_vector_t()) :
                m_name(name),
                m_date(date),
                m_instrument_name(instrument_name),
                m_run_number(run_number),
                m_version(version),
                m_flowcell(flowcell),
                m_channels(channels),
                m_image_dim(image_dim),
                m_reads(reads),
                m_total_cycle_count(0)
        {
            m_total_cycle_count = total_cycles();
        }

        info(const flowcell_layout &flowcell,
             const read_vector_t &reads=read_vector_t(),
             const str_vector_t &channels=str_vector_t()) :
                m_name(""),
                m_date(""),
                m_instrument_name(""),
                m_run_number(0),
                m_version(3),
                m_flowcell(flowcell),
                m_channels(channels),
                m_image_dim(image_dimensions()),
                m_reads(reads),
                m_total_cycle_count(0)
        {
            m_total_cycle_count = total_cycles();
        }

    public:
        void read(const std::string &run_folder) INTEROP_THROW_SPEC((xml::xml_file_not_found_exception,
        xml::bad_xml_format_exception,
        xml::empty_xml_format_exception,
        xml::missing_xml_element_exception,
        xml::xml_parse_exception,
        xml::xml_format_exception,
        util::base_exception));

        void validate()const INTEROP_THROW_SPEC((model::invalid_run_info_exception,model::invalid_tile_naming_method));
        void validate_tiles()const INTEROP_THROW_SPEC((model::invalid_tile_list_exception));
        void validate(const ::uint32_t lane, const ::uint32_t tile, const std::string& metric_name)const
        INTEROP_THROW_SPEC((model::invalid_run_info_exception));
        void validate_cycle(const ::uint32_t lane, const ::uint32_t tile, const size_t cycle, const std::string& metric_name)const
        INTEROP_THROW_SPEC((model::invalid_run_info_exception,
              model::invalid_run_info_cycle_exception));
        void validate_read(const ::uint32_t lane, const ::uint32_t tile, const size_t read, const std::string& metric_name)const
        INTEROP_THROW_SPEC((model::invalid_run_info_exception));

    public:
        const std::string &instrument_name() const
        { return m_instrument_name; }
        const std::string &flowcell_id() const
        { return m_flowcell.barcode(); }
        size_t run_number() const
        { return m_run_number; }

        const std::string &name() const
        { return m_name; }

        const std::string &date() const
        { return m_date; }

        uint_t version() const
        { return m_version; }

        const flowcell_layout &flowcell() const
        { return m_flowcell; }

        const str_vector_t &channels() const
        { return m_channels; }

        const image_dimensions &dimensions_of_image() const
        { return m_image_dim; }

        const read_vector_t &reads() const
        { return m_reads; }

        bool is_indexed() const
        {
            for (read_vector_t::const_iterator b = m_reads.begin(); b != m_reads.end(); ++b)
                if (b->is_index()) return true;
            return false;
        }
        bool is_paired_end()const
        {
            size_t non_index_read_count = 0;

            for (read_vector_t::const_iterator b = m_reads.begin(), e = m_reads.end(); b != e; ++b)
            {
                if (b->is_index()) continue;
                ++non_index_read_count;
            }
            return non_index_read_count > 1;
        }
        bool is_last_cycle_of_read(const size_t cycle)const
        {
            for (read_vector_t::const_iterator b = m_reads.begin(), e = m_reads.end(); b != e; ++b)
                if (b->last_cycle() == cycle) return true;
            return false;
        }
        size_t cycle_within_read(const size_t cycle)const
        {
            for (read_vector_t::const_iterator b = m_reads.begin(), e = m_reads.end(); b != e; ++b)
                if ( cycle <= b->last_cycle()) return cycle-b->first_cycle() + 1;
            return 0;
        }

        const read_info &read(const size_t read_number) const INTEROP_THROW_SPEC((model::invalid_read_exception))
        {
            for (read_vector_t::const_iterator b = m_reads.begin(), e = m_reads.end(); b != e; ++b)
                if (b->number() == read_number) return *b;
            INTEROP_THROW(invalid_read_exception, "Read number not found: " << read_number);
        }

        void channels(const str_vector_t &channels)
        { m_channels = channels; }

        void reads(const read_vector_t& read_vec)
        {
            m_reads = read_vec;
            m_total_cycle_count = total_cycles();
        }

        void set_naming_method(const constants::tile_naming_method naming_method)
        {
            m_flowcell.set_naming_method(naming_method);
        }
        void flowcell(const flowcell_layout & flowcell)
        { m_flowcell = flowcell; }

        size_t total_cycles() const
        {
            size_t total = 0;
            for (read_vector_t::const_iterator b = m_reads.begin(), e = m_reads.end(); b != e; ++b)
                total += b->total_cycles();
            return total;
        }

        size_t useable_cycles() const
        {
            size_t total = 0;
            for (read_vector_t::const_iterator b = m_reads.begin(), e = m_reads.end(); b != e; ++b)
                total += b->useable_cycles();
            return total;
        }
    public:
        void read_file(const std::string &filename) INTEROP_THROW_SPEC((xml::xml_file_not_found_exception,
        xml::bad_xml_format_exception,
        xml::empty_xml_format_exception,
        xml::missing_xml_element_exception,
        xml::xml_parse_exception));

        void parse(char *data) INTEROP_THROW_SPEC((xml::xml_file_not_found_exception,
        xml::bad_xml_format_exception,
        xml::empty_xml_format_exception,
        xml::missing_xml_element_exception,
        xml::xml_parse_exception));

        void write(const std::string &filename)const INTEROP_THROW_SPEC((xml::xml_file_not_found_exception,
                                                                         xml::bad_xml_format_exception));

        void write(std::ostream& out)const INTEROP_THROW_SPEC((xml::bad_xml_format_exception));

    private:
        bool is_bool_attribute_valid(const char c) const;

    private:
        std::string m_name;
        std::string m_date;
        std::string m_instrument_name;
        size_t m_run_number;
        uint_t m_version;
        flowcell_layout m_flowcell;
        str_vector_t m_channels;
        image_dimensions m_image_dim;
        read_vector_t m_reads;
        size_t m_total_cycle_count;
    };

}}}}

#ifdef _MSC_VER
#pragma warning(pop)
#endif