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); }