Subprocess.hpp

Go to the documentation of this file.

#pragma once

#ifndef CHI_SUBPROCESS_HPP
#define CHI_SUBPROCESS_HPP

#include "chi/Support/Fwd.hpp"

#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/optional.hpp>

#include <chrono>
#include <string>
#include <vector>

namespace chi {

struct Subprocess {
    using pipeHandler = std::function<void(const char* data, size_t size)>;

    Subprocess(const boost::filesystem::path& pathToExecutable);

    ~Subprocess();


    template <typename ForwardIterator>
    void setArguments(const ForwardIterator& begin, const ForwardIterator& end) {
        // make sure the iterator type is good to go
        static_assert(
            std::is_convertible<typename std::iterator_traits<ForwardIterator>::value_type,
                                std::string>::value,
            "Cannot run setArguments with iterators not convertable to std::string");

        assert(!started() && "Cannot set arguments after start() has been called");

        mArguments = std::vector<std::string>(begin, end);
    }

    template <typename Range>
    void setArguments(Range&& range) {
        setArguments(std::forward<Range>(range).begin(), std::forward<Range>(range).end());
    }

    void setArguments(std::initializer_list<const char*> init) {
        setArguments(init.begin(), init.end());
    }

    const std::vector<std::string>& arguments() const { return mArguments; }

    void attachToStdOut(pipeHandler stdOutHandler) {
        assert(!started() &&
               "Cannot attach a differnt function to stdout after start() has been called");
        mStdOutHandler = stdOutHandler;
    }

    void attachToStdErr(pipeHandler stdErrHandler) {
        assert(!started() &&
               "Cannot attach a differnt function to stderr after start() has been called");
        mStdErrHandler = stdErrHandler;
    }

    void attachStringToStdOut(std::string& str) {
        attachToStdOut([&str](const char* data, size_t size) { str.append(data, size); });
    }

    void attachStringToStdErr(std::string& str) {
        attachToStdErr([&str](const char* data, size_t size) { str.append(data, size); });
    }

    void setWorkingDirectory(boost::filesystem::path newWd) { mWorkingDir = std::move(newWd); }


    Result start();

    bool started() const { return mStarted; }


    Result pushToStdIn(const char* data, size_t size);

    Result closeStdIn();

    bool isStdInClosed() const { return mStdInClosed; }

    void kill();

    void wait();

    int exitCode();

    bool running();


private:
    struct Implementation;
    std::unique_ptr<Implementation> mPimpl;

    std::vector<std::string> mArguments;

    pipeHandler mStdOutHandler;
    pipeHandler mStdErrHandler;

    boost::filesystem::path mExePath;

    boost::filesystem::path mWorkingDir = boost::filesystem::current_path();

    bool mStarted     = false;
    bool mStdInClosed = false;

    boost::optional<int> mExitCode;
};


}  // namespace chi

#endif  // CHI_SUBPROCESS_HPP