Process.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_Process_hxx
#define __ccxx_Process_hxx

#include <commonc++/Common.h++>
#include <commonc++/Stream.h++>
#include <commonc++/String.h++>
#include <commonc++/SystemException.h++>

#include <vector>
#include <memory>

#ifdef CCXX_OS_POSIX
#include <sys/types.h>
#include <fcntl.h>
#endif

namespace ccxx {

class COMMONCPP_API ExitStatus
{
  friend class Process;

  public:

  ExitStatus() throw() { }

  ~ExitStatus() throw() { }

  inline int getExitCode() const throw()
  { return(_exitCode); }

  inline int getExitSignal() const throw()
  { return(_exitSignal); }

  inline bool isNormal() const throw()
  { return(_exitedNormally); }

  inline uint64_t getUserTime() const throw()
  { return(_userTime); }

  inline uint64_t getKernelTime() const throw()
  { return(_kernelTime); }

  inline uint_t getMaxRSS() const throw()
  { return(_maxSize); }

  static const int SigAbort;

  static const int SigFloatingPointException;
  static const int SigIllegalInstruction;
  static const int SigKeyboardInterrupt;
  static const int SigSegmentationFault;
  static const int SigTerminationRequest;

  static const int SUCCESS;

  static const int FAILURE;

  private:

  int _exitCode;
  int _exitSignal;
  bool _exitedNormally;
  uint64_t _userTime;
  uint64_t _kernelTime;
  uint_t _maxSize;
};

class COMMONCPP_API Process
{
  public:

  Process(const String &path, const StringVec& args,
          const StringVec& env = StringVec::emptyVec,
          const String &workingDir = ".");

  ~Process() throw();

  void start() throw(SystemException);

  void stop() throw();

  bool kill() throw();

  void setPriority(Priority priority) throw();

  Priority getPriority() const throw();

  bool waitFor(ExitStatus& status) throw();

  inline bool isStarted() const throw()
  { return(_started); }

  inline Stream& getInputStream() throw()
  { return(*_ins); }

  inline Stream& getOutputStream() throw()
  { return(*_outs); }

  inline Stream& getErrorStream() throw()
  { return(*_errs); }

  inline time_ms_t getStartTime() const throw()
  { return(_startTime); }

  static void exit(int status) throw();

  inline static const char *getProgramName() throw()
  { return(_progname.c_str()); }

  static String getExecutablePath() throw(SystemException);

  static String getExecutableDir() throw(SystemException);

  inline static void setProgramName(const char *name) throw()
  { _progname = name; }

  static String getWorkingDir();

  static bool setWorkingDir(const String &path) throw();

  static bool hasConsole() throw();

  static bool getConsoleSize(uint_t *columns, uint_t *rows) throw();

  static void setConsoleTitle(const String &title) throw();

  static ProcessID currentProcessID() throw();

  private:

  String _path;
  String _workingDir;
  bool _started;
  time_ms_t _startTime;
  ProcessHandle _handle;
  StringVec _args;
  StringVec _env;
  Stream* _ins;
  Stream* _outs;
  Stream* _errs;

  static String _progname;

  Process(); // not supported
  CCXX_COPY_DECLS(Process);
};

}; // namespace ccxx

#endif // __ccxx_Process_hxx

/* end of header file */