---

more/cf/pipestream.h

Go to the documentation of this file.

//  more/pipestream.h
//  Copyright (C) 1998--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)

//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.

//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.

//  $Id: pipestream.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $


#ifndef MORE_PIPESTREAM_H
#define MORE_PIPESTREAM_H

#include <stdexcept>
#include <ios>
#include <iostream>
#include <string>

#include <unistd.h>


namespace more {

//template <class charT, class traits>
class pipe_streambuf : public std::streambuf {
    typedef std::char_traits<char> traits;
    typedef traits::int_type int_type;
    typedef traits::char_type char_type;
    int fd[2];

public:
    pipe_streambuf() {
        if(pipe(fd) < 0)
            throw std::runtime_error("Could not open pipe.");
    }
    ~pipe_streambuf() {
        if(fd[0] != -1) close(fd[0]);
        if(fd[1] != -1) close(fd[1]);
    }
    void close_input() { close(fd[0]); fd[0] = -1; }
    void close_output() { close(fd[1]); fd[1] = -1; }

protected:

    int_type sync() {
        std::streamsize n = pptr() - pbase();
        if(n && write(fd[1], pbase(), n*sizeof(char_type)) < 0)
            return EOF;
        return 0;
    }

    int_type underflow() {
        char_type buf[2];
        if(read(fd[0], buf, sizeof(char_type)) != 1) return traits::eof();
        else return traits::to_int_type(buf[0]);
    }

    int_type uflow() { return underflow(); }
    // to prevent storing in temporary buffer?

    int_type overflow(int_type c = traits::eof()) {
        return write(fd[1], &c, sizeof(char_type)) == 1? 1 : traits::eof();
    }
    std::streamsize xsputn(const char_type* s, std::streamsize n) {
        return write(fd[1], s, n*sizeof(char_type));
        ///fixme: should we divide returned value by sizeof(char_type)?
        //check it. 
    }
};


class pipe_stream : virtual public pipe_streambuf, public std::iostream {
public:
    pipe_stream() : std::iostream(this) {}
};

}

#endif

---