FILEStream.hpp

// <FILEStream> -*- C++ -*-
 
#pragma once
 
#include <ios>
#include <iostream>
#include <memory>
#include <algorithm>
#include <cstdio>
#include <cstring>
 
class FILEOstream {
 
private:
 
    class OFILE_streambuf : public std::streambuf {
    public:
 
        OFILE_streambuf(FILE *fp, size_t buf_size = 1024) :
            fp_(fp),
            buf_(new char[buf_size]),
            buf_size_(buf_size)
        {
            if (fp_ == nullptr) {
                throw std::ios_base::failure("Underlying stream pointer is null");
            }
            if (buf_.get() == nullptr) {
                throw std::bad_alloc();
            }
 
            char *b = buf_.get();
 
            // Set current pointer to beginning of buffer
            setp(&b[0], &b[buf_size_]);
        }
 
    private:
 
        int_type overflow(int_type ch = traits_type::eof()) override {
 
            // Try to drain the intermediate buffer, if it is full.
            if (pptr() == epptr()) {
                sync();
            }
            if (traits_type::eq_int_type(ch, traits_type::eof()) == true) {
                return traits_type::eof();
            }
 
            // Insert the new character into the intermediate buffer.
            // Note: the pptr() may still be epptr(), if sync failed above.
            if (pptr() != epptr()) {
                *pptr() = ch;
                pbump(1);
                return 0;
            }
            return traits_type::eof();
        }
 
        int sync() override {
            size_t chars_to_write = pptr() - pbase();
            size_t chars_written = fwrite(pbase(), 1, chars_to_write, fp_);
            if (chars_written == chars_to_write) {
                char *b = buf_.get();
                setp(&b[0], &b[buf_size_]);
                return 0;
            }
            pbump(chars_written);
            return -1;
        }
 
        std::streamsize xsputn(const char_type *s, std::streamsize count) override {
            // First flush out the intermediate buffer
            if (sync() == -1) {
                return 0;
            }
 
            // Now write the rest of the characters directly to the FILE
            return fwrite(s, 1, count, fp_);
        }
 
        FILE *fp_;                      
        std::unique_ptr<char[]> buf_;   
        const size_t buf_size_;         
    };
 
public:
 
    FILEOstream(FILE *fd) :
        streambuf_(fd),
        stream_(&streambuf_) { }
 
    std::ostream& getStream() {
        return stream_;
    }
 
private:
 
    OFILE_streambuf streambuf_;   
    std::ostream stream_;         
};
 
 
class FILEIstream {
 
private:
 
    class IFILE_streambuf : public std::streambuf {
    public:
 
        IFILE_streambuf(FILE *fp, size_t buf_size = 1024) :
            fp_(fp),
            buf_(new char[buf_size]),
            buf_size_(buf_size)
        {
            if (fp_ == nullptr) {
                throw std::ios_base::failure("Underlying stream pointer is null");
            }
            if (buf_.get() == nullptr) {
                throw std::bad_alloc();
            }
 
            char *b = buf_.get();
 
            // Set current pointer to end of buffer, indicating it is empty
            setg(&b[0], &b[buf_size_], &b[buf_size_]);
        }
 
    private:
 
        int_type underflow() override {
            if (gptr() == egptr()) {
                char *b = buf_.get();
                auto byte_cnt = xsgetn(b, buf_size_);
                if (byte_cnt == 0) {
                    // There is no more data from the file, and the
                    // intermediate buffer is empty.  Leave gptr() == egptr(),
                    // as required by parent class.
                    return traits_type::eof();
 
                } else if (static_cast<size_t>(byte_cnt) < buf_size_) {
                    // We just extracted the last of the data from the file,
                    // and the intermediate buffer is partially filled.  Set
                    // the end pointer accordingly.
                    setg(&b[0], &b[0], &b[byte_cnt]);
 
                } else {
                    // We just filled the entire intermediate buffer, and there
                    // is still more data to read from the file.
                    setg(&b[0], &b[0], &b[buf_size_]);
                }
            }
            return *gptr();
        }
 
        std::streamsize xsgetn(char *s, std::streamsize count) override {
            // First empty the intermediate buffer.
            size_t intermediate_chars = egptr() - gptr();
            size_t intermediate_copy = std::min(intermediate_chars, static_cast<size_t>(count));
            memcpy(s, gptr(), intermediate_copy);
            gbump(intermediate_copy);  // Advance gptr()
            s += intermediate_copy;
            count -= intermediate_copy;
            size_t retval = intermediate_copy;
 
            // Now directly read from the FILE for the rest.
            retval += fread(s, 1, count, fp_);
            return retval;
        }
 
        FILE *fp_;                          
        std::unique_ptr<char[]> buf_;       
        const size_t buf_size_;             
    };
 
public:
 
    FILEIstream(FILE *fd) :
        streambuf_(fd),
        stream_(&streambuf_) { }
 
    std::istream& getStream() {
        return stream_;
    }
 
private:
 
    IFILE_streambuf streambuf_;   
    std::istream stream_;         
};