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;

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(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }

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

  constexpr Process(const Process& other) noexcept = delete;

  constexpr Process(Process&& other) noexcept
    : Process(other.release())
  {
  }
 
  constexpr Process(const ProcessRef& other) = delete;
 
  constexpr Process(ProcessRef&& other) = delete;

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

  Process(PropertiesRef props);

  ~Process() { SDL_DestroyProcess(m_resource); }

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

  Process& operator=(const Process& other) = delete;

  constexpr ProcessRaw get() const noexcept { return m_resource; }

  constexpr ProcessRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }

  constexpr auto operator<=>(const Process& other) const noexcept = default;

  constexpr explicit operator bool() const noexcept { return !!m_resource; }

  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 ProcessRef : Process
{
  using Process::Process;

  constexpr ProcessRef(ProcessRaw resource) noexcept
    : Process(resource)
  {
  }

  constexpr ProcessRef(const Process& resource) noexcept
    : Process(resource.get())
  {
  }

  constexpr ProcessRef(Process&& resource) noexcept
    : Process(std::move(resource).release())
  {
  }

  constexpr ProcessRef(const ProcessRef& other) noexcept
    : Process(other.get())
  {
  }

  constexpr ProcessRef(ProcessRef&& other) noexcept
    : Process(other.get())
  {
  }

  ~ProcessRef() { release(); }

  ProcessRef& operator=(const ProcessRef& other) noexcept
  {
    release();
    Process::operator=(Process(other.get()));
    return *this;
  }

  constexpr operator ProcessRaw() const noexcept { return get(); }
};

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)
  : m_resource(SDL_CreateProcess(args, pipe_stdio))
{
}
 
inline Process::Process(PropertiesRef props)
  : m_resource(SDL_CreateProcessWithProperties(props))
{
}

inline Process CreateProcessWithProperties(PropertiesRef 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;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto CREATE_WORKING_DIRECTORY_STRING =
  SDL_PROP_PROCESS_CREATE_WORKING_DIRECTORY_STRING;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
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;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto CREATE_CMDLINE_STRING = SDL_PROP_PROCESS_CREATE_CMDLINE_STRING;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
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(ProcessRef process)
{
  return {CheckError(SDL_GetProcessProperties(process))};
}
 
inline PropertiesRef Process::GetProperties() const
{
  return SDL::GetProcessProperties(m_resource);
}

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 Process::Read(int* exitcode)
{
  return SDL::ReadProcess(m_resource, exitcode);
}

inline IOStreamRef GetProcessInput(ProcessRef process)
{
  return {SDL_GetProcessInput(process)};
}
 
inline IOStreamRef Process::GetInput()
{
  return SDL::GetProcessInput(m_resource);
}

inline IOStreamRef GetProcessOutput(ProcessRef process)
{
  return {SDL_GetProcessOutput(process)};
}
 
inline IOStreamRef Process::GetOutput()
{
  return SDL::GetProcessOutput(m_resource);
}

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

inline bool WaitProcess(ProcessRef 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_ */