FM / posix

/usr/include/boost/process/detail/posix/

/usr/include/boost/process/detail/posix

Name	Size	Mode	Actions
asio_fwd.hpp	1342	0644	edit dl rm
async_handler.hpp	1187	0644	edit dl rm
async_in.hpp	3541	0644	edit dl rm
async_out.hpp	5794	0644	edit dl rm
async_pipe.hpp	11386	0644	edit dl rm
basic_cmd.hpp	4551	0644	edit dl rm
basic_pipe.hpp	5660	0644	edit dl rm
child_handle.hpp	1432	0644	edit dl rm
close_in.hpp	1053	0644	edit dl rm
close_out.hpp	1735	0644	edit dl rm
cmd.hpp	2531	0644	edit dl rm
compare_handles.hpp	1029	0644	edit dl rm
environment.hpp	9960	0644	edit dl rm
env_init.hpp	979	0644	edit dl rm
exe.hpp	569	0644	edit dl rm
executor.hpp	15541	0644	edit dl rm
fd.hpp	2621	0644	edit dl rm
file_descriptor.hpp	1884	0644	edit dl rm
file_in.hpp	1407	0644	edit dl rm
file_out.hpp	2198	0644	edit dl rm
group_handle.hpp	2068	0644	edit dl rm
group_ref.hpp	1088	0644	edit dl rm
handler.hpp	1739	0644	edit dl rm
handles.hpp	3945	0644	edit dl rm
io_context_ref.hpp	4036	0644	edit dl rm
is_running.hpp	2304	0644	edit dl rm
null_in.hpp	1305	0644	edit dl rm
null_out.hpp	2089	0644	edit dl rm
on_exit.hpp	1001	0644	edit dl rm
pipe_in.hpp	2375	0644	edit dl rm
pipe_out.hpp	3091	0644	edit dl rm
search_path.hpp	1218	0644	edit dl rm
shell_path.hpp	878	0644	edit dl rm
sigchld_service.hpp	4102	0644	edit dl rm
signal.hpp	1898	0644	edit dl rm
start_dir.hpp	1093	0644	edit dl rm
terminate.hpp	1199	0644	edit dl rm
use_vfork.hpp	781	0644	edit dl rm
wait_for_exit.hpp	6689	0644	edit dl rm
wait_group.hpp	3423	0644	edit dl rm

Edit: /usr/include/boost/process/detail/posix/io_context_ref.hpp (4036B)

// Copyright (c) 2016 Klemens D. Morgenstern
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_PROCESS_POSIX_IO_CONTEXT_REF_HPP_
#define BOOST_PROCESS_POSIX_IO_CONTEXT_REF_HPP_

#include <boost/process/detail/posix/handler.hpp>
#include <boost/process/detail/posix/async_handler.hpp>
#include <boost/asio/io_context.hpp>

#include <boost/fusion/algorithm/iteration/for_each.hpp>
#include <boost/fusion/algorithm/transformation/filter_if.hpp>
#include <boost/fusion/algorithm/transformation/transform.hpp>
#include <boost/fusion/view/transform_view.hpp>
#include <boost/fusion/container/vector/convert.hpp>

#include <boost/process/detail/posix/sigchld_service.hpp>
#include <boost/process/detail/posix/is_running.hpp>

#include <functional>
#include <type_traits>
#include <memory>
#include <vector>
#include <sys/wait.h>

namespace boost { namespace process { namespace detail { namespace posix {

template<typename Executor>
struct on_exit_handler_transformer
{
    Executor & exec;
    on_exit_handler_transformer(Executor & exec) : exec(exec) {}
    template<typename Sig>
    struct result;

template<typename T>
    struct result<on_exit_handler_transformer<Executor>(T&)>
    {
        typedef typename T::on_exit_handler_t type;
    };

template<typename T>
    auto operator()(T& t) const -> typename T::on_exit_handler_t
    {
        return t.on_exit_handler(exec);
    }
};

template<typename Executor>
struct async_handler_collector
{
    Executor & exec;
    std::vector<std::function<void(int, const std::error_code & ec)>> &handlers;

async_handler_collector(Executor & exec,
            std::vector<std::function<void(int, const std::error_code & ec)>> &handlers)
                : exec(exec), handlers(handlers) {}

template<typename T>
    void operator()(T & t) const
    {
        handlers.push_back(t.on_exit_handler(exec));
    }
};

//Also set's up waiting for the exit, so it can close async stuff.
struct io_context_ref : handler_base_ext
{
    io_context_ref(boost::asio::io_context & ios) : ios(ios)
    {

}
    boost::asio::io_context &get() {return ios;};
    
    template <class Executor>
    void on_success(Executor& exec)
    {
        ios.notify_fork(boost::asio::io_context::fork_parent);
        //must be on the heap so I can move it into the lambda.
        auto asyncs = boost::fusion::filter_if<
                        is_async_handler<
                        typename std::remove_reference< boost::mpl::_ > ::type
                        >>(exec.seq);

//ok, check if there are actually any.
        if (boost::fusion::empty(asyncs))
            return;

std::vector<std::function<void(int, const std::error_code & ec)>> funcs;
        funcs.reserve(boost::fusion::size(asyncs));
        boost::fusion::for_each(asyncs, async_handler_collector<Executor>(exec, funcs));

auto & es = exec.exit_status;

auto wh = [funcs, es](int val, const std::error_code & ec)
                {
                    es->store(val);
                    for (auto & func : funcs)
                        func(::boost::process::detail::posix::eval_exit_status(val), ec);
                };

sigchld_service.async_wait(exec.pid, std::move(wh));
    }

template<typename Executor>
    void on_setup (Executor &) const {/*ios.notify_fork(boost::asio::io_context::fork_prepare);*/}

template<typename Executor>
    void on_exec_setup  (Executor &) const {/*ios.notify_fork(boost::asio::io_context::fork_child);*/}

template <class Executor>
    void on_error(Executor&, const std::error_code &) const {/*ios.notify_fork(boost::asio::io_context::fork_parent);*/}

private:
    boost::asio::io_context &ios;
    boost::process::detail::posix::sigchld_service &sigchld_service = boost::asio::use_service<boost::process::detail::posix::sigchld_service>(ios);
};

}}}}

#endif /* BOOST_PROCESS_WINDOWS_IO_CONTEXT_REF_HPP_ */

cmd: