ProcessFile.hxx

#pragma once
 
// C++
#include <optional>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/proc/pidfd.h>
#include <cosmos/proc/PidFD.hxx>
#include <cosmos/proc/process.hxx>
#include <cosmos/proc/signal.hxx>
#include <cosmos/proc/types.hxx>
 
namespace cosmos {
 
 
class COSMOS_API ProcessFile {
public: // types
 
        enum class OpenFlag : unsigned int {
                NONBLOCK = PIDFD_NONBLOCK 
        };
 
        using OpenFlags = BitMask<OpenFlag>;
 
public: // functions
 
 
        explicit ProcessFile(const ProcessID pid, const OpenFlags flags = OpenFlags{});
 
 
        explicit ProcessFile(const PidFD fd) :
                        m_fd{fd}
        {}
 
        /* non-copyable and move semantics */
 
        ProcessFile(const ProcessFile&) = delete;
        ProcessFile& operator=(const ProcessFile&) = delete;
 
        ProcessFile(ProcessFile &&other) noexcept {
                *this = std::move(other);
        }
 
        ProcessFile& operator=(ProcessFile &&other) noexcept {
                m_fd = other.m_fd;
                other.m_fd.reset();
                return *this;
        }
 
        ~ProcessFile();
 
        bool open() const {
                return m_fd.valid();
        }
 
        void close() {
                m_fd.close();
        }
 
 
        PidFD fd() const { return m_fd; }
 
        void sendSignal(const Signal sig) const {
                signal::send(m_fd, sig);
        }
 
 
        FileDescriptor dupFD(const FileNum targetfd) const;
 
 
        std::optional<ChildData> wait(const WaitFlags flags = WaitFlags{WaitFlag::WAIT_FOR_EXITED}) {
                return proc::wait(m_fd, flags);
        }
 
protected: // data
 
        PidFD m_fd;
};
 
} // end ns