pprocess.h

Go to the documentation of this file.

/*
 *   P::Classes - Portable C++ Application Framework
 *   Copyright (C) 2000-2003 Christian Prochnow <cproch@seculogix.de>
 *
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2 of the License, or (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _pprocess_h_
#define _pprocess_h_

#include <pclasses/pexport.h>
#include <pclasses/pexception.h>
#include <pclasses/piodevice.h>
#include <string>
#include <list>

namespace P {


class PCORE_EXPORT ProcessIO: public IODevice {
  friend class Process;
  public:

    void close() throw(IOError);

    size_t write(const char* buffer, size_t count) throw(IOError);

    size_t read(char* buffer, size_t count) throw(IOError);

    size_t readErr(char* buffer, size_t count) throw(IOError);

  protected:
    ProcessIO(io_handle_t in, io_handle_t out, io_handle_t err) throw();
    ~ProcessIO() throw();

  private:
    io_handle_t m_in;
    io_handle_t m_out;
    io_handle_t m_err;

};



class PCORE_EXPORT ProcessEnv {
  public:

    static void set(const char* name, const char* value);

    static void unset(const char* name);

    static const char* get(const char* name);

  private:
    ProcessEnv();
    ~ProcessEnv();
};



class PCORE_EXPORT Process {
  public:
    enum state_t {
      Stopped,
      Running,
      Stopping
    };

    enum commMode_t {
      NoCommunication = 0,  
      StdIn     = 1,        
      StdOut    = 2,        
      StdErr    = 4,        
      AllOutput = 6,        
      All       = 7         
    };

    typedef std::list<std::string> arg_list;

    Process(const char* path, const arg_list& args = arg_list())
      throw(IOError);

    ~Process() throw();

    inline state_t state() const
    { return m_state; }

    void addArg(const char* arg);

    void clearArgs();

    void setWorkDir(const char* dir);

    inline const std::string& workDir() const
    { return m_dir; }

    void start(commMode_t mode = NoCommunication)
      throw(SystemError,IOError,LogicError);

    void stop() throw(SystemError);

    void kill() throw(SystemError);

    bool tryWait(int& exitCode) throw(SystemError);

    int wait() throw(SystemError);

    static Process* tryWaitAny(int& exitCode) throw(SystemError);

    static Process* waitAny(int& exitCode) throw(SystemError);


    inline ProcessIO* processIO() const throw()
    { return m_procIO; }

  private:
    struct process_handle_t;
    process_handle_t* m_handle;

    ProcessIO*    m_procIO;
    state_t       m_state;
    std::string   m_dir;
    std::string   m_program;
    arg_list      m_args;
};

}

#endif

---