SDL3pp_process.h

#ifndef SDL3PP_PROCESS_H_
#define SDL3PP_PROCESS_H_
 
#include <SDL3/SDL_process.h>
#include "SDL3pp_iostream.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {

 
// Forward decl
struct ProcessBase;
 
// Forward decl
struct Process;

using ProcessRaw = SDL_Process*;

using ProcessRef = ResourceRefT<ProcessBase>;

using ProcessIO = SDL_ProcessIO;
 
constexpr ProcessIO PROCESS_STDIO_INHERITED =
  SDL_PROCESS_STDIO_INHERITED; 
 
constexpr ProcessIO PROCESS_STDIO_NULL =
  SDL_PROCESS_STDIO_NULL; 

constexpr ProcessIO PROCESS_STDIO_APP = SDL_PROCESS_STDIO_APP;

constexpr ProcessIO PROCESS_STDIO_REDIRECT = SDL_PROCESS_STDIO_REDIRECT;

struct ProcessBase : ResourceBaseT<ProcessRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  PropertiesRef GetProperties() const;

  StringResult Read(int* exitcode = nullptr);

  template<class T>
  OwnArray<T> ReadAs(int* exitcode = nullptr)
  {
    StringResult data = Read(exitcode);
    if (data.empty()) return {};
    size_t sz = data.size() / sizeof(T);
    return OwnArray{static_cast<T*>(data.release()), sz};
  }

  IOStreamRef GetInput();

  IOStreamRef GetOutput();

  void Kill(bool force);

  bool Wait(bool block, int* exitcode);
};

struct Process : ProcessBase
{
  using ProcessBase::ProcessBase;

  constexpr explicit Process(ProcessRaw resource) noexcept
    : ProcessBase(resource)
  {
  }

  constexpr Process(Process&& other) noexcept
    : Process(other.release())
  {
  }

  Process(const char* const* args, bool pipe_stdio);

  Process(PropertiesRef props);

  ~Process() { SDL_DestroyProcess(get()); }

  constexpr Process& operator=(Process&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline Process CreateProcess(const char* const* args, bool pipe_stdio)
{
  return Process(args, pipe_stdio);
}
 
inline Process::Process(const char* const* args, bool pipe_stdio)
  : Process(SDL_CreateProcess(args, pipe_stdio))
{
}
 
inline Process::Process(PropertiesRef props)
  : Process(SDL_CreateProcessWithProperties(props))
{
}

inline Process CreateProcessWithProperties(PropertiesRef props)
{
  return Process(props);
}

namespace prop::Process::Create {
 
constexpr auto ARGS_POINTER =
  SDL_PROP_PROCESS_CREATE_ARGS_POINTER; 
 
constexpr auto ENVIRONMENT_POINTER =
  SDL_PROP_PROCESS_CREATE_ENVIRONMENT_POINTER; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto WORKING_DIRECTORY_STRING =
  SDL_PROP_PROCESS_CREATE_WORKING_DIRECTORY_STRING; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto STDIN_NUMBER =
  SDL_PROP_PROCESS_CREATE_STDIN_NUMBER; 
 
constexpr auto STDIN_POINTER =
  SDL_PROP_PROCESS_CREATE_STDIN_POINTER; 
 
constexpr auto STDOUT_NUMBER =
  SDL_PROP_PROCESS_CREATE_STDOUT_NUMBER; 
 
constexpr auto STDOUT_POINTER =
  SDL_PROP_PROCESS_CREATE_STDOUT_POINTER; 
 
constexpr auto STDERR_NUMBER =
  SDL_PROP_PROCESS_CREATE_STDERR_NUMBER; 
 
constexpr auto STDERR_POINTER =
  SDL_PROP_PROCESS_CREATE_STDERR_POINTER; 
 
constexpr auto STDERR_TO_STDOUT_BOOLEAN =
  SDL_PROP_PROCESS_CREATE_STDERR_TO_STDOUT_BOOLEAN; 
 
constexpr auto BACKGROUND_BOOLEAN =
  SDL_PROP_PROCESS_CREATE_BACKGROUND_BOOLEAN; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto CMDLINE_STRING =
  SDL_PROP_PROCESS_CREATE_CMDLINE_STRING; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
} // namespace prop::Process::Create

inline PropertiesRef GetProcessProperties(ProcessRef process)
{
  return {CheckError(SDL_GetProcessProperties(process))};
}
 
inline PropertiesRef ProcessBase::GetProperties() const
{
  return SDL::GetProcessProperties(get());
}

namespace prop::Process {
 
constexpr auto PID_NUMBER = SDL_PROP_PROCESS_PID_NUMBER; 
 
constexpr auto STDIN_POINTER =
  SDL_PROP_PROCESS_STDIN_POINTER; 
 
constexpr auto STDOUT_POINTER =
  SDL_PROP_PROCESS_STDOUT_POINTER; 
 
constexpr auto STDERR_POINTER =
  SDL_PROP_PROCESS_STDERR_POINTER; 
 
constexpr auto BACKGROUND_BOOLEAN =
  SDL_PROP_PROCESS_BACKGROUND_BOOLEAN; 
 
} // namespace prop::Process

inline StringResult ReadProcess(ProcessRef process, int* exitcode = nullptr)
{
  size_t size = 0;
  auto data = static_cast<char*>(SDL_ReadProcess(process, &size, exitcode));
  return StringResult(CheckError(data), size);
}
 
inline StringResult ProcessBase::Read(int* exitcode)
{
  return SDL::ReadProcess(get(), exitcode);
}

inline IOStreamRef GetProcessInput(ProcessRef process)
{
  return {SDL_GetProcessInput(process)};
}
 
inline IOStreamRef ProcessBase::GetInput()
{
  return SDL::GetProcessInput(get());
}

inline IOStreamRef GetProcessOutput(ProcessRef process)
{
  return {SDL_GetProcessOutput(process)};
}
 
inline IOStreamRef ProcessBase::GetOutput()
{
  return SDL::GetProcessOutput(get());
}

inline void KillProcess(ProcessRef process, bool force)
{
  CheckError(SDL_KillProcess(process, force));
}
 
inline void ProcessBase::Kill(bool force) { SDL::KillProcess(get(), force); }

inline bool WaitProcess(ProcessRef process, bool block, int* exitcode)
{
  return SDL_WaitProcess(process, block, exitcode);
}
 
inline bool ProcessBase::Wait(bool block, int* exitcode)
{
  return SDL::WaitProcess(get(), block, exitcode);
}

inline void DestroyProcess(ProcessRaw process) { SDL_DestroyProcess(process); }
 
inline void ProcessBase::Destroy() { DestroyProcess(release()); }

 
} // namespace SDL
 
#endif /* SDL3PP_PROCESS_H_ */