C++: buffer the cin istream

Question

The problem is:

I have a code that operates on a fully functional istream. It uses methods like:

istream is;
is.seekg(...) // <--- going backwards at times
is.tellg()    // <--- to save the position before looking forward
etc.

These methods are only available for istreams from, say, a file. However, if I use cin in this fashion, it will not work--cin does not have the option of saving a position, reading forward, then returning to the saved position.

// So, I can't cat the file into the program
cat file | ./program

// I can only read the file from inside the program
./program -f input.txt

// Which is the problem with a very, very large zipped file
// ... that cannot coexist on the same raid-10 drive system 
// ... with the resulting output
zcat really_big_file.zip | ./program //<--- Doesn't work due to cin problem
./program -f really_big_file.zip //<--- not possible without unzipping

I can read cin into a deque, and process the deque. A 1mb deque buffer would be more than enough. However, this is problematic in three senses:

1. I have to rewrite everything to do this with a deque
2. It wont be as bulletproof as just using an istream, for which the code has already been debugged
3. It seems like, if I implement it as a deque with some difficulty, someone is going to come along and say, why didn't you just do it like ___

---

What is the proper/most efficient way to create a usable istream object, in the sense that all members are active, with a cin istream?

(Bearing in mind that performance is important)

Answer 1

cin is user input and should be treated as unpredictable. If you want to use mentioned functionality and you are sure about your input you can read whole input to istringstream and then operate on it

Answer 2

You could create a filtering stream buffer reading from std::cin when getting new data but buffering all received characters. You'd be able to implement seeking within the buffered range of the input. Seeking beyond the end of the already buffered input would imply reading corresponding amounts of data. Here is an example of a corresponding implementation:

#include <iostream>
#include <vector>

class bufferbuf
    : public std::streambuf {
private:
    std::streambuf*   d_sbuf;
    std::vector<char> d_buffer;

    int_type underflow() {
        char buffer[1024];
        std::streamsize size = this->d_sbuf->sgetn(buffer, sizeof(buffer));
        if (size == 0) {
            return std::char_traits<char>::eof();
        }
        this->d_buffer.insert(this->d_buffer.end(), buffer, buffer + size);
        this->setg(this->d_buffer.data(),
                   this->d_buffer.data() + this->d_buffer.size() - size,
                   this->d_buffer.data() + this->d_buffer.size());
        return std::char_traits<char>::to_int_type(*this->gptr());
    }
    pos_type seekoff(off_type off, std::ios_base::seekdir whence, std::ios_base::openmode) {
        switch (whence) {
        case std::ios_base::beg:
            this->setg(this->eback(), this->eback() + off, this->egptr());
            break;
        case std::ios_base::cur:
            this->setg(this->eback(), this->gptr() + off, this->egptr());
            break;
        case std::ios_base::end:
            this->setg(this->eback(), this->egptr() + off, this->egptr());
            break;
        default: return pos_type(off_type(-1)); break;
        }
        return pos_type(off_type(this->gptr() - this->eback()));
    }
    pos_type seekpos(pos_type pos, std::ios_base::openmode) {
        this->setg(this->eback(), this->eback() + pos, this->egptr());
        return pos_type(off_type(this->gptr() - this->eback()));
    }
public:
    bufferbuf(std::streambuf* sbuf)
        : d_sbuf(sbuf)
        , d_buffer() {
        this->setg(0, 0, 0); // actually the default setting
    }
};

int main() {
    bufferbuf      sbuf(std::cin.rdbuf());
    std::istream   in(&sbuf);
    std::streampos pos(in.tellg());

    std::string line;
    while (std::getline(in, line)) {
        std::cout << "pass1: '" << line << "'\n";
    }
    in.clear();
    in.seekg(pos);
    while (std::getline(in, line)) {
        std::cout << "pass2: '" << line << "'\n";
    }
}

This implementation buffers input before passing it on to the reading step. You can read individual characters (e.g. change char buffer[1024]; to become char buffer[1]; or replace the use of sgetn() appropriately using sbumpc()) to provide a more direct response: there is a trade-off between immediate response and performance for batch processing.