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 Process;
 
using ProcessRaw = SDL_Process*;
 
// Forward decl
struct ProcessRef;
 
struct ProcessParam
{
  ProcessRaw value; 
 
  constexpr ProcessParam(ProcessRaw value)
    : value(value)
  {
  }
 
  constexpr ProcessParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const ProcessParam& other) const = default;
 
  constexpr operator ProcessRaw() const { return value; }
};
 
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;
 
class Process
{
  ProcessRaw m_resource = nullptr;
 
public:
  constexpr Process() = default;
 
  constexpr explicit Process(const ProcessRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr Process(const Process& other) = delete;
 
  constexpr Process(Process&& other)
    : Process(other.release())
  {
  }
 
  constexpr Process(const ProcessRef& other) = delete;
 
  constexpr Process(ProcessRef&& other) = delete;
 
  Process(const char* const* args, bool pipe_stdio)
    : m_resource(SDL_CreateProcess(args, pipe_stdio))
  {
  }
 
  Process(PropertiesParam props)
    : m_resource(SDL_CreateProcessWithProperties(props))
  {
  }
 
  ~Process() { SDL_DestroyProcess(m_resource); }
 
  Process& operator=(Process other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr ProcessRaw get() const { return m_resource; }
 
  constexpr ProcessRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Process& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator ProcessParam() const { return {m_resource}; }
 
  void Destroy();
 
  PropertiesRef GetProperties() const;
 
  StringResult Read(int* exitcode = nullptr);
 
  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();
 
  IOStreamRef GetOutput();
 
  void Kill(bool force);
 
  bool Wait(bool block, int* exitcode);
};
 
struct ProcessRef : Process
{
  ProcessRef(ProcessParam resource)
    : Process(resource.value)
  {
  }
 
  ProcessRef(const ProcessRef& other)
    : Process(other.get())
  {
  }
 
  ~ProcessRef() { release(); }
};
 
inline Process CreateProcess(const char* const* args, bool pipe_stdio)
{
  return Process(args, pipe_stdio);
}
 
inline Process CreateProcessWithProperties(PropertiesParam props)
{
  return Process(props);
}
 
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
 
inline PropertiesRef GetProcessProperties(ProcessParam process)
{
  return {CheckError(SDL_GetProcessProperties(process))};
}
 
inline PropertiesRef Process::GetProperties() const
{
  return SDL::GetProcessProperties(m_resource);
}
 
inline StringResult ReadProcess(ProcessParam 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 Process::Read(int* exitcode)
{
  return SDL::ReadProcess(m_resource, exitcode);
}
 
inline IOStreamRef GetProcessInput(ProcessParam process)
{
  return {SDL_GetProcessInput(process)};
}
 
inline IOStreamRef Process::GetInput()
{
  return SDL::GetProcessInput(m_resource);
}
 
inline IOStreamRef GetProcessOutput(ProcessParam process)
{
  return {SDL_GetProcessOutput(process)};
}
 
inline IOStreamRef Process::GetOutput()
{
  return SDL::GetProcessOutput(m_resource);
}
 
inline void KillProcess(ProcessParam process, bool force)
{
  CheckError(SDL_KillProcess(process, force));
}
 
inline void Process::Kill(bool force) { SDL::KillProcess(m_resource, force); }
 
inline bool WaitProcess(ProcessParam process, bool block, int* exitcode)
{
  return SDL_WaitProcess(process, block, exitcode);
}
 
inline bool Process::Wait(bool block, int* exitcode)
{
  return SDL::WaitProcess(m_resource, block, exitcode);
}
 
inline void DestroyProcess(ProcessRaw process) { SDL_DestroyProcess(process); }
 
inline void Process::Destroy() { DestroyProcess(release()); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_PROCESS_H_ */