NAME

       redi::basic_opstream - Class template for Output PStreams

SYNOPSIS

       #include <pstream.h>

       Inherits std::basic_ostream< CharT, std::char_traits< CharT > >, redi::pstream_common< CharT, Traits >,
       and redi::pstreams.

   Public Types
       typedef pbase_type::pmode pmode
           Type used to specify how to connect to the process.
       typedef pbase_type::argv_type argv_type
           Type used to hold the arguments for a command.
       typedef int fd_type
           Type used for file descriptors.

   Public Member Functions
       basic_opstream ()
           Default constructor, creates an uninitialised stream.
       basic_opstream (const std::string &cmd, pmode mode=pstdin)
           Constructor that initialises the stream by starting a process.
       basic_opstream (const std::string &file, const argv_type &argv, pmode mode=pstdin)
           Constructor that initialises the stream by starting a process.
       basic_opstream (const argv_type &argv, pmode mode=pstdin)
           Constructor that initialises the stream by starting a process.
       ~basic_opstream ()
           Destructor.
       void open (const std::string &cmd, pmode mode=pstdin)
           Start a process.
       void open (const std::string &file, const argv_type &argv, pmode mode=pstdin)
           Start a process.
       int close ()
       bool is_open () const
           Report whether the stream's buffer has been initialised.
       const std::string & command () const
           Return the command used to initialise the stream.
       streambuf_type * rdbuf () const
           Return a pointer to the stream buffer.

   Static Public Attributes
       static const pmode pstdin = std::ios_base::out
           Write to stdin.
       static const pmode pstdout = std::ios_base::in
           Read from stdout.
       static const pmode pstderr = std::ios_base::app
           Read from stderr.
       static const pmode newpg = std::ios_base::trunc
           Create a new process group for the child process.

   Protected Types
       typedef basic_pstreambuf< CharT, Traits > streambuf_type
       typedef std::basic_ios< CharT, Traits > ios_type
       enum { bufsz = 32 }
       enum { pbsz = 2 }

   Protected Member Functions
       void do_open (const std::string &cmd, pmode mode)
           Start a process.
       void do_open (const std::string &file, const argv_type &argv, pmode mode)
           Start a process.

   Protected Attributes
       std::string command_
           The command used to start the process.

   Related Symbols
       (Note that these are not member symbols.)
       template<typename C, typename T> std::basic_ostream< C, T > & peof (std::basic_ostream< C, T > &s)
           Manipulator to close the pipe connected to the process' stdin.

Detailed Description

   template<typename CharT, typename Traits = std::char_traits<CharT>>
       class redi::basic_opstream< CharT, Traits >"Class template for Output PStreams.

       Writing to an open opstream writes to the standard input of the command; the command's standard output is
       the same as that of the process that created the pstream object, unless altered by the command itself.

Constructor & Destructor Documentation

   template<typename CharT, typename Traits = std::char_traits<CharT>> redi::basic_opstream< CharT, Traits
       >::basic_opstream (const std::string & cmd, pmode mode = pstdin) [inline],  [explicit]
       Constructor that initialises the stream by starting a process. Initialises the stream buffer by calling
       do_open() with the supplied arguments.

       Parameters
           cmd a string containing a shell command.
           mode the I/O mode to use when opening the pipe.

       See also
           do_open(const std::string&, pmode)

   template<typename CharT, typename Traits = std::char_traits<CharT>> redi::basic_opstream< CharT, Traits
       >::basic_opstream (const std::string & file, const argv_type & argv, pmode mode = pstdin) [inline]
       Constructor that initialises the stream by starting a process. Initialises the stream buffer by calling
       do_open() with the supplied arguments.

       Parameters
           file a string containing the pathname of a program to execute.
           argv a vector of argument strings passed to the new program.
           mode the I/O mode to use when opening the pipe.

       See also
           do_open(const std::string&, const argv_type&, pmode)

   template<typename CharT, typename Traits = std::char_traits<CharT>> redi::basic_opstream< CharT, Traits
       >::basic_opstream (const argv_type & argv, pmode mode = pstdin) [inline],  [explicit]
       Constructor that initialises the stream by starting a process. Initialises the stream buffer by calling
       do_open(argv[0],argv,mode|pstdin)

       Parameters
           argv a vector of argument strings passed to the new program.
           mode the I/O mode to use when opening the pipe.

       See also
           do_open(const std::string&, const argv_type&, pmode)

   template<typename CharT, typename Traits = std::char_traits<CharT>> redi::basic_opstream< CharT, Traits
       >::~basic_opstream () [inline]
       Destructor. Closes the stream and waits for the child to exit.

