ProcessUtils::PipeIO

#include <ProcessUtils.h>

Inheritance diagram for ProcessUtils::PipeIO:

Public Member Functions
	PipeIO (HANDLE handle, HANDLE hEvent, bool processMessages, DWORD timeOut=INFINITE)
	~PipeIO ()
	PFC_DECLARE_EXCEPTION (timeout, exception_io,"Timeout")
size_t	read (void *p_buffer, size_t p_bytes, abort_callback &abort)
size_t	readPass (void *p_buffer, size_t p_bytes, abort_callback &abort)
void	write (const void *p_buffer, size_t p_bytes, abort_callback &abort)

Private Member Functions
void	_cancel (OVERLAPPED &ol)
DWORD	myWait (DWORD count, const HANDLE *handles)

Static Private Member Functions
static void	ProcessPendingMessages ()

Private Attributes
HANDLE	m_event
HANDLE	m_handle
const bool	m_processMessages
const DWORD	m_timeOut

Detailed Description

Definition at line 4 of file ProcessUtils.h.

Constructor & Destructor Documentation

ProcessUtils::PipeIO::PipeIO ( HANDLE  handle, HANDLE  hEvent, bool  processMessages, DWORD  timeOut = INFINITE  )

inline

Definition at line 7 of file ProcessUtils.h.

                                                                                             : m_handle(handle), m_event(hEvent), m_processMessages(processMessages), m_timeOut(timeOut) {
        }

ProcessUtils::PipeIO::~PipeIO ( )

inline

Definition at line 9 of file ProcessUtils.h.

                  {
        }

Member Function Documentation

void ProcessUtils::PipeIO::_cancel ( OVERLAPPED &  ol )

inlineprivate

Definition at line 115 of file ProcessUtils.h.

                                      {
    #if _WIN32_WINNT >= 0x600
            CancelIoEx(m_handle,&ol);
    #else
            CancelIo(m_handle);
    #endif
        }

DWORD ProcessUtils::PipeIO::myWait ( DWORD  count, const HANDLE *  handles  )

inlineprivate

Definition at line 101 of file ProcessUtils.h.

                                                          {
            if (m_processMessages) {
                for(;;) {
                    DWORD state = MsgWaitForMultipleObjects(count, handles, FALSE, m_timeOut, QS_ALLINPUT);
                    if (state == WAIT_OBJECT_0 + count) {
                        ProcessPendingMessages();
                    } else {
                        return state;
                    }
                }
            } else {
                return WaitForMultipleObjects(count, handles, FALSE, m_timeOut);
            }
        }

ProcessUtils::PipeIO::PFC_DECLARE_EXCEPTION	(	timeout	,
		exception_io	,
		"Timeout"
	)

static void ProcessUtils::PipeIO::ProcessPendingMessages ( )

inlinestaticprivate

Definition at line 122 of file ProcessUtils.h.

                                             {
            MSG msg = {};
            while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) DispatchMessage(&msg);
        }

size_t ProcessUtils::PipeIO::read ( void *  p_buffer, size_t  p_bytes, abort_callback &  abort  )

inline

Definition at line 46 of file ProcessUtils.h.

                                                                            {
            uint8_t * ptr = (uint8_t*) p_buffer;
            size_t done = 0;
            while(done < p_bytes) {
                abort.check();
                size_t delta = readPass(ptr + done, p_bytes - done, abort);
                if (delta == 0) break;
                done += delta;
            }
            return done;
        }

size_t ProcessUtils::PipeIO::readPass ( void *  p_buffer, size_t  p_bytes, abort_callback &  abort  )

inline

Definition at line 57 of file ProcessUtils.h.

                                                                                {
            if (p_bytes == 0) return 0;
            OVERLAPPED ol = {};
            ol.hEvent = m_event;
            ResetEvent(m_event);
            DWORD bytesDone;
            SetLastError(NO_ERROR);
            if (ReadFile( m_handle, p_buffer, pfc::downcast_guarded<DWORD>(p_bytes), &bytesDone, &ol)) {
                // succeeded already?
                return bytesDone;
            }

            {
                const DWORD code = GetLastError();
                switch(code) {
                case ERROR_HANDLE_EOF:
                    return 0;
                case ERROR_IO_PENDING:
                    break; // continue
                default:
                    exception_io_from_win32(code);
                };
            }

            const HANDLE handles[] = {m_event, abort.get_abort_event()};
            SetLastError(NO_ERROR);
            DWORD state = myWait(_countof(handles), handles);
            if (state == WAIT_OBJECT_0) {
                SetLastError(NO_ERROR);
                if (!GetOverlappedResult(m_handle,&ol,&bytesDone,TRUE)) {
                    const DWORD code = GetLastError();
                    if (code == ERROR_HANDLE_EOF) bytesDone = 0;
                    else {
                        _cancel(ol);
                        exception_io_from_win32(code);
                    }
                }
                return bytesDone;
            }
            _cancel(ol);
            abort.check();
            throw timeout();
        }

void ProcessUtils::PipeIO::write ( const void *  p_buffer, size_t  p_bytes, abort_callback &  abort  )

inline

Definition at line 12 of file ProcessUtils.h.

                                                                                 {
            if (p_bytes == 0) return;
            OVERLAPPED ol = {};
            ol.hEvent = m_event;
            ResetEvent(m_event);
            DWORD bytesWritten;
            SetLastError(NO_ERROR);
            if (WriteFile( m_handle, p_buffer, pfc::downcast_guarded<DWORD>(p_bytes), &bytesWritten, &ol)) {
                // succeeded already?
                if (bytesWritten != p_bytes) throw exception_io();
                return;
            }
        
            {
                const DWORD code = GetLastError();
                if (code != ERROR_IO_PENDING) exception_io_from_win32(code);
            }
            const HANDLE handles[] = {m_event, abort.get_abort_event()};
            SetLastError(NO_ERROR);
            DWORD state = myWait(_countof(handles), handles);
            if (state == WAIT_OBJECT_0) {
                try {
                    WIN32_IO_OP( GetOverlappedResult(m_handle,&ol,&bytesWritten,TRUE) );
                } catch(...) {
                    _cancel(ol);
                    throw;
                }
                if (bytesWritten != p_bytes) throw exception_io();
                return;
            }
            _cancel(ol);
            abort.check();
            throw timeout();
        }

Field Documentation

HANDLE ProcessUtils::PipeIO::m_event

private

Definition at line 128 of file ProcessUtils.h.

HANDLE ProcessUtils::PipeIO::m_handle

private

Definition at line 127 of file ProcessUtils.h.

const bool ProcessUtils::PipeIO::m_processMessages

private

Definition at line 130 of file ProcessUtils.h.

const DWORD ProcessUtils::PipeIO::m_timeOut

private

Definition at line 129 of file ProcessUtils.h.

---

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

• foobar2000/helpers/ProcessUtils.h