StdoutThread Class Reference

Defines a thread class for capturing stdout. More...

#include <StdoutThread.h>

Inheritance diagram for StdoutThread:

Public Member Functions
	StdoutThread (void)
virtual	~StdoutThread (void)
void	Get (CString &dst, bool clear)
void	Quit ()
bool	InitThread (int bufLen, UINT threadMsg, DWORD parentID)
	StdoutThread (void)
virtual	~StdoutThread (void)
void	Get (CString &dst, bool clear)
void	Quit ()
bool	InitThread (int bufLen, UINT threadMsg, DWORD parentID)
Public Member Functions inherited from StdoutRedirect
	StdoutRedirect ()
virtual	~StdoutRedirect ()
void	Close ()
int	Init (int bufferSize)
int	Start ()
int	Stop ()
int	GetBuffer (char *buffer, int size)
	StdoutRedirect ()
virtual	~StdoutRedirect ()
void	Close ()
int	Init (int bufferSize)
int	Start ()
int	Stop ()
int	GetBuffer (char *buffer, int size)

Static Public Member Functions
static UINT __cdecl	ThreadProc (void *param)
static UINT __cdecl	ThreadProc (void *param)

Protected Attributes
int	m_bufLen
	the size of the stdio buffer More...
CriticalCString	m_str
	this stores the data that was read More...
UINT	m_msg
	message to send when data has been read More...
DWORD	m_parentID
	ID of thread to send m_msg to. More...
CWinThread *	m_thread
	pointer to our thread More...
Protected Attributes inherited from StdoutRedirect
FILE *	file
	stdout (subclasses can set this to something else, e.g. stderr) More...

Detailed Description

Defines a thread class for capturing stdout.

Constructor & Destructor Documentation

StdoutThread::StdoutThread

(

void

)

References m_bufLen, m_msg, and m_parentID.

{
   m_bufLen   = 0;
   m_msg      = 0;
   m_parentID = 0;
}

StdoutThread::~StdoutThread ( void  )

virtual

{
}

StdoutThread::StdoutThread

(

void

)

virtual StdoutThread::~StdoutThread ( void  )

virtual

Member Function Documentation

void StdoutThread::Get ( CString &  dst, bool  clear  )

inline

References CriticalCString::Get(), and m_str.

Referenced by COperatorConsoleApp::GetStdoutMsg().

{m_str.Get(dst, clear);}

Here is the call graph for this function:

Here is the caller graph for this function:

void StdoutThread::Get ( CString &  dst, bool  clear  )

inline

References CriticalCString::Get(), and m_str.

{m_str.Get(dst, clear);}

Here is the call graph for this function:

bool StdoutThread::InitThread	(	int	bufLen,
		UINT	threadMsg,
		DWORD	parentID
	)

bool StdoutThread::InitThread	(	int	bufLen,
		UINT	threadMsg,
		DWORD	parentID
	)

References StdoutRedirect::Init(), m_bufLen, m_msg, m_parentID, m_thread, StdoutRedirect::Start(), and ThreadProc().

Referenced by COperatorConsoleApp::InitOutput().

