Am 09.11.2016 um 23:26 schrieb Gavin Lambert:

On 10/11/2016 09:00, Klemens Morgenstern wrote:

...

That did however allow one additional feature: with the pipe automatically closing, you can now use a part of the asio stuff with bp::spawn.

asio::io_service ios; std::future<std::string> fut; bp::spawn("foo", std_out > fut, ios);

Not sure this is the smartest thing to do, but it could make sense for some simple applications.

That's quite nice, actually -- a large number of applications would just want to pull the complete output from a process, either with no input or with completely provided input. It's probably less common to need to hold an interactive conversation, so having a nice quick syntax that hides the stream/pipe work internally is a pretty good win.

Having said that, is there an inverse of this for providing the complete input? Presumably std_in < std::string(x) can't work, as this would be confused with a filename. (And while wrapping it in a future is possible, it'd be a bit silly.) It's "std_in < asio::buffer(x)", whereby buffer is also pulled into the

Well the problem is the potential deadlock, since you cannot terminate the process if it hangs. But that's a risk conciously taken if you don't store the handle. Makes sense for some processes though. process namespace. And you can also use a future which tells when the write is complete: std::string x; std::future<void> f; bp::spawn("foo", std_in < asio::buffer(x) > f); and yeah, that looks a bit weird, but I couldn't think of a better operator for this.

This sort of thing kinda makes me wish that the originally proposed future_stream survived into Boost or the standard. Though you can simulate one with a composite future (a future that returns a value and a new future); I have an implementation kicking around somewhere. It's not the prettiest of things nor would it be a simple drop-in though, I think.

If there was some facility like that to use with boost.asio (which has a streambuf implementation) you could use it. I could add lazy syntax for a popular use-case. That one currently works asio::streambuf buf; bp::spawn("foo", std_out > buf); std::istream(&buf); //but here I don't know how thread-safe that is, that would be a question for boost.asio.