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 ProcessRef;
 
// Forward decl
struct Process;
 
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 : Resource<SDL_Process*>
{
  using Resource::Resource;
 
  ProcessBase(const char* const* args, bool pipe_stdio)
    : Resource(CheckError(SDL_CreateProcess(args, pipe_stdio)))
  {
  }
 
  ProcessBase(PropertiesBase& props)
    : Resource(CheckError(SDL_CreateProcessWithProperties(props.get())))
  {
  }
 
  PropertiesRef GetProperties() const
  {
    return CheckError(SDL_GetProcessProperties(get()));
  }
 
  StringResult Read(int* exitcode = nullptr)
  {
    size_t size = 0;
    auto data = static_cast<char*>(SDL_ReadProcess(get(), &size, exitcode));
    return StringResult(CheckError(data), size);
  }
 
  template<class T>
  OwnArray<T> ReadAs(int* exitcode = nullptr)
  {
    OwnArray<std::byte> data = Read(exitcode);
    if (data.empty()) return {};
    size_t sz = data.size() / sizeof(T);
    return OwnArray{static_cast<T*>(data.release()), sz};
  }
 
  IOStreamRef GetInput() { return SDL_GetProcessInput(get()); }
 
  IOStreamRef GetOutput() { return SDL_GetProcessOutput(get()); }
 
  void Kill(bool force) { CheckError(SDL_KillProcess(get(), force)); }
 
  bool Wait(bool block, int* exitcode)
  {
    return SDL_WaitProcess(get(), block, exitcode);
  }
};
 
struct ProcessRef : ProcessBase
{
  using ProcessBase::ProcessBase;
 
  constexpr ProcessRef(const ProcessRef& other)
    : ProcessBase(other.get())
  {
  }
 
  constexpr ProcessRef(ProcessRef&& other)
    : ProcessBase(other.release())
  {
  }
 
  constexpr ~ProcessRef() = default;
 
  ProcessRef& operator=(ProcessRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Process* newResource = {})
  {
    SDL_DestroyProcess(release(newResource));
  }
};
 
struct Process : ProcessRef
{
  using ProcessRef::ProcessRef;
 
  constexpr explicit Process(SDL_Process* resource = {})
    : ProcessRef(resource)
  {
  }
 
  constexpr Process(const Process& other) = delete;
 
  constexpr Process(Process&& other) = default;
 
  ~Process() { reset(); }
 
  Process& operator=(Process other)
  {
    reset(other.release());
    return *this;
  }
};
 
namespace prop::process {
 
constexpr auto CREATE_ARGS_POINTER = SDL_PROP_PROCESS_CREATE_ARGS_POINTER;
 
constexpr auto CREATE_ENVIRONMENT_POINTER =
  SDL_PROP_PROCESS_CREATE_ENVIRONMENT_POINTER;
 
constexpr auto CREATE_STDIN_NUMBER = SDL_PROP_PROCESS_CREATE_STDIN_NUMBER;
 
constexpr auto CREATE_STDIN_POINTER = SDL_PROP_PROCESS_CREATE_STDIN_POINTER;
 
constexpr auto CREATE_STDOUT_NUMBER = SDL_PROP_PROCESS_CREATE_STDOUT_NUMBER;
 
constexpr auto CREATE_STDOUT_POINTER = SDL_PROP_PROCESS_CREATE_STDOUT_POINTER;
 
constexpr auto CREATE_STDERR_NUMBER = SDL_PROP_PROCESS_CREATE_STDERR_NUMBER;
 
constexpr auto CREATE_STDERR_POINTER = SDL_PROP_PROCESS_CREATE_STDERR_POINTER;
 
constexpr auto CREATE_STDERR_TO_STDOUT_BOOLEAN =
  SDL_PROP_PROCESS_CREATE_STDERR_TO_STDOUT_BOOLEAN;
 
constexpr auto CREATE_BACKGROUND_BOOLEAN =
  SDL_PROP_PROCESS_CREATE_BACKGROUND_BOOLEAN;
 
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
 
} // namespace SDL
 
#endif /* SDL3PP_PROCESS_H_ */