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 ProcessRef;
 
// Forward decl
struct Process;
 
using ProcessShared = ResourceShared<Process>;
 
using ProcessWeak = ResourceWeak<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 ProcessRef : Resource<SDL_Process*>
{
  using Resource::Resource;
 
  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);
  }
 
  static void reset(SDL_Process* resource) { SDL_DestroyProcess(resource); }
};
 
struct Process : ResourceUnique<ProcessRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Process Create(const char* const* args, bool pipe_stdio)
  {
    return Process(SDL_CreateProcess(args, pipe_stdio));
  }
 
  static Process CreateWithProperties(PropertiesRef props)
  {
    return Process(SDL_CreateProcessWithProperties(props));
  }
 
  void Destroy() { reset(); }
  ProcessShared share();
 
};
 
 
inline ProcessShared Process::share()
{
  return ProcessShared(std::move(*this));
}
 
struct ProcessUnsafe : ResourceUnsafe<ProcessRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit ProcessUnsafe(Process&& other)
    : ProcessUnsafe(other.release())
  {
  }
};
 
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_ */