include/wx/private/streamtempinput.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/private/streamtempinput.h
   3 // Purpose:     defines wxStreamTempInputBuffer which is used by Unix and MSW
   4 //              implementations of wxExecute; this file is only used by the
   5 //              library and never by the user code
   6 // Author:      Vadim Zeitlin
   7 // Modified by: Rob Bresalier
   8 // Created:     2013-05-04
   9 // Copyright:   (c) 2002 Vadim Zeitlin <vadim@wxwindows.org>
  10 // Licence:     wxWindows licence
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 #ifndef _WX_PRIVATE_STREAMTEMPINPUT_H
  14 #define _WX_PRIVATE_STREAMTEMPINPUT_H
  15
  16 #include "wx/private/pipestream.h"
  17
  18 // ----------------------------------------------------------------------------
  19 // wxStreamTempInputBuffer
  20 // ----------------------------------------------------------------------------
  21
  22 /*
  23    wxStreamTempInputBuffer is a hack which we need to solve the problem of
  24    executing a child process synchronously with IO redirecting: when we do
  25    this, the child writes to a pipe we open to it but when the pipe buffer
  26    (which has finite capacity, e.g. commonly just 4Kb) becomes full we have to
  27    read data from it because the child blocks in its write() until then and if
  28    it blocks we are never going to return from wxExecute() so we dead lock.
  29
  30    So here is the fix: we now read the output as soon as it appears into a temp
  31    buffer (wxStreamTempInputBuffer object) and later just stuff it back into
  32    the stream when the process terminates. See supporting code in wxExecute()
  33    itself as well.
  34
  35    Note that this is horribly inefficient for large amounts of output (count
  36    the number of times we copy the data around) and so a better API is badly
  37    needed! However it's not easy to devise a way to do this keeping backwards
  38    compatibility with the existing wxExecute(wxEXEC_SYNC)...
  39 */
  40 class wxStreamTempInputBuffer
  41 {
  42 public:
  43     wxStreamTempInputBuffer()
  44     {
  45         m_stream = NULL;
  46         m_buffer = NULL;
  47         m_size = 0;
  48     }
  49
  50     // call to associate a stream with this buffer, otherwise nothing happens
  51     // at all
  52     void Init(wxPipeInputStream *stream)
  53     {
  54         wxASSERT_MSG( !m_stream, wxS("Can only initialize once") );
  55
  56         m_stream = stream;
  57     }
  58
  59     // check for input on our stream and cache it in our buffer if any
  60     //
  61     // return true if anything was done
  62     bool Update()
  63     {
  64         if ( !m_stream || !m_stream->CanRead() )
  65             return false;
  66
  67         // realloc in blocks of 4Kb: this is the default (and minimal) buffer
  68         // size of the Unix pipes so it should be the optimal step
  69         //
  70         // NB: don't use "static int" in this inline function, some compilers
  71         //     (e.g. IBM xlC) don't like it
  72         enum { incSize = 4096 };
  73
  74         void *buf = realloc(m_buffer, m_size + incSize);
  75         if ( !buf )
  76             return false;
  77
  78         m_buffer = buf;
  79         m_stream->Read((char *)m_buffer + m_size, incSize);
  80         m_size += m_stream->LastRead();
  81
  82         return true;
  83     }
  84
  85     // check if can continue reading from the stream, this is used to disable
  86     // the callback once we can't read anything more
  87     bool Eof() const
  88     {
  89         // If we have no stream, always return true as we can't read any more.
  90         return !m_stream || m_stream->Eof();
  91     }
  92
  93     // read everything remaining until the EOF, this should only be called once
  94     // the child process terminates and we know that no more data is coming
  95     bool ReadAll()
  96     {
  97         while ( !Eof() )
  98         {
  99             if ( !Update() )
 100                 return false;
 101         }
 102
 103         return true;
 104     }
 105
 106     // dtor puts the data buffered during this object lifetime into the
 107     // associated stream
 108     ~wxStreamTempInputBuffer()
 109     {
 110         if ( m_buffer )
 111         {
 112             m_stream->Ungetch(m_buffer, m_size);
 113             free(m_buffer);
 114         }
 115     }
 116
 117     const void *GetBuffer() const { return m_buffer; }
 118
 119     size_t GetSize() const { return m_size; }
 120
 121 private:
 122     // the stream we're buffering, if NULL we don't do anything at all
 123     wxPipeInputStream *m_stream;
 124
 125     // the buffer of size m_size (NULL if m_size == 0)
 126     void *m_buffer;
 127
 128     // the size of the buffer
 129     size_t m_size;
 130
 131     wxDECLARE_NO_COPY_CLASS(wxStreamTempInputBuffer);
 132 };
 133
 134 #endif // _WX_PRIVATE_STREAMTEMPINPUT_H