{
   SECURITY_ATTRIBUTES  security;

   m_bufLen   = bufLen;
   m_msg      = threadMsg;
   m_parentID = parentID;

   Init(m_bufLen);   // open the pipes
   Start();    // start getting output

   //
   // Create the thread.  We set auto delete to false so that we can tell when the thread
   // quits (otherwise Windows would delete the thread when threadProc returns, and its handle
   // would be invalid).
   //
   // In order to *safely* set auto delete, we have to create the thread in suspended mode.  
   // This ensures that the thread won't quit before we set auto delete.
   //
   security.nLength              = sizeof(security);
   security.lpSecurityDescriptor = NULL;
   security.bInheritHandle       = TRUE;

   m_thread = ::AfxBeginThread(ThreadProc, this, 0, 0, CREATE_SUSPENDED, &security);

   if (m_thread != NULL)
   {
      m_thread->m_bAutoDelete = FALSE;
      m_thread->ResumeThread();
   }

   return m_thread != NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void StdoutThread::Quit

(

)

References StdoutRedirect::Close(), m_thread, and StdoutRedirect::Stop().

Referenced by COperatorConsoleApp::Quit().

{
   if (m_thread != NULL)
   {
      Stop();
      Close(); // close the pipe-- this will cause ThreadProc to return (i.e. terminate)
      ::WaitForSingleObject(m_thread->m_hThread, INFINITE); // wait for it to quit
      delete m_thread;                             // delete the thread
      m_thread = NULL;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void StdoutThread::Quit

(

)

UINT __cdecl StdoutThread::ThreadProc ( void *  param )

static

References CriticalCString::Append(), BUF_LEN, FindChar(), StdoutRedirect::GetBuffer(), m_bufLen, m_msg, m_parentID, m_str, and CriticalCString::Set().

Referenced by InitThread().

{
   char        *buf[2];
   StdoutThread   *data = (StdoutThread *)param;
   char        *src, *dst, *ch;
   int            bufIndex;   // tells which buffer to read data into (buf[0] or buf[1])
   int            len;     // the number of characters in the buffer
   int            bytesRead;  // the number of bytes that were just read from the pipe
   int            leftover;   // the number of characters remaining in the buffer after the newline
   int            index;      // the array index of the last newline ('\n') in the buffer


   //
   // Allocate 2 buffers to hold the data read from the pipe
   //
   buf[0] = new char[data->m_bufLen];
   buf[1] = new char[data->m_bufLen];


   if ((buf[0] == NULL) || (buf[1] == NULL))
   {
      data->m_str.Set("Unable to allocate buffers in StdoutThread\n\r");
      ::PostThreadMessage(data->m_parentID, data->m_msg, (WPARAM)0, (LPARAM)0);  // tell the parent thread the data is ready
   }
   else
   {
      memset(buf[0], 0, data->m_bufLen);
      memset(buf[1], 0, data->m_bufLen);

      bufIndex = 0;
      len      = 0;

      do
      {
         //
         // Read all available data (up BUF_LEN bytes) from the pipe.  Note that GetBuffer() will block until
         // data is available or the pipe is closed.  We start reading new data into the end of the buffer.
         //
         ch = buf[bufIndex] + len;
         bytesRead = data->GetBuffer(ch, BUF_LEN);

         if (bytesRead > 0)   // 0 means that the pipe was closed
         {
            //
            // Look for a newline character in the buffer, starting at the end of the buffer
            //
            len += bytesRead;                   // total number of bytes in buf
            index = FindChar(buf[bufIndex], '\n', len);  // find last newline (if any) in buf (-1 means no newline was found)
         
            //
            // If we found a newline, copy the string into the shared data buffer.  It is possible that
            // the string may contain more than one newline (i.e. more that one line of text), but that's
            // okay-- we just want to make sure that we copy complete lines into the destination buffer.
            //
            if (index >= 0)
            {
               //
               // Copy buf[0] to buf[index] (inclusive) into m_str.  If data->m_str was empty before the copy, 
               // post a message to tell the parent thread that data is ready.  If data->m_str wasn't empty
               // that means that the parent thread hasn't gotten around to processing the previous message yet, 
               // so we don't need to post another message.
               //
               // An alternative to this system would be to pass a pointer to the string in PostThreadMessage,
               // but then we would need to have several messages allocated ahead of time.
               //
               if (data->m_str.Append(buf[bufIndex], index+1))
               {
                  ::PostThreadMessage(data->m_parentID, data->m_msg, (WPARAM)0, (LPARAM)0);
               }

               //
               // Copy any leftover characters into the other buffer
               //
               leftover = (len - index) - 1;

               if (leftover)
               {
                  src = buf[bufIndex] + (index+1);
                  dst = buf[bufIndex ^ 1];
                  memcpy(dst, src, leftover);               // if I used memmove() instead, I would only need 1 buffer
                  memset(buf[bufIndex], 0, data->m_bufLen); // this makes debugging easier
                  bufIndex ^= 1;                      // switch to other buffer 0 -> 1,  1-> 0
               }

               len = leftover;
            }
         }
      }
      while (bytesRead > 0);  // 0 means that the pipe has been closed

      delete [] buf[0];
      delete [] buf[1];
   }

   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static UINT __cdecl StdoutThread::ThreadProc ( void *  param )

static

Member Data Documentation

int StdoutThread::m_bufLen

protected

the size of the stdio buffer

Referenced by InitThread(), StdoutThread(), and ThreadProc().

UINT StdoutThread::m_msg

protected

message to send when data has been read

Referenced by InitThread(), StdoutThread(), and ThreadProc().

DWORD StdoutThread::m_parentID

protected

ID of thread to send m_msg to.

Referenced by InitThread(), StdoutThread(), and ThreadProc().

CriticalCString StdoutThread::m_str

protected

this stores the data that was read

Referenced by Get(), and ThreadProc().

CWinThread * StdoutThread::m_thread

protected

pointer to our thread

Referenced by InitThread(), and Quit().

---

The documentation for this class was generated from the following files:

• Documentation/Operator-Console/StdoutThread.h
• Documentation/Operator-Console/StdoutThread.cpp