+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/private/streamtempinput.h
+// Purpose: defines wxStreamTempInputBuffer which is used by Unix and MSW
+// implementations of wxExecute; this file is only used by the
+// library and never by the user code
+// Author: Vadim Zeitlin
+// Modified by: Rob Bresalier
+// Created: 2013-05-04
+// RCS-ID: $Id$
+// Copyright: (c) 2002 Vadim Zeitlin <vadim@wxwindows.org>
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_PRIVATE_STREAMTEMPINPUT_H
+#define _WX_PRIVATE_STREAMTEMPINPUT_H
+
+#include "wx/private/pipestream.h"
+
+// ----------------------------------------------------------------------------
+// wxStreamTempInputBuffer
+// ----------------------------------------------------------------------------
+
+/*
+ wxStreamTempInputBuffer is a hack which we need to solve the problem of
+ executing a child process synchronously with IO redirecting: when we do
+ this, the child writes to a pipe we open to it but when the pipe buffer
+ (which has finite capacity, e.g. commonly just 4Kb) becomes full we have to
+ read data from it because the child blocks in its write() until then and if
+ it blocks we are never going to return from wxExecute() so we dead lock.
+
+ So here is the fix: we now read the output as soon as it appears into a temp
+ buffer (wxStreamTempInputBuffer object) and later just stuff it back into
+ the stream when the process terminates. See supporting code in wxExecute()
+ itself as well.
+
+ Note that this is horribly inefficient for large amounts of output (count
+ the number of times we copy the data around) and so a better API is badly
+ needed! However it's not easy to devise a way to do this keeping backwards
+ compatibility with the existing wxExecute(wxEXEC_SYNC)...
+*/
+class wxStreamTempInputBuffer
+{
+public:
+ wxStreamTempInputBuffer()
+ {
+ m_stream = NULL;
+ m_buffer = NULL;
+ m_size = 0;
+ }
+
+ // call to associate a stream with this buffer, otherwise nothing happens
+ // at all
+ void Init(wxPipeInputStream *stream)
+ {
+ wxASSERT_MSG( !m_stream, wxS("Can only initialize once") );
+
+ m_stream = stream;
+ }
+
+ // check for input on our stream and cache it in our buffer if any
+ //
+ // return true if anything was done
+ bool Update()
+ {
+ if ( !m_stream || !m_stream->CanRead() )
+ return false;
+
+ // realloc in blocks of 4Kb: this is the default (and minimal) buffer
+ // size of the Unix pipes so it should be the optimal step
+ //
+ // NB: don't use "static int" in this inline function, some compilers
+ // (e.g. IBM xlC) don't like it
+ enum { incSize = 4096 };
+
+ void *buf = realloc(m_buffer, m_size + incSize);
+ if ( !buf )
+ return false;
+
+ m_buffer = buf;
+ m_stream->Read((char *)m_buffer + m_size, incSize);
+ m_size += m_stream->LastRead();
+
+ return true;
+ }
+
+ // check if can continue reading from the stream, this is used to disable
+ // the callback once we can't read anything more
+ bool Eof() const
+ {
+ // If we have no stream, always return true as we can't read any more.
+ return !m_stream || m_stream->Eof();
+ }
+
+ // dtor puts the data buffered during this object lifetime into the
+ // associated stream
+ ~wxStreamTempInputBuffer()
+ {
+ if ( m_buffer )
+ {
+ m_stream->Ungetch(m_buffer, m_size);
+ free(m_buffer);
+ }
+ }
+
+ const void *GetBuffer() const { return m_buffer; }
+
+ size_t GetSize() const { return m_size; }
+
+private:
+ // the stream we're buffering, if NULL we don't do anything at all
+ wxPipeInputStream *m_stream;
+
+ // the buffer of size m_size (NULL if m_size == 0)
+ void *m_buffer;
+
+ // the size of the buffer
+ size_t m_size;
+
+ wxDECLARE_NO_COPY_CLASS(wxStreamTempInputBuffer);
+};
+
+#endif // _WX_PRIVATE_STREAMTEMPINPUT_H
projects / wxWidgets.git / commitdiff
