transpose.hpp

#ifndef SHORE_STREAMS_TRANSPOSE_HPP__
#define SHORE_STREAMS_TRANSPOSE_HPP__

#include <algorithm>
#include <vector>
#include <stdexcept>

#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/traits.hpp>

#include "shore/stream/streams.hpp"
#include "shore/stream/stream_slicer.hpp"
#include "shore/base/memops.hpp"

namespace shore {

class block_transposition
{
 public:

        typedef shore::stream_slicer::slice slice;

 private:

        std::ostream *m_os;
        std::vector<const char *> m_lines;
        slice m_slice;

        char *m_buf;
        size_t m_bufsize;


        block_transposition(const block_transposition &other);
        block_transposition &operator=(const block_transposition &other);

 public:

        block_transposition();
        ~block_transposition();

        void transpose(const slice &s,const bool change_first_line);

        const slice &current() const;
};

class output_transposer
{
 private:

        std::ostream *m_os;
        size_t m_blocksize;
        block_transposition m_blktr;
        block_transposition::slice m_slice;
        char *m_buf;


        output_transposer(const output_transposer &other);
        output_transposer &operator=(const output_transposer &other);

 public:

        output_transposer(std::ostream &os,const size_t bs);
        ~output_transposer();

        std::streamsize write(const char* s,std::streamsize n);
        void close();
};

class transposing_sink
:public boost::iostreams::sink
{
 private:

        output_transposer *m_otr;

 public:

        transposing_sink(output_transposer *const otr);

        std::streamsize write(const char* s,std::streamsize n);
        void close();
};

class transposing_ostream
:public boost::iostreams::stream<transposing_sink>
{
 private:

        output_transposer m_otr;

 public:

        transposing_ostream(std::ostream *os,const size_t bs);
        ~transposing_ostream();
};

class input_backtransposer
{
 private:

        std::istream *m_in;
        int64_t m_streamsize;
        bool m_is_transposed;
        size_t m_headsize;

        size_t m_blocksize;
        block_transposition m_blktr;
        shore::stream_slicer *m_slicer;
        size_t m_sliceoff;

        char *m_buf;
        size_t m_bufoff;
        size_t m_bufsize;

        shore::stream_slicer::slice m_slice;


        input_backtransposer(const input_backtransposer &other);
        input_backtransposer &operator=(const input_backtransposer &other);

 public:

        input_backtransposer(std::istream &in,int64_t stream_size=-1);
        ~input_backtransposer();

        std::streamsize read(char* s,std::streamsize n);

        std::streampos seek(boost::iostreams::stream_offset off,
                            std::ios_base::seekdir way);

        int64_t stream_size() const;
};

class backtransposing_source
:public boost::iostreams::device<boost::iostreams::input_seekable>
{
 private:

        input_backtransposer *m_ibt;

 public:

        backtransposing_source(input_backtransposer *const ibt);

        std::streamsize read(char* s,std::streamsize n);

        std::streampos seek(boost::iostreams::stream_offset off,
                            std::ios_base::seekdir way);
};

class backtransposing_istream
:public boost::iostreams::stream<backtransposing_source>
{
 private:

        input_backtransposer m_ibt;

 public:

        backtransposing_istream(std::istream* is,const int64_t streamsize=-1);
        ~backtransposing_istream();

        int64_t stream_size() const;
};

} // namespace shore

#endif // SHORE_STREAMS_TRANSPOSE_HPP__