Process.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  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++/SystemException.h++>
#include <commonc++/String.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() { }

  ~ExitStatus() { }

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

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

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

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

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

  inline uint_t getMaxRSS() const
  { 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();

  void start();

  void stop();

  bool kill();

  void setPriority(Priority priority);

  Priority getPriority() const;

  bool waitFor(ExitStatus& status);

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

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

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

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

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

  static void exit(int status);

  inline static String getProgramName()
  { return(_progname); }

  static String getExecutablePath();

  static String getExecutableDir();

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

  static String getWorkingDir();

  static bool setWorkingDir(const String& path);

  static bool hasConsole();

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

  static void setConsoleTitle(const String& title);

  static ProcessID currentProcessID();

 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