ChildStream inherits from std::iostream.

git-svn-id: https://svn.microneil.com/svn/CodeDweller/branches/adeniz_1@77 d34b734f-a00e-4b39-a726-e4eeb87269ab

child.cpp

 
 namespace CodeDweller {
 
-  Child::Child(std::vector<std::string> args, size_t bufSize) :
+  ChildStream::ChildStream(std::vector<std::string> args, size_t bufSize) :
     childStreambuf(bufSize),
-    childStream(&childStreambuf),
+    std::iostream(&childStreambuf),
     cmdArgs(args) {
 
     init();
 
   }
 
-  Child::Child(std::string childpath, size_t bufSize) :
+  ChildStream::ChildStream(std::string childpath, size_t bufSize) :
     childStreambuf(bufSize),
-    childStream(&childStreambuf),
+    std::iostream(&childStreambuf),
     cmdline(childpath) {
     cmdArgs.push_back(childpath);
     init();
   }
 
-  Child::~Child() {
+  ChildStream::~ChildStream() {
     // Close handles.
   }
 
   void
-  Child::init() {
+  ChildStream::init() {
 
     if (cmdArgs.empty()) {
       throw std::invalid_argument("A child executable must be specified.");
   }
 
   size_t
-  Child::numBytesAvailable() const {
+  ChildStream::numBytesAvailable() const {
 
     return childStreambuf.numBytesAvailable();
 
   }
 
   void
-  Child::run() {
+  ChildStream::run() {
 
     if (childStarted) {
       throw std::logic_error("Child process was active when "
 
 	// Send message to parent.
 	errMsg = "Error redirecting stdin in the child:  " + getErrorText();
-	write(childStdOutPipe[1], errMsg.data(), errMsg.size());
+	::write(childStdOutPipe[1], errMsg.data(), errMsg.size());
 	exit(-1);
       }
 
 
 	// Send message to parent.
 	errMsg = "Error redirecting stdout in the child:  " + getErrorText();
-	write(childStdOutPipe[1], errMsg.data(), errMsg.size());
+	::write(childStdOutPipe[1], errMsg.data(), errMsg.size());
 	exit(-1);
       }
 
 
 	// Send message to parent.
 	errMsg = "Error closing the pipes in the child:  " + getErrorText();
-	write(STDOUT_FILENO, errMsg.data(), errMsg.size());
+	::write(STDOUT_FILENO, errMsg.data(), errMsg.size());
 	exit(-1);
 
       }
 
       // Send message to parent.
       errMsg = "Error from exec:  " + getErrorText();
-      write(STDOUT_FILENO, errMsg.data(), errMsg.size());
+      ::write(STDOUT_FILENO, errMsg.data(), errMsg.size());
       exit(-1);
 
     }
   }
 
   void
-  Child::terminate() {
+  ChildStream::terminate() {
 
     if (isDone()) {
 
   }
 
   bool
-  Child::isDone() {
+  ChildStream::isDone() {
 
     if (childExited) {
 
   }
 
   int32_t
-  Child::result() {
+  ChildStream::result() {
 
     if (exitCodeObtainedFlag) {
 
   }
 
   std::string
-  Child::getErrorText() {
+  ChildStream::getErrorText() {
 
 #ifdef _WIN32
     LPVOID winMsgBuf;
 #endif
   }
 
-  Child::ChildStreambuf::ChildStreambuf(std::size_t bufferSize) :
+  ChildStream::ChildStreambuf::ChildStreambuf(std::size_t bufferSize) :
 #ifdef _WIN32
     inputHandle(0),
     outputHandle(0),
 
 #ifdef _WIN32
   void
-  Child::ChildStreambuf::setInputHandle(HANDLE inHandle) {
+  ChildStream::ChildStreambuf::setInputHandle(HANDLE inHandle) {
 
     inputHandle = inHandle;
 
   }
 #else
   void
-  Child::ChildStreambuf::setInputFileDescriptor(int inFd) {
+  ChildStream::ChildStreambuf::setInputFileDescriptor(int inFd) {
 
     inputFileDescriptor = inFd;
 
 #endif
 
   size_t
-    Child::ChildStreambuf::numBytesAvailable() const {
+    ChildStream::ChildStreambuf::numBytesAvailable() const {
 
     size_t nBytesAvailable =  egptr() - gptr();
 
   }
 
   std::streambuf::int_type
-  Child::ChildStreambuf::underflow() {
+  ChildStream::ChildStreambuf::underflow() {
 
     // Check for empty buffer.
     if (gptr() < egptr()) {
 #else
     ssize_t nBytesRead;
 
-    nBytesRead = read(inputFileDescriptor,
-		      start,
-		      readBuffer.size() - (start - base));
+    nBytesRead = ::read(inputFileDescriptor,
+                        start,
+                        readBuffer.size() - (start - base));
     if (-1 == nBytesRead) {
       return traits_type::eof();
     }
 
 #ifdef _WIN32
   void
-  Child::ChildStreambuf::setOutputHandle(HANDLE outHandle) {
+  ChildStream::ChildStreambuf::setOutputHandle(HANDLE outHandle) {
 
     outputHandle = outHandle;
 
   }
 #else
   void
-  Child::ChildStreambuf::setOutputFileDescriptor(int outFd) {
+  ChildStream::ChildStreambuf::setOutputFileDescriptor(int outFd) {
 
     outputFileDescriptor = outFd;
 
 #endif
 
   void
-  Child::ChildStreambuf::flushBuffer() {
+  ChildStream::ChildStreambuf::flushBuffer() {
 
     // Write.
     std::ptrdiff_t nBytes = pptr() - pbase();
 #else
     ssize_t nBytesWritten;
 
-    nBytesWritten = write(outputFileDescriptor, pbase(), nBytes);
+    nBytesWritten = ::write(outputFileDescriptor, pbase(), nBytes);
 
 #endif
 
   }
 
   std::streambuf::int_type
-  Child::ChildStreambuf::overflow(int_type ch) {
+  ChildStream::ChildStreambuf::overflow(int_type ch) {
 
     // Check whether we're writing EOF.
     if (traits_type::eof() != ch) {
   }
 
   int
-  Child::ChildStreambuf::sync() {
+  ChildStream::ChildStreambuf::sync() {
 
     flushBuffer(); // Throws exception on failure.
 

child.hpp

 
   */
 
-  /** Class that abstracts the creation of child processes.
+  /** Class that abstracts the communication with a child process.
 
       This class provides functionality to create a child process,
       communicate with the child process via streams and signals, and
 
   */
 
-  class Child {
+  class ChildStream : public std::iostream {
 
   private:
 
     /// writing to the standard input of the child process.
     class ChildStreambuf : public std::streambuf {
 
-      friend class Child;
+      friend class ChildStream;
 
     public:
 
 	executable, and args[1] thru args[n] are the command-line
 	parameters.
 
-	\param[in] bufSize is the buffer size of the reader and writer
-	streams used to communicate with the child process.
+	\param[in] bufSize is the input and output buffer size of the
+	stream used to communicate with the child process.
 
     */
-    Child(std::vector<std::string> args, size_t bufSize = 4096);
+    ChildStream(std::vector<std::string> args, size_t bufSize = 4096);
 
     /** Constructor for spawning without command-line parameters.
 
 
 	\param[in] childpath contains the child executable file name.
 
-	\param[in] bufSize is the buffer size of the reader and writer
-	streams used to communicate with the child process.
+	\param[in] bufSize is the input and output buffer size of the
+	stream used to communicate with the child process.
 
     */
-    Child(std::string childpath, size_t bufSize = 4096);
+    ChildStream(std::string childpath, size_t bufSize = 4096);
 
     /** Destructor terminates the child process. */
-    ~Child();
-
-    /// I/O stream to read data from the child's standard output and
-    /// write data to the child's standard input.
-    std::iostream childStream;
+    ~ChildStream();
 
     /** Get the number of bytes available for input.
 
-	@returns number of bytes that can be read from reader without
-	blocking.
+	@returns number of bytes that can be read without blocking.
 
     */
     size_t numBytesAvailable() const;