metric_file_stream.h

Go to the documentation of this file.

#pragma once
#include "interop/util/exception.h"
#include "interop/util/filesystem.h"
#include "interop/io/format/stream_membuf.h"
#include "interop/io/metric_stream.h"
#include "interop/model/metric_base/metric_exceptions.h"

namespace illumina { namespace interop { namespace io
{

    template<class MetricSet>
    size_t compute_buffer_size(const MetricSet& metrics) INTEROP_THROW_SPEC((io::invalid_argument, io::bad_format_exception))
    {
        return size_of_buffer(metrics);
    }
    template<class MetricSet>
    size_t write_interop_to_buffer(const MetricSet& metrics, ::uint8_t* buffer, const size_t buffer_size)
                        INTEROP_THROW_SPEC((io::invalid_argument, io::bad_format_exception, io::incomplete_file_exception, io::format_exception))
    {
        std::ostringstream fout;
        write_metrics(fout, metrics, metrics.version());
        std::string str = fout.str();
        if(buffer_size < str.length())
            INTEROP_THROW(invalid_argument, "Buffer size too small: " << buffer_size << " < " << str.length());
        size_t i=0;
        for(;i<str.length();++i)
            buffer[i] = static_cast< ::uint8_t >(str[i]);
        return i;
    }
    template<class MetricSet>
    void read_interop_from_buffer(::uint8_t* buffer, const size_t buffer_size, MetricSet& metrics)  INTEROP_THROW_SPEC(
                                                                            (interop::io::file_not_found_exception,
                                                                            interop::io::bad_format_exception,
                                                                            interop::io::incomplete_file_exception,
                                                                            model::index_out_of_bounds_exception) )
    {
        detail::membuf sbuf(reinterpret_cast<char*>(buffer), reinterpret_cast<char*>(buffer) + buffer_size);
        std::istream in(&sbuf);
        read_metrics(in, metrics, buffer_size, /*rebuild=*/ false);
    }
    template<class MetricSet>
    void read_interop_from_string(const std::string& buffer, MetricSet& metrics, const bool rebuild=true)  INTEROP_THROW_SPEC(
    (interop::io::bad_format_exception,
    interop::io::incomplete_file_exception,
    model::index_out_of_bounds_exception) )
    {
        std::istringstream in(buffer);
        read_metrics(in, metrics, buffer.length(), rebuild);
    }
    template<class MetricSet>
    void write_interop_to_string(std::string& buffer
            , const MetricSet& metrics, const ::int16_t version = -1)  INTEROP_THROW_SPEC(
            (interop::io::bad_format_exception,
                    interop::io::incomplete_file_exception,
                    model::index_out_of_bounds_exception))
    {
        std::ostringstream out;
        write_metrics(out, metrics, version);
        buffer = out.str();
    }
    template<class MetricSet>
    size_t read_header_from_string(const std::string& buffer, MetricSet& metrics)  INTEROP_THROW_SPEC(
    (interop::io::bad_format_exception,
    interop::io::incomplete_file_exception,
    model::index_out_of_bounds_exception))
    {
        std::istringstream in(buffer);
        return read_header(in, metrics);
    }
    template<class MetricSet>
    void write_header_to_string(std::string& buffer, const MetricSet& metrics, ::int16_t version=-1)  INTEROP_THROW_SPEC(
            (interop::io::bad_format_exception,
                    interop::io::incomplete_file_exception,
                    model::index_out_of_bounds_exception))
    {
        if(version == -1) version = metrics.version();
        std::ostringstream out;
        write_metric_header<typename MetricSet::metric_type>(out, version, metrics);
        buffer = out.str();
    }
    template<class MetricSet>
    void read_interop(const std::string& run_directory, MetricSet& metrics, const bool use_out=true)   INTEROP_THROW_SPEC(
                                                                        (   io::file_not_found_exception,
                                                                            io::bad_format_exception,
                                                                            io::incomplete_file_exception,
                                                                            model::index_out_of_bounds_exception))
    {
#       if __GNUC__ <= 4 && __GNUC_MINOR__ <= 7
            // ---------------------------------------------------------------------------------------------------------
            // No operations to get GCC 4.4.x to compile correctly
            const bool no_op = metrics.offset_map().find(0) != metrics.offset_map().end();
            (void)no_op;
            metrics.resize(metrics.size());
            metrics.trim(metrics.size());
            // ---------------------------------------------------------------------------------------------------------
#       endif

        std::string file_name = interop_filename<MetricSet>(run_directory, use_out);
        std::ifstream fin(file_name.c_str(), std::ios::binary);
        if(!fin.good())
        {
            file_name = interop_filename<MetricSet>(run_directory, !use_out);
            fin.open(file_name.c_str(), std::ios::binary);
        }
        if(!fin.good()) INTEROP_THROW(file_not_found_exception, "File not found: " << file_name);
        read_metrics(fin, metrics, static_cast<size_t>(file_size(file_name)));
    }
    template<class MetricSet>
    bool write_interop(const std::string& run_directory,
                       const MetricSet& metrics,
                       const bool use_out=true,
                       const ::int16_t version=-1)
    INTEROP_THROW_SPEC((io::file_not_found_exception,
    io::bad_format_exception,
    io::incomplete_file_exception))
    {
        if(metrics.empty() || metrics.version() == 0 )return true;
        const std::string file_name = interop_filename<MetricSet>(run_directory, use_out);
        std::ofstream fout(file_name.c_str(), std::ios::binary);
        if(!fout.good())INTEROP_THROW(file_not_found_exception, "File not found: " << file_name);
        write_metrics(fout, metrics, version);
        return fout.good();
    }
    template<class MetricType>
    void write_interop_header(const std::string& run_directory,
                              const ::int16_t version=-1,
                              const typename MetricType::header_type& header = typename MetricType::header_type(),
                              const bool use_out=true)
    INTEROP_THROW_SPEC((io::file_not_found_exception,
    io::bad_format_exception,
    io::incomplete_file_exception))
    {
        const std::string file_name = interop_filename<MetricType>(run_directory, use_out);
        std::ofstream fout(file_name.c_str(), std::ios::binary);
        if(!fout.good())INTEROP_THROW(file_not_found_exception, "File not found: " << file_name);
        write_metric_header(fout, header, version);
    }
    template<class MetricSet>
    bool interop_exists(const std::string& run_directory, MetricSet&, const bool use_out=true)
    INTEROP_THROW_SPEC((io::file_not_found_exception,
    io::bad_format_exception,
    io::incomplete_file_exception,
    model::index_out_of_bounds_exception))
    {
        const std::string file_name = interop_filename<MetricSet>(run_directory, use_out);
        std::ifstream fin(file_name.c_str(), std::ios::binary);
        if(!fin.good()) return false;
        return true;
    }
    template<class MetricSet>
    void list_interop_filenames(std::vector<std::string>& files,
                                const std::string& run_directory,
                                const size_t last_cycle=0,
                                const bool use_out=true,
                                const bool add=false)
    {
        if(!add)
        {
            files.clear();
            files.reserve(last_cycle+1);
        }
        else files.reserve(last_cycle+1+files.size());
        files.push_back(interop_filename<MetricSet>(run_directory, use_out));
        for(size_t cycle=1;cycle <= last_cycle;++cycle)
        {
            files.push_back(interop_filename<MetricSet>(run_directory, cycle, use_out));
        }
    }
    template<class MetricSet>
    void read_interop_by_cycle(const std::string& run_directory,
                               MetricSet& metrics,
                               const size_t last_cycle,
                               const bool use_out=true)
    INTEROP_THROW_SPEC((interop::io::file_not_found_exception,
    interop::io::bad_format_exception,
    interop::io::incomplete_file_exception,
    model::index_out_of_bounds_exception))
    {
        std::string incomplete_file_message;
        for(size_t cycle=1;cycle <= last_cycle;++cycle)
        {
            const std::string file_name = interop_filename<MetricSet>(run_directory, cycle, use_out);
            const int64_t file_size_in_bytes = file_size(file_name);
            if(file_size_in_bytes < 0) continue;
            std::ifstream fin(file_name.c_str(), std::ios::binary);
            if(fin.good())
            {
                try
                {
                    read_metrics(fin, metrics, static_cast<size_t>(file_size_in_bytes), false);
                }
                catch(const incomplete_file_exception& ex)
                {
                    incomplete_file_message = ex.what();
                }
            }
        }
        metrics.rebuild_index();
        if(incomplete_file_message != "")
            throw incomplete_file_exception(incomplete_file_message);
    }
    template<class MetricSet>
    bool interop_exists(const std::string& run_directory, MetricSet&, const size_t last_cycle, const bool use_out=true)
    INTEROP_THROW_SPEC((io::file_not_found_exception,
    io::bad_format_exception,
    io::incomplete_file_exception,
    model::index_out_of_bounds_exception))
    {
        std::string file_name = interop_filename<MetricSet>(run_directory, use_out);
        std::ifstream fin(file_name.c_str(), std::ios::binary);
        if(fin.good()) return true;
        for(size_t cycle=1;cycle <= last_cycle;++cycle)
        {
            file_name = interop_filename<MetricSet>(run_directory, cycle, use_out);
            fin.open(file_name.c_str(), std::ios::binary);
            if(fin.good()) return true;
        }
        return false;
    }
    template<class Metric>
    bool is_deprecated(const int version)
    {
        typedef metric_format_factory<Metric> factory_t;
        typedef typename factory_t::metric_format_map metric_format_map;
        metric_format_map &format_map = factory_t::metric_formats();
        if (format_map.find(version) == format_map.end())
            return false;
        if(format_map[version]->is_deprecated()) return true;
        return false;
    }
    template<class MetricSet>
    bool is_deprecated_set(MetricSet &metrics)
    {
        typedef typename MetricSet::metric_type metric_t;
        return is_deprecated<metric_t>(metrics.version());
    }

}}}