void zmq::pipe_t::terminate (bool delay_)
{
// Overload the value specified at pipe creation.
delay = delay_;
// If terminate was already called, we can ignore the duplicate invocation.
if (state == term_req_sent1 || state == term_req_sent2) {
return;
}
// If the pipe is in the final phase of async termination, it's going to
// closed anyway. No need to do anything special here.
else if (state == term_ack_sent) {
return;
}
// The simple sync termination case. Ask the peer to terminate and wait
// for the ack.
else if (state == active) {
send_pipe_term (peer);
state = term_req_sent1;
}
// There are still pending messages available, but the user calls
// 'terminate'. We can act as if all the pending messages were read.
else if (state == waiting_for_delimiter && !delay) {
// Drop any unfinished outbound messages.
rollback ();
outpipe = NULL;
send_pipe_term_ack (peer);
state = term_ack_sent;
}
// If there are pending messages still available, do nothing.
else if (state == waiting_for_delimiter) {
}
// We've already got delimiter, but not term command yet. We can ignore
// the delimiter and ack synchronously terminate as if we were in
// active state.
else if (state == delimiter_received) {
send_pipe_term (peer);
state = term_req_sent1;
}
// There are no other states.
else {
zmq_assert (false);
}
// Stop outbound flow of messages.
out_active = false;
if (outpipe) {
// Drop any unfinished outbound messages.
rollback ();
// Write the delimiter into the pipe. Note that watermarks are not
// checked; thus the delimiter can be written even when the pipe is full.
msg_t msg;
msg.init_delimiter ();
outpipe->write (msg, false);
flush ();
}
}
void zmq::reader_t::terminate ()
{
// If termination was already started by the peer, do nothing.
if (terminating)
return;
active = false;
terminating = true;
send_pipe_term (writer);
}
void zmq::reader_t::term ()
{
endpoint = NULL;
send_pipe_term (peer);
}
