map_io.h

Go to the documentation of this file.

#pragma once

#include "interop/io/format/stream_util.h"
#include "interop/util/length_of.h"

namespace illumina { namespace interop { namespace io
{

    template<typename Source, typename Destination>
    void copy_from(std::ostream &, const Source &, const Destination &)
    { }

    template<typename Source, typename Destination>
    void copy_from(std::istream &, Destination &dst, const Source &src)
    {
        dst = src;
    }
    template<typename Source, typename Destination>
    void copy_from(const char*, Destination &dst, const Source &src) // TODO: Simplify this entire file with templates
    {
        dst = src;
    }

    template<typename ReadType, typename ValueType>
    std::streamsize stream_map(std::istream &in, ValueType &val)
    {
        ReadType read_val;
        read_binary(in, read_val);
        val = static_cast<ValueType>(read_val);
        return in.gcount();
    }
    template<typename ReadType, typename ValueType>
    std::streamsize stream_map(char*& in, ValueType &val)
    {
        ReadType read_val;
        read_binary(in, read_val);
        val = static_cast<ValueType>(read_val);
        return sizeof(ReadType);
    }

    inline std::streamsize stream_map(std::istream &in, std::string &val)
    {
        read_binary(in, val, "");
        return in.gcount();
    }
    inline std::streamsize stream_map(char*& in, std::string &val)
    {
        read_binary(in, val);
        return val.size();
    }

    template<typename ReadType, typename ValueType, bool SameSize=sizeof(ReadType)==sizeof(ValueType)>
    struct read_array_helper
    {
        static std::streamsize read_array_from_stream(std::istream &in, ValueType* vals, const size_t n, const size_t offset=0)
        {
            std::streamsize tot = 0;
            for (size_t i = 0; i < n; i++)
            {
                ReadType read_val;
                read_binary(in, read_val);
                vals[offset + i] = read_val;
                tot += in.gcount();
            }
            return tot;
        }
        static std::streamsize read_array_from_stream(char* &in, ValueType* vals, const size_t n, const size_t offset=0)
        {
            for (size_t i = 0; i < n; i++)
            {
                ReadType read_val;
                read_binary(in, read_val);
                vals[offset + i] = read_val;
            }
            return n*sizeof(ReadType);
        }
    };
    template<typename ReadType, typename ValueType>
    struct read_array_helper<ReadType, ValueType, true>
    {
        static std::streamsize read_array_from_stream(std::istream &in, ValueType* vals, const size_t n, const size_t offset=0)
        {
            read_binary(in, vals+offset, n);
            return in.gcount();
        }
        static std::streamsize read_array_from_stream(char* &in, ValueType* vals, const size_t n, const size_t offset=0)
        {
            read_binary(in, vals+offset, n);
            return n*sizeof(ReadType);
        }
    };

    template<typename ReadType, typename ValueType>
    std::streamsize stream_map(std::istream &in, std::vector<ValueType>&vals, const size_t n)
    {
        vals.resize(n);
        INTEROP_ASSERTMSG(!vals.empty(), "n="<<n);
        return read_array_helper<ReadType,ValueType>::read_array_from_stream(in, &vals.front(), n);
    }


    template<typename ReadType, typename ValueType>
    std::streamsize stream_map(char*& in, std::vector<ValueType>&vals, const size_t n)
    {
        vals.resize(n);
        INTEROP_ASSERT(!vals.empty());
        return read_array_helper<ReadType,ValueType>::read_array_from_stream(in, &vals.front(), n);
    }

    template<typename ReadType, typename ValueType>
    std::streamsize padded_stream_map(std::istream &in, std::vector<ValueType>&vals, const size_t n, const ReadType)
    {
        vals.resize(n);
        INTEROP_ASSERTMSG(!vals.empty(), "n="<<n);
        return read_array_helper<ReadType,ValueType>::read_array_from_stream(in, &vals.front(), n);
    }


    template<typename ReadType, typename ValueType>
    std::streamsize padded_stream_map(char*& in, std::vector<ValueType>&vals, const size_t n, const ReadType)
    {
        vals.resize(n);
        INTEROP_ASSERT(!vals.empty());
        return read_array_helper<ReadType,ValueType>::read_array_from_stream(in, &vals.front(), n);
    }



    template<typename ReadType, typename ValueType>
    std::streamsize stream_map(std::istream &in, std::vector<ValueType> &vals, const size_t offset, const size_t n)
    {
        vals.resize(offset + n);
        INTEROP_ASSERT(!vals.empty());
        return read_array_helper<ReadType,ValueType>::read_array_from_stream(in, &vals.front(), n, offset);
    }

    template<typename ReadType, typename ValueType>
    std::streamsize stream_map(char*& in, std::vector<ValueType> &vals, const size_t offset, const size_t n)
    {
        vals.resize(offset + n);
        INTEROP_ASSERT(!vals.empty());
        return read_array_helper<ReadType,ValueType>::read_array_from_stream(in, &vals.front(), n, offset);
    }

    template<typename ReadType, typename ValueType, size_t N>
    std::streamsize stream_map(std::istream &in, ValueType (&vals)[N], const size_t n)
    {
        return read_array_helper<ReadType,ValueType>::read_array_from_stream(in, vals, n);
    }

    template<typename ReadType, typename ValueType, size_t N>
    std::streamsize stream_map(char* &in, ValueType (&vals)[N], const size_t n)
    {
        return read_array_helper<ReadType,ValueType>::read_array_from_stream(in, vals, n);
    }

    template<typename WriteType, typename ValueType>
    std::streamsize stream_map(std::ostream &out, const ValueType val)
    {
        write_binary(out, static_cast<WriteType>(val));
        return out.tellp();
    }

    inline std::streamsize stream_map(std::ostream &out, const std::string &str)
    {
        write_binary(out, str);
        return out.tellp();
    }

    template<typename WriteType, typename ValueType>
    std::streamsize stream_map(std::ostream &out, const ValueType &vals, const size_t n)
    {
        INTEROP_ASSERT(util::length_of(vals) >= n);
        INTEROP_RANGE_CHECK_GT(n, util::length_of(vals), bad_format_exception,
                               "Write bug: expected values is greater than array size");
        for (size_t i = 0; i < n; i++)
        {
            WriteType write_val = static_cast<WriteType>(vals[i]);
            write_binary(out, write_val);
        }
        return out.tellp();
    }

    template<typename WriteType, typename ValueType>
    std::streamsize padded_stream_map(std::ostream &out, const ValueType &vals, const size_t n, const WriteType pad)
    {
        for (size_t i = 0; i < util::length_of(vals); i++)
        {
            WriteType write_val = static_cast<WriteType>(vals[i]);
            write_binary(out, write_val);
        }
        for (size_t i = util::length_of(vals); i < n; i++)
        {
            write_binary(out, pad);
        }
        return out.tellp();
    }

    template<typename WriteType, typename ValueType>
    std::streamsize stream_map(std::ostream &out, const ValueType &vals, const size_t offset, const size_t n)
    {
        INTEROP_ASSERT(util::length_of(vals) >= (offset+n));
        INTEROP_RANGE_CHECK_GT(offset+n, util::length_of(vals), bad_format_exception,
                               "Write bug: expected values is greater than array size");
        for (size_t i = 0; i < n; i++)
        {
            WriteType write_val = static_cast<WriteType>(vals[offset + i]);
            write_binary(out, write_val);
        }
        return out.tellp();
    }

    template<typename Layout>
    void map_resize(const Layout &, size_t)
    {
    }

    template<typename Layout>
    void map_resize(Layout &layout, const size_t n)
    {
        layout.resize(n);
    }

}}}