stream_util.h

Go to the documentation of this file.

#pragma once

#include <istream>
#include <cstddef>
#include <vector>
#include <cstring>
#include "interop/util/exception.h"
#include "interop/io/stream_exceptions.h"
#include "interop/util/lexical_cast.h"
#include "interop/util/cstdint.h"
#include "interop/io/format/stream_membuf.h"

namespace illumina { namespace interop { namespace io
{

    template<class T>
    void read_binary(std::istream &in, T *buffer, const size_t n)
    {
        in.read(reinterpret_cast<char *>(buffer), n * sizeof(T));
    }

    template<class T>
    void read_binary(std::istream &in, T &buffer)
    {
        read_binary(in, &buffer, 1);
    }
    template<class T>
    void read_binary(char*& in, T *buffer, const size_t n)
    {
        std::memcpy(reinterpret_cast<char *>(buffer), in, n * sizeof(T));
        in+=n * sizeof(T);
    }
    template<class T>
    void read_binary(char*& in, T &buffer)
    {
        read_binary(in, &buffer, 1);
    }

    template<class T>
    std::streamsize read_binary_with_count(std::istream &in, T &buffer)
    {
        read_binary(in, &buffer, 1);
        return in.gcount();
    }

    template<class T>
    std::streamsize read_binary_with_count(char*& in, T &buffer)
    {
        read_binary(in, &buffer, 1);
        return static_cast<std::streamsize >(sizeof(T));
    }

    template<class T>
    T read_binary(std::istream &in)
    {
        T val;
        read_binary(in, &val, 1);
        return val;
    }

    template<class T>
    void read_binary(std::istream &in, std::vector<T> &buffer, const size_t n)
    {
        INTEROP_ASSERT(!buffer.empty());
        read_binary(in, &buffer.front(), n);
    }

    template<class T>
    void read_binary(std::istream &in, std::vector<T> &buffer)
    {
        INTEROP_ASSERT(!buffer.empty());
        read_binary(in, &buffer.front(), buffer.size());
    }

    inline void read_binary(std::istream &in, std::string &str, const std::string& default_val)
    {
        const size_t length = read_binary< ::uint16_t >(in);
        if (in.fail()) INTEROP_THROW(incomplete_file_exception, "Unexpected end of file");
        if (length > 0)
        {
            str.assign(length, ' ');
            read_binary(in, const_cast<char *>(str.c_str()), length);
        }
        else str = default_val;
    }

    template<class T>
    void write_binary(std::ostream &out, const T *buffer, const size_t n)
    {
        out.write(reinterpret_cast<const char *>(buffer), n * sizeof(T));
    }

    template<class T>
    void write_binary(std::ostream &out, const T &buffer)
    {
        write_binary(out, &buffer, 1);
    }

    template<class T>
    void write_binary(std::ostream &out, const std::vector<T> &buffer, const size_t n)
    {
        if(buffer.empty())return;
        write_binary(out, &buffer.front(), n);
    }

    template<class T>
    void write_binary(std::ostream &out, const std::vector<T> &buffer)
    {
        write_binary(out, buffer, buffer.size());
    }

    inline void write_binary(std::ostream &out, const std::string &str)
    {
        const ::uint16_t len = static_cast< ::uint16_t >(str.size());
        write_binary(out, len);
        if (len > 0) write_binary(out, const_cast<char *>(str.c_str()), len);
    }

    inline std::streamsize scount(std::istream &in)
    {
        return in.gcount();
    }

    inline std::streamsize scount(std::ostream &out)
    {
        return out.tellp();
    }

}}}