UT/UT_WritePipe.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_WritePipe.h ( UT Library, C++)
 *
 * COMMENTS:    This is a write pipe which allows you to poll the pipe to see
 *              if the child process has completed.  It works almost exactly
 *              like popen/pclose except for a few things:
 *                      1:  You can easily get the pid of the child
 *                      2:  The close() method has an option to not block
 *                          and return even if the child is running.
 *
 * CAVEATS:     This class does not work for read pipes, but then again, read
 *              pipes don't have the problem of blocking on the child
 *              process...
 */

#ifndef __UT_WritePipe__
#define __UT_WritePipe__

#include "UT_API.h"
#include <sys/types.h>
#include <stdio.h>
#include "UT_Lock.h"
#include "UT_SysClone.h"

class UT_API UT_WritePipe {
public:
     explicit UT_WritePipe(const char *cmd = 0, int rmanproc = 0);

     // If the pipe is open and destructed, the process will be blocked until
     // the child is terminated.
    ~UT_WritePipe();

    FILE        *open(const char *cmd);

    // Close:  Close will return
    //          -1 - Error closing the pipe
    //           0 - Child is still running (only returned if the arg is 0)
    //          >0 - Child is terminated
    // After close is called, it is not safe to write to the pipe anymore
    // (since the file descriptor is closed).  Please use isComplete() to see
    // if the child process has terminated.
    int          close(int wait_for_child_to_terminate = 0);

    // Call this to find out whether it's safe to close (i.e. the child process
    // has terminated).  This can be called before, or after the pipe has been
    // closed.
    int          isComplete(int block=0);

    void         suspend();
    void         restart();
    void         terminate();
    int          isSuspended() const;

    FILE        *getFilePtr()           { return myFilePtr; }

    // If close() fails, you can get the errno of the fail call by calling
    //  this method.  If the child is still running, the error will be
    //  set to EWOULDBLOCK
    int          getErrno() const       { return myErrno; }

    // If close() succeeds, you can get the exit status of the child process by
    // calling the following method.
    int         getStatus() const       { return myExitStatus; }

    // This method will return the child process id.
    pid_t       getPid() const          { return myPid; }

#ifdef WIN32
    void        setRmanProc(int on)     { myRmanProc = on; }
    FILE        *doPOpen( char *cmd );
#endif

private:
    FILE        *myFilePtr;
    int          myErrno;
    int          myExitStatus;
    unsigned     myFlag;
    pid_t        myPid;
#ifdef WIN32
    void        *myHThread;
    void        *myHProcess;
    void        *myPipe;
    int          myRmanProc;
#else
    UT_Lock      myCompleteLock;
#endif
};

#endif

---