REDI_BASIC_OPSTREAM(3)

📦
version 1.0.4 · 2 versions
, in ubuntu resolute, ubuntu stonking

🌸 redi::basic_opstream 🌸

okay bestie, welcome to a page straight outta the Library Functions Manual — this is the class template for Output PStreams and she is serving. grab a boba, we're going in 💖

✨ 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. she's got so many ancestors, main character energy fr fr 👑

💜 Public Types 💜

  • typedef pbase_type::pmode pmode — the type you use to say how to connect to the process 🔌
  • typedef pbase_type::argv_type argv_type — the type that holds all the arguments for a command 📝
  • typedef int fd_type — the type used for file descriptors, it's just int and that's iconic 💅

💜 Public Member Functions 💜

  • basic_opstream () — default constructor, makes an uninitialised stream (so, a little empty shell, no thoughts, head empty 🐚)
  • 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, the farewell tour 💀
  • 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 () — (the docs just drop the name and ghost us, no description given, she's mysterious like that 🙈)
  • bool is_open () const — reports whether the stream's buffer has been initialised 👀
  • const std::string & command () const — returns the command used to initialise the stream 📣
  • streambuf_type * rdbuf () const — returns 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, 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 📜

(noting for the record bestie: 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."

so like. you write into it, and it lands on the command's stdin. the command's stdout? that's just whatever the process that made the pstream already had, unless the command itself switched it up. no cap 💯

💖 Member Enumeration Documentation 💖

anonymous enum [protected], [inherited]

Enumerator 👑

  • bufsz — Size of pstreambuf buffers 📦
  • pbsz — Number of putback characters kept ↩️

💖 Constructor & Destructor Documentation 💖

💗 basic_opstream (const std::string & cmd, pmode mode = pstdin) [inline], [explicit]

template<typename CharT, typename Traits = std::char_traits<CharT>>
redi::basic_opstream< CharT, Traits >::basic_opstream (const std::string & cmd, pmode mode = pstdin)

Constructor that initialises the stream by starting a process. 🚀 she initialises the stream buffer by calling do_open() with the args you handed her.

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)

💗 basic_opstream (const std::string & file, const argv_type & argv, pmode mode = pstdin) [inline]

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)

Constructor that initialises the stream by starting a process. 🚀 same vibe: calls 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)

💗 basic_opstream (const argv_type & argv, pmode mode = pstdin) [inline], [explicit]

template<typename CharT, typename Traits = std::char_traits<CharT>>
redi::basic_opstream< CharT, Traits >::basic_opstream (const argv_type & argv, pmode mode = pstdin)

Constructor that initialises the stream by starting a process. 🚀 this one calls do_open(argv[0],argv,mode|pstdin) — yes, exactly like that, argv[0] and everything, periodt.

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)

💗 ~basic_opstream () [inline]

template<typename CharT, typename Traits = std::char_traits<CharT>>
redi::basic_opstream< CharT, Traits >::~basic_opstream ()

Destructor. Closes the stream and waits for the child to exit. 😭 the emotional goodbye — she closes up and waits for the child, very responsible queen 💅

💖 Member Function Documentation 💖

💗 close () [inline], [inherited]

template<typename C, typename T> int redi::pstream_common< C, T >::close ()

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_.

💗 command () const [inline], [inherited]

template<typename C, typename T> const std::string & redi::pstream_common< C, T >::command () const

Return the command used to initialise the stream. 📣

Returns

  • a string containing the command used to initialise the stream 🫶

References command_.

💗 do_open (const std::string & cmd, pmode mode) [inline], [protected], [inherited]

template<typename C, typename T> void redi::pstream_common< C, T >::do_open (const std::string & cmd, pmode mode)

Start a process. Calls rdbuf()->open( cmd , 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(). (she's everywhere, the social butterfly of this library 🦋)

💗 do_open (const std::string & file, const argv_type & argv, pmode mode) [inline], [protected], [inherited]

template<typename C, typename T> void redi::pstream_common< C, T >::do_open (const std::string & file, const argv_type & argv, pmode mode)

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_.

💗 is_open () const [inline], [inherited]

template<typename C, typename T> bool redi::pstream_common< C, T >::is_open () const

Report whether the stream's buffer has been initialised. 👀

Returns

  • rdbuf()->is_open()

See also

  • basic_pstreambuf::is_open()

References buf_.

💗 open (const std::string & cmd, pmode mode = pstdin) [inline]

template<typename CharT, typename Traits = std::char_traits<CharT>> void
redi::basic_opstream< CharT, Traits >::open (const std::string & cmd, pmode mode = pstdin)

Start a process. Calls do_open( cmd , mode|pstdin ). 🏁 notice the |pstdin bestie, don't lose it ✨

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)

💗 open (const std::string & file, const argv_type & argv, pmode mode = pstdin) [inline]

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)

Start a process. Calls do_open( file , argv , mode|pstdin ). 🏁 again with the |pstdin — it's part of the fit, it stays 💅

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)

💗 rdbuf () const [inline], [inherited]

template<typename C, typename T> pstream_common< C, T >::streambuf_type *
redi::pstream_common< C, T >::rdbuf () const

Return a pointer to the stream buffer. 🎯

Returns

  • a pointer to the private stream buffer member 🔐

References buf_.

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. 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. 🤖 (not a human author bestie, it's the robot doing the typing ✨)

and that's the whole page, bestie!! 🌈 this came out of PStreams, living in section 3 of the manual (redi::basi...T, Traits >(3), the header and footer doing their little matching fit 👑). every single flag, type, default, param and reference is still here, i just gave it a makeover. mwah 💋

📦 where this page comes from