AProcess.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
//
// Created by alex2 on 31.10.2020.
//
 
#pragma once
 
#include <AUI/IO/APath.h>
#include <AUI/Common/AException.h>
#include <AUI/Common/AVector.h>
#include <AUI/Common/AObject.h>
#include <AUI/Common/ASignal.h>
#include <AUI/IO/IInputStream.h>
#include <AUI/IO/IOutputStream.h>
#include <AUI/Thread/AFuture.h>
#include "AUI/Common/IStringable.h"
 
#if AUI_PLATFORM_WIN
#include <AUI/Platform/win32/AWin32EventWait.h>
#include <AUI/Platform/win32/WinIoAsync.h>
#include <windows.h>
#include "Pipe.h"
#else
#include "AUI/Platform/unix/UnixIoAsync.h"
#endif
 
class AChildProcess;

AUI_ENUM_FLAG(ASubProcessExecutionFlags) {
   MERGE_STDOUT_STDERR = 0b001,

   TIE_STDOUT = 0b010,

   TIE_STDERR = 0b100, DEFAULT = 0,

   DETACHED = 0b1000,
};
 
class AProcessException : public AException {
public:
   AProcessException(const AString& message) : AException(message) {}
};

class API_AUI_CORE AProcess : public aui::noncopyable {
public:
   virtual ~AProcess() = default;

   virtual APath getModuleName() = 0;

   virtual APath getPathToExecutable() = 0;

   virtual uint32_t getPid() const noexcept = 0;

   virtual int waitForExitCode() = 0;

   virtual size_t processMemory() const = 0;

   struct ArgSingleString {
       AString arg;
   };

   struct ArgStringList {
       AStringVector list;

       bool win32WrapWhitespaceArgumentsWithQuots = true;
   };

   struct ProcessCreationInfo {
       APath executable;

       std::variant<ArgSingleString, ArgStringList> args;

       APath workDir;
   };

   static _<AChildProcess> create(ProcessCreationInfo args);

   [[deprecated("use AProcess::create instead")]]
   static _<AChildProcess> make(AString applicationFile, AString args = {}, APath workingDirectory = {}) {
       return create(
           { .executable = std::move(applicationFile),
             .args = ArgSingleString { std::move(args) },
             .workDir = std::move(workingDirectory) });
   }

   [[deprecated("use auto process = AProcess::make(); process->run(); process->waitForExitCode()")]]
   static int executeWaitForExit(
       AString applicationFile, AString args = {}, APath workingDirectory = {},
       ASubProcessExecutionFlags flags = ASubProcessExecutionFlags::DEFAULT);
 
#if AUI_PLATFORM_WIN

   static void executeAsAdministrator(
       const AString& applicationFile, const AString& args = {}, const APath& workingDirectory = {});
 
#endif

   static AVector<_<AProcess>> all();

   static _<AProcess> self();

   static _<AProcess> findAnotherSelfInstance(const AString& yourProjectName);

   static _<AProcess> fromPid(uint32_t pid);
 
   void kill() const noexcept;
};

class API_AUI_CORE AChildProcess : public AProcess, public AObject, public IStringable {
   friend class AProcess;
 
public:
   ~AChildProcess();
 
   [[nodiscard]]
   const auto& getApplicationFile() const {
       return mInfo.executable;
   }
 
   [[nodiscard]]
   const auto& getArgs() const {
       return mInfo.args;
   }
 
   [[nodiscard]]
   const auto& getWorkingDirectory() const {
       return mInfo.workDir;
   }
 
   APath getPathToExecutable() override {
       return getApplicationFile();
   }
 
   [[nodiscard]]
   AOptional<int> exitCodeNonBlocking() const noexcept {
       if (mExitCode.hasValue()) {
           return *mExitCode;
       }
       return std::nullopt;
   }
 
   [[nodiscard]]
   bool isFinished() const noexcept {
       return mExitCode.hasValue();
   }

   void run(ASubProcessExecutionFlags flags = ASubProcessExecutionFlags::DEFAULT);

   int waitForExitCode() override;
 
   uint32_t getPid() const noexcept override;
 
   size_t processMemory() const override;
 
   APath getModuleName() override;
 
   [[nodiscard]]
   const _<IOutputStream>& getStdInStream() const {
       return mStdInStream;
   }
   AString toString() const override;
 
signals:
   emits<> finished;
   emits<AByteBuffer> stdOut;
   emits<AByteBuffer> stdErr;
 
private:
   AChildProcess() = default;
   ProcessCreationInfo mInfo;
 
   _<IOutputStream> mStdInStream;
 
 
   AFuture<int> mExitCode;
#if AUI_PLATFORM_WIN
   PROCESS_INFORMATION mProcessInformation;
   AWin32EventWait mExitEvent;
   WinIoAsync mStdoutAsync;
#else
   pid_t mPid;
   _<AThread> mWatchdog;
   UnixIoAsync mStdoutAsync;
#endif
};

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.