rpstream.h

Go to the documentation of this file.

/* $Id: rpstream.h,v 1.7 2002/10/22 01:30:27 redi Exp $
PStreams - POSIX Process I/O for C++
Copyright (C) 2001,2002 Jonathan Wakely

This file is part of PStreams.

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

PStreams 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 Lesser General Public License for more details.

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

#ifndef REDI_RPSTREAM_H
#define REDI_RPSTREAM_H

#include "pstream.h"

// Check the PStreams version.
// #if PSTREAMS_VERSION < 0x0022
// #error This version of rpstream.h is incompatible with your pstream.h
// #error Please use pstream.h v0.34 or higher.
// #endif


// All PStreams classes are declared in namespace redi.
namespace redi
{
  template <typename CharT, typename Traits = std::char_traits<CharT> >
    class basic_rpstream
    : public std::basic_ostream<CharT, Traits>
    , private std::basic_istream<CharT, Traits>
    , private pstream_common<CharT, Traits>
    {
      typedef std::basic_ostream<CharT, Traits>     ostream_type;
      typedef std::basic_istream<CharT, Traits>     istream_type;
      typedef pstream_common<CharT, Traits>         pbase_type;
      typedef typename pbase_type::pmode            pmode;

    public:
      basic_rpstream();

      basic_rpstream(const std::string& command, pmode mode = std::ios_base::in|std::ios_base::out);

      basic_rpstream(const std::string& file, const std::vector<std::string>& argv, pmode mode = std::ios_base::in|std::ios_base::out);

      ~basic_rpstream() { }

      void
      open(const std::string& command, pmode mode = std::ios_base::in|std::ios_base::out);

      void
      open(const std::string& file, const std::vector<std::string>& argv, pmode mode = std::ios_base::in|std::ios_base::out);

      istream_type&
      out();

      istream_type&
      err();
    };

  typedef basic_rpstream<char> rpstream;


  // TODO document RPSTREAMS better

  /*
   * member definitions for basic_rpstream
   */

  template <typename C, typename T>
    basic_rpstream<C,T>::basic_rpstream()
    : ostream_type(NULL)
    , istream_type(NULL)
    , pbase_type()
    {
      this->init(&buf_);  // calls shared std::basic_ios virtual base class
    }

  template <typename C, typename T>
    basic_rpstream<C,T>::basic_rpstream(const std::string& command, pmode mode)
    : ostream_type(NULL)
    , istream_type(NULL)
    , pbase_type(command, mode)
    {
      this->init(&buf_);
    }

  template <typename C, typename T>
    inline
    basic_rpstream<C,T>::basic_rpstream(const std::string& file, const std::vector<std::string>& argv, pmode mode)
    : ostream_type(NULL)
    , istream_type(NULL)
    , pbase_type(file, argv, mode)
    {
      this->init(&buf_);
    }

  template <typename C, typename T>
    inline void
    basic_rpstream<C,T>::open(const std::string& command, pmode mode)
    {
      pbase_type::open(command, mode);
    }

  template <typename C, typename T>
    inline void
    basic_rpstream<C,T>::open(const std::string& file, const std::vector<std::string>& argv, pmode mode)
    {
      pbase_type::open(file, argv, mode);
    }

  template <typename C, typename T>
    inline typename basic_rpstream<C,T>::istream_type&
    basic_rpstream<C,T>::out()
    {
      buf_.read_err(false);
      return *this;
    }

  template <typename C, typename T>
    inline typename basic_rpstream<C,T>::istream_type&
    basic_rpstream<C,T>::err()
    {
      buf_.read_err(true);
      return *this;
    }

} // namespace redi

#endif  // REDI_RPSTREAM_H

---