unbuffered_streambuf.hpp

Go to the documentation of this file.

/*
 * Copyright 2015, alex at staticlibs.net
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* 
 * File:   unbuffered_streambuf.hpp
 * Author: alex
 *
 * Created on October 9, 2015, 12:10 PM
 */

#ifndef STATICLIB_IO_UNBUFFERED_STREAMBUF_HPP
#define STATICLIB_IO_UNBUFFERED_STREAMBUF_HPP

#include <ios>
#include <memory>
#include <streambuf>
#include <utility>

#include "staticlib/config.hpp"

#include "staticlib/io/reference_sink.hpp"
#include "staticlib/io/reference_source.hpp"
#include "staticlib/io/span.hpp"

namespace staticlib {
namespace io {

namespace detail {

class unbuffered_streambuf_base : public std::streambuf {
public:   
    virtual int underflow() override {
        throw std::ios_base::failure("'underflow' operation is not supported by unbuffered streambuf");
    }

    virtual int uflow() override {
        throw std::ios_base::failure("'uflow' operation is not supported by unbuffered streambuf");
    }

    virtual int overflow(int) override {
        throw std::ios_base::failure("'overflow' operation is not supported by unbuffered streambuf");
    }

protected:

    virtual std::streamsize xsgetn(char*, std::streamsize) override {
        throw std::ios_base::failure("'xsgetn' operation is not supported by unbuffered streambuf");
    }

    virtual std::streamsize xsputn(const char*, std::streamsize) override {
        throw std::ios_base::failure("'xsputn' operation is not supported by unbuffered streambuf");
    }

    virtual unbuffered_streambuf_base* setbuf(char*, std::streamsize) override {
        throw std::ios_base::failure("'setbuf' operation is not supported by unbuffered streambuf");
    }

    virtual std::streampos seekoff(std::streamoff, std::ios_base::seekdir, std::ios_base::openmode) override {
        throw std::ios_base::failure("'seekoff' operation is not supported by unbuffered streambuf");
    }

    virtual std::streampos seekpos(std::streampos, std::ios_base::openmode) override {
        throw std::ios_base::failure("'seekpos' operation is not supported by unbuffered streambuf");
    }

};

} // namespace

// use -1 as std::char_traits<char>::eof() won't work in msvc
template <typename Source, std::streamsize source_eof = -1>
class unbuffered_istreambuf : public detail::unbuffered_streambuf_base {
    Source source;
    bool exhausted = false;

public:
    explicit unbuffered_istreambuf(Source&& source) : 
    source(std::move(source)) { }

    unbuffered_istreambuf(const unbuffered_istreambuf&) = delete;

    unbuffered_istreambuf& operator=(const unbuffered_istreambuf&) = delete;

    unbuffered_istreambuf(unbuffered_istreambuf&& other) STATICLIB_NOEXCEPT :
    source(std::move(other.source)),
    exhausted(other.exhausted) { 
        other.exhausted = true;
    }

    unbuffered_istreambuf& operator=(unbuffered_istreambuf&& other) STATICLIB_NOEXCEPT {
        source = std::move(other.source);
        exhausted = other.exhausted;
        other.exhausted = true;
        return *this;
    }

    virtual int uflow() override {
        if (exhausted) {
            return std::char_traits<char>::eof();
        } else {
            throw std::ios_base::failure("'uflow' operation is not supported by unbuffered streambuf");
        }
    }
    
    Source& get_source() {
        return source;
    }

protected:
    virtual std::streamsize xsgetn(char* s, std::streamsize count) override {
        if (!exhausted) {
            auto res = source.read({s, count});
            if (source_eof != res) {
                return res;
            } else {
                exhausted = true;
                return 0;
            }
        } else {
            return 0;
        }
    }
};

template <typename Source,
        class = typename std::enable_if<!std::is_lvalue_reference<Source>::value>::type>
unbuffered_istreambuf<Source> make_unbuffered_istreambuf(Source&& source) {
    return unbuffered_istreambuf<Source>(std::move(source));
}

template <typename Source,
class = typename std::enable_if<!std::is_lvalue_reference<Source>::value>::type>
std::unique_ptr<unbuffered_istreambuf<Source>> make_unbuffered_istreambuf_ptr(Source&& source) {
    return std::unique_ptr<unbuffered_istreambuf<Source>>(
            new unbuffered_istreambuf<Source>(std::move(source)));
}

template <typename Source>
unbuffered_istreambuf<reference_source<Source>> make_unbuffered_istreambuf(Source& source) {
    return unbuffered_istreambuf<reference_source<Source>>(make_reference_source(source));
}

template <typename Source>
std::unique_ptr<unbuffered_istreambuf<reference_source<Source>>> make_unbuffered_istreambuf_ptr(Source& source) {
    return std::unique_ptr<unbuffered_istreambuf<reference_source<Source>>>(
            new unbuffered_istreambuf<reference_source<Source>>(make_reference_source(source)));
}

template <typename Sink>
class unbuffered_ostreambuf : public detail::unbuffered_streambuf_base {
    Sink sink;

public:
    explicit unbuffered_ostreambuf(Sink&& sink) : 
    sink(std::move(sink)) { }

    unbuffered_ostreambuf(const unbuffered_ostreambuf&) = delete;

    unbuffered_ostreambuf& operator=(const unbuffered_ostreambuf&) = delete;

    unbuffered_ostreambuf(unbuffered_ostreambuf&& other) STATICLIB_NOEXCEPT :
    sink(std::move(other.sink)) { }

    unbuffered_ostreambuf& operator=(unbuffered_ostreambuf&& other) STATICLIB_NOEXCEPT {
        sink = std::move(other.sink);
        return *this;
    }

    Sink& get_sink() {
        return sink;
    }

protected:

    virtual std::streamsize xsputn(const char* s, std::streamsize count) override {
        return sink.write({s, count});
    }
};

template <typename Sink,
        class = typename std::enable_if<!std::is_lvalue_reference<Sink>::value>::type>
unbuffered_ostreambuf<Sink> make_unbuffered_ostreambuf(Sink&& sink) {
    return unbuffered_ostreambuf<Sink>(std::move(sink));
}

template <typename Sink,
class = typename std::enable_if<!std::is_lvalue_reference<Sink>::value>::type>
std::unique_ptr<unbuffered_ostreambuf<Sink>> make_unbuffered_ostreambuf_ptr(Sink&& sink) {
    return std::unique_ptr<unbuffered_ostreambuf<Sink>>(
            new unbuffered_ostreambuf<Sink>(std::move(sink)));
}

template <typename Sink>
unbuffered_ostreambuf<reference_sink<Sink>> make_unbuffered_ostreambuf(Sink& sink) {
    return unbuffered_ostreambuf<reference_sink<Sink>>(make_reference_sink(sink));
}

template <typename Sink>
std::unique_ptr<unbuffered_ostreambuf<reference_sink<Sink>>> make_unbuffered_ostreambuf_ptr(Sink& sink) {
    return std::unique_ptr<unbuffered_ostreambuf<reference_sink<Sink>>>(
            new unbuffered_ostreambuf<reference_sink<Sink>>(make_reference_sink(sink)));
}
    
} // namespace
}

#endif /* STATICLIB_IO_UNBUFFERED_STREAMBUF_HPP */