io_filter.h

Go to the documentation of this file.

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef MOD_SERVLET_IO_FILTER_H
#define MOD_SERVLET_IO_FILTER_H

#include <servlet/lib/io.h>

namespace servlet
{

template <typename CharT>
struct basic_sink
{
    virtual ~basic_sink() noexcept = default;
    virtual std::streamsize write(CharT* s, std::streamsize n) = 0;
    virtual void flush() {}
};
template <typename CharT>
struct basic_source
{
    virtual ~basic_source() noexcept = default;
    virtual std::streamsize read(CharT* s, std::streamsize n) = 0;
};
template <typename CharT>
struct basic_out_filter
{
    virtual ~basic_out_filter() noexcept = default;
    virtual std::streamsize write(CharT* s, std::streamsize n, basic_sink<CharT>& dst) = 0;
};
template <typename CharT>
struct basic_in_filter
{
    virtual ~basic_in_filter() noexcept = default;
    virtual std::streamsize read(CharT* s, std::streamsize n, basic_source<CharT>& src) = 0;
};

using in_filter = basic_in_filter<char>;
using out_filter = basic_out_filter<char>;

template<typename CharT>
class out_filter_adapter : public basic_sink<CharT>
{
public:
    out_filter_adapter(basic_sink<CharT>& dst, basic_out_filter<CharT>* filter, bool filter_owner) :
            _sink{dst}, _filter{filter}, _filter_owner{filter_owner} {}
    ~out_filter_adapter() noexcept override { if (_filter_owner) delete _filter; }

    std::streamsize write(CharT* s, std::streamsize n) override { return _filter->write(s, n, _sink); }
private:
    basic_sink<CharT>& _sink;
    basic_out_filter<CharT>* _filter;
    bool _filter_owner;
};

template <typename CharT>
class basic_filtered_sink : public basic_sink<CharT>
{
public:
    explicit basic_filtered_sink(basic_sink<CharT>* sink) : _sink{sink} { _front_sink = _sink; }
    ~basic_filtered_sink() noexcept override { delete _sink; }

    std::streamsize write(CharT* s, std::streamsize n) override { return _front_sink->write(s, n); }
    void flush() override { _sink->flush(); }

    void add_filter(basic_out_filter<CharT>* filter, bool delete_after_use = true)
    {
        if (_filters.empty()) _filters.emplace_back(*_sink, filter, delete_after_use);
        else _filters.emplace_back(_filters.back(), filter, delete_after_use);
        _front_sink = &_filters.back();
    }
private:
    basic_sink<CharT>* _sink;
    std::vector<out_filter_adapter<CharT>> _filters;
    basic_sink<CharT>* _front_sink;
};

template<typename CharT>
class in_filter_adapter : public basic_source<CharT>
{
public:
    in_filter_adapter(basic_source<CharT>& src, basic_in_filter<CharT>* filter, bool filter_owner) :
            _source{src}, _filter{filter}, _filter_owner{filter_owner} {}
    ~in_filter_adapter() noexcept override { if (_filter_owner) delete _filter; }

    std::streamsize read(CharT* s, std::streamsize n) override { return _filter->read(s, n, _source); }
private:
    basic_source<CharT>& _source;
    basic_in_filter<CharT>* _filter;
    bool _filter_owner;
};

template <typename CharT>
class basic_filtered_source : public basic_source<CharT>
{
public:
    explicit basic_filtered_source(basic_source<CharT>* src) : _source{src} { _front_source = _source; }
    ~basic_filtered_source() noexcept override { delete _source; }

    std::streamsize read(CharT* s, std::streamsize n) override { return _front_source->read(s, n); }

    void add_filter(basic_in_filter<CharT>* filter, bool delete_after_use = true)
    {
        if (_filters.empty()) _filters.emplace_back(*_source, filter, delete_after_use);
        else _filters.emplace_back(_filters.back(), filter, delete_after_use);
        _front_source = &_filters.back();
    }
private:
    basic_source<CharT>* _source;
    std::vector<in_filter_adapter<CharT>> _filters;
    basic_source<CharT>* _front_source;
};

template <typename CharT>
class basic_stream_sink : public basic_sink<CharT>
{
public:
    basic_stream_sink(std::basic_ostream<CharT>& out) : _out{out} {}
    std::streamsize write(CharT* s, std::streamsize n) override
    {
        _out.write(s, n);
        return _out ? n : 0;
    }
private:
    std::basic_ostream<CharT>& _out;
};

template <typename CharT>
class basic_stream_source : public basic_source<CharT>
{
public:
    basic_stream_source(std::basic_istream<CharT>& in) : _in{in} {}
    std::streamsize read(CharT* s, std::streamsize n) override
    {
        _in.read(s, n);
        return _in.gcount();
    }
private:
    std::basic_istream<CharT>& _in;
};

using stream_sink = basic_stream_sink<char>;
using stream_source = basic_stream_source<char>;

template <typename CharT, typename Buffering = buffer_1k>
using basic_filtered_outstream = basic_outstream<basic_filtered_sink<CharT>, Buffering, CharT>;
template <typename CharT, typename Buffering = buffer_1k>
using basic_filtered_instream = basic_instream<basic_filtered_source<CharT>, Buffering, CharT>;

using filtered_outstream = basic_filtered_outstream<char>;
using filtered_instream = basic_filtered_instream<char>;

} // end of servlet namespace

#endif // MOD_SERVLET_IO_FILTER_H