Member Function Documentation

   template<typename C, typename T> int redi::pstream_common< C, T >::close () [inline],  [inherited]
       Close the pipe, returning the program's exit status, as pclose(3) does.

       Calls rdbuf->close() and sets failbit on error. Returns process's exit status, as pclose(3) does.

       References buf_.

   template<typename C, typename T> const std::string & redi::pstream_common< C, T >::command () const [inline],
       [inherited]
       Return the command used to initialise the stream.

       Returns
           a string containing the command used to initialise the stream.

       References command_.

   template<typename C, typename T> void redi::pstream_common< C, T >::do_open (const std::string & cmd, pmode
       mode) [inline],  [protected],  [inherited]
       Start a process. Calls rdbuf()->open( command , mode ) and sets failbit on error.

       Parameters
           cmd a string containing a shell command.
           mode the I/O mode to use when opening the pipe.

       See also
           basic_pstreambuf::open(const std::string&, pmode)

       References buf_, and command_.

       Referenced by redi::basic_ipstream< char >::open(), redi::basic_ipstream< char >::open(),
       redi::basic_opstream< char >::open(), redi::basic_opstream< char >::open(), redi::basic_pstream< char
       >::open(), redi::basic_pstream< char >::open(), redi::basic_rpstream< char >::open(),
       redi::basic_rpstream< char >::open(), pstream_common(), and pstream_common().

   template<typename C, typename T> void redi::pstream_common< C, T >::do_open (const std::string & file, const
       argv_type & argv, pmode mode) [inline],  [protected],  [inherited]
       Start a process. Calls rdbuf()->open( file, argv, mode ) and sets failbit on error.

       Parameters
           file a string containing the pathname of a program to execute.
           argv a vector of argument strings passed to the new program.
           mode the I/O mode to use when opening the pipe.

       See also
           basic_pstreambuf::open(const std::string&, const argv_type&, pmode)

       References buf_, and command_.

   template<typename C, typename T> bool redi::pstream_common< C, T >::is_open () const [inline],  [inherited]
       Report whether the stream's buffer has been initialised.

       Returns
           rdbuf()->is_open().

       See also
           basic_pstreambuf::is_open()

       References buf_.

   template<typename CharT, typename Traits = std::char_traits<CharT>> void redi::basic_opstream< CharT, Traits
       >::open (const std::string & cmd, pmode mode = pstdin) [inline]
       Start a process. Calls do_open( cmd , mode|pstdin ).

       Parameters
           cmd a string containing a shell command.
           mode the I/O mode to use when opening the pipe.

       See also
           do_open(const std::string&, pmode)

   template<typename CharT, typename Traits = std::char_traits<CharT>> void redi::basic_opstream< CharT, Traits
       >::open (const std::string & file, const argv_type & argv, pmode mode = pstdin) [inline]
       Start a process. Calls do_open( file , argv , mode|pstdin ).

       Parameters
           file a string containing the pathname of a program to execute.
           argv a vector of argument strings passed to the new program.
           mode the I/O mode to use when opening the pipe.

       See also
           do_open(const std::string&, const argv_type&, pmode)

   template<typename C, typename T> pstream_common< C, T >::streambuf_type * redi::pstream_common< C, T >::rdbuf
       () const [inline],  [inherited]
       Return a pointer to the stream buffer.

       Returns
           a pointer to the private stream buffer member.

       References buf_.

Friends And Related Symbol Documentation

   template<typename C, typename T> std::basic_ostream< C, T > & peof (std::basic_ostream< C, T > & s) [related]

       Manipulator to close the pipe connected to the process' stdin. When inserted into an output pstream the
       manipulator calls basic_pstreambuf<C,T>::peof() to close the output pipe, causing the child process to
       receive the end-of-file indicator on subsequent reads from its stdin stream.

       Parameters
           s An output PStream class.

       Returns
           The stream object the manipulator was invoked on.

       See also
           basic_pstreambuf<C,T>::peof() basic_pstream basic_rpstream

Author

       Generated automatically by Doxygen for PStreams from the source code.

                                                    PStreams            redi::basic_opstream< CharT, Traits >(3)