Minor cleanups

src/pipe.cpp

@@ -340,7 +340,7 @@ void zmq::pipe_t::terminate (bool delay_)
     //  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 == 0) {
+    if (state == waiting_for_delimiter && !delay) {
         outpipe = NULL;
         send_pipe_term_ack (peer);
         state = term_ack_sent;

src/plain_mechanism.cpp

@@ -110,7 +110,6 @@ int zmq::plain_mechanism_t::process_handshake_message (msg_t *msg_)
     return 0;
 }
 
-
 bool zmq::plain_mechanism_t::is_handshake_complete () const
 {
     return state == ready;
@@ -125,7 +124,7 @@ int zmq::plain_mechanism_t::hello_command (msg_t *msg_) const
     const std::string password = options.plain_password;
     zmq_assert (password.length () < 256);
 
-    const size_t command_size = 8 + 1 + username.length () 
+    const size_t command_size = 8 + 1 + username.length ()
                                   + 1 + password.length ();
 
     const int rc = msg_->init_size (command_size);
@@ -134,11 +133,11 @@ int zmq::plain_mechanism_t::hello_command (msg_t *msg_) const
     unsigned char *ptr = static_cast <unsigned char *> (msg_->data ());
     memcpy (ptr, "HELLO   ", 8);
     ptr += 8;
-    
+
     *ptr++ = static_cast <unsigned char> (username.length ());
     memcpy (ptr, username.c_str (), username.length ());
     ptr += username.length ();
-    
+
     *ptr++ = static_cast <unsigned char> (password.length ());
     memcpy (ptr, password.c_str (), password.length ());
     ptr += password.length ();
@@ -163,7 +162,7 @@ int zmq::plain_mechanism_t::process_hello_command (msg_t *msg_)
         errno = EPROTO;
         return -1;
     }
-    size_t username_length = static_cast <size_t> (*ptr++);
+    const size_t username_length = static_cast <size_t> (*ptr++);
     bytes_left -= 1;
 
     if (bytes_left < username_length) {
@@ -178,7 +177,7 @@ int zmq::plain_mechanism_t::process_hello_command (msg_t *msg_)
         errno = EPROTO;
         return -1;
     }
-    size_t password_length = static_cast <size_t> (*ptr++);
+    const size_t password_length = static_cast <size_t> (*ptr++);
     bytes_left -= 1;
 
     if (bytes_left < password_length) {
@@ -316,19 +315,19 @@ int zmq::plain_mechanism_t::parse_property_list (const unsigned char *ptr,
         bytes_left -= 1;
         if (bytes_left < name_length)
             break;
-        
+
         const std::string name = std::string ((const char *) ptr, name_length);
         ptr += name_length;
         bytes_left -= name_length;
         if (bytes_left < 4)
             break;
-        
+
         const size_t value_length = static_cast <size_t> (get_uint32 (ptr));
         ptr += 4;
         bytes_left -= 4;
         if (bytes_left < value_length)
             break;
-        
+
         const unsigned char * const value = ptr;
         ptr += value_length;
         bytes_left -= value_length;

src/session_base.cpp

@@ -217,9 +217,9 @@ void zmq::session_base_t::pipe_terminated (pipe_t *pipe_)
         terminate ();
     }
 
-    // If we are waiting for pending messages to be sent, at this point
-    // we are sure that there will be no more messages and we can proceed
-    // with termination safely.
+    //  If we are waiting for pending messages to be sent, at this point
+    //  we are sure that there will be no more messages and we can proceed
+    //  with termination safely.
     if (pending && !pipe && terminating_pipes.empty ())
         proceed_with_term ();
 }
@@ -349,7 +349,7 @@ void zmq::session_base_t::process_term (int linger_)
 
 void zmq::session_base_t::proceed_with_term ()
 {
-    //  The pending phase have just ended.
+    //  The pending phase has just ended.
     pending = false;
 
     //  Continue with standard termination.

src/session_base.hpp

@@ -108,9 +108,9 @@ namespace zmq
 
         //  Pipe connecting the session to its socket.
         zmq::pipe_t *pipe;
-        
+
         //  This set is added to with pipes we are disconnecting, but haven't yet completed
-        std::set<pipe_t *> terminating_pipes;
+        std::set <pipe_t *> terminating_pipes;
 
         //  This flag is true if the remainder of the message being processed
         //  is still in the in pipe.