Merge pull request #467 from hurtonm/code_cleanup

Code cleanup

src/dealer.cpp

@@ -49,16 +49,13 @@ void zmq::dealer_t::xattach_pipe (pipe_t *pipe_, bool icanhasall_)
     lb.attach (pipe_);
 }
 
-int zmq::dealer_t::xsend (msg_t *msg_, int flags_)
+int zmq::dealer_t::xsend (msg_t *msg_)
 {
-    return lb.send (msg_, flags_);
+    return lb.send (msg_);
 }
 
-int zmq::dealer_t::xrecv (msg_t *msg_, int flags_)
+int zmq::dealer_t::xrecv (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     return fq.recv (msg_);
 }
 

src/dealer.hpp

@@ -47,8 +47,8 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xsend (zmq::msg_t *msg_, int flags_);
-        int xrecv (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
+        int xrecv (zmq::msg_t *msg_);
         bool xhas_in ();
         bool xhas_out ();
         void xread_activated (zmq::pipe_t *pipe_);

src/dist.cpp

@@ -103,19 +103,19 @@ void zmq::dist_t::activated (pipe_t *pipe_)
     }
 }
 
-int zmq::dist_t::send_to_all (msg_t *msg_, int flags_)
+int zmq::dist_t::send_to_all (msg_t *msg_)
 {
     matching = active;
-    return send_to_matching (msg_, flags_);
+    return send_to_matching (msg_);
 }
 
-int zmq::dist_t::send_to_matching (msg_t *msg_, int flags_)
+int zmq::dist_t::send_to_matching (msg_t *msg_)
 {
     //  Is this end of a multipart message?
     bool msg_more = msg_->flags () & msg_t::more ? true : false;
 
     //  Push the message to matching pipes.
-    distribute (msg_, flags_);
+    distribute (msg_);
 
     //  If mutlipart message is fully sent, activate all the eligible pipes.
     if (!msg_more)
@@ -126,11 +126,8 @@ int zmq::dist_t::send_to_matching (msg_t *msg_, int flags_)
     return 0;
 }
 
-void zmq::dist_t::distribute (msg_t *msg_, int flags_)
+void zmq::dist_t::distribute (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  If there are no matching pipes available, simply drop the message.
     if (matching == 0) {
         int rc = msg_->close ();

src/dist.hpp

@@ -58,10 +58,10 @@ namespace zmq
         void terminated (zmq::pipe_t *pipe_);
 
         //  Send the message to the matching outbound pipes.
-        int send_to_matching (zmq::msg_t *msg_, int flags_);
+        int send_to_matching (zmq::msg_t *msg_);
 
         //  Send the message to all the outbound pipes.
-        int send_to_all (zmq::msg_t *msg_, int flags_);
+        int send_to_all (zmq::msg_t *msg_);
 
         bool has_out ();
 
@@ -72,7 +72,7 @@ namespace zmq
         bool write (zmq::pipe_t *pipe_, zmq::msg_t *msg_);
 
         //  Put the message to all active pipes.
-        void distribute (zmq::msg_t *msg_, int flags_);
+        void distribute (zmq::msg_t *msg_);
 
         //  List of outbound pipes.
         typedef array_t <zmq::pipe_t, 2> pipes_t;

src/lb.cpp

@@ -71,11 +71,8 @@ void zmq::lb_t::activated (pipe_t *pipe_)
     active++;
 }
 
-int zmq::lb_t::send (msg_t *msg_, int flags_)
+int zmq::lb_t::send (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  Drop the message if required. If we are at the end of the message
     //  switch back to non-dropping mode.
     if (dropping) {

src/lb.hpp

@@ -42,7 +42,7 @@ namespace zmq
         void activated (pipe_t *pipe_);
         void terminated (pipe_t *pipe_);
 
-        int send (msg_t *msg_, int flags_);
+        int send (msg_t *msg_);
         bool has_out ();
 
     private:

src/pair.cpp

@@ -69,14 +69,14 @@ void zmq::pair_t::xwrite_activated (pipe_t *)
     //  There's nothing to do here.
 }
 
-int zmq::pair_t::xsend (msg_t *msg_, int flags_)
+int zmq::pair_t::xsend (msg_t *msg_)
 {
     if (!pipe || !pipe->write (msg_)) {
         errno = EAGAIN;
         return -1;
     }
 
-    if (!(flags_ & ZMQ_SNDMORE))
+    if (!(msg_->flags () & msg_t::more))
         pipe->flush ();
 
     //  Detach the original message from the data buffer.
@@ -86,11 +86,8 @@ int zmq::pair_t::xsend (msg_t *msg_, int flags_)
     return 0;
 }
 
-int zmq::pair_t::xrecv (msg_t *msg_, int flags_)
+int zmq::pair_t::xrecv (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  Deallocate old content of the message.
     int rc = msg_->close ();
     errno_assert (rc == 0);

src/pair.hpp

@@ -43,8 +43,8 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xsend (zmq::msg_t *msg_, int flags_);
-        int xrecv (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
+        int xrecv (zmq::msg_t *msg_);
         bool xhas_in ();
         bool xhas_out ();
         void xread_activated (zmq::pipe_t *pipe_);

src/pub.cpp

@@ -32,7 +32,7 @@ zmq::pub_t::~pub_t ()
 {
 }
 
-int zmq::pub_t::xrecv (class msg_t *, int)
+int zmq::pub_t::xrecv (class msg_t *)
 {
     //  Messages cannot be received from PUB socket.
     errno = ENOTSUP;

src/pub.hpp

@@ -40,7 +40,7 @@ namespace zmq
         ~pub_t ();
 
         //  Implementations of virtual functions from socket_base_t.
-        int xrecv (zmq::msg_t *msg_, int flags_);
+        int xrecv (zmq::msg_t *msg_);
         bool xhas_in ();
 
     private:

src/pull.cpp

@@ -53,11 +53,8 @@ void zmq::pull_t::xterminated (pipe_t *pipe_)
     fq.terminated (pipe_);
 }
 
-int zmq::pull_t::xrecv (msg_t *msg_, int flags_)
+int zmq::pull_t::xrecv (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     return fq.recv (msg_);
 }
 

src/pull.hpp

@@ -46,7 +46,7 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xrecv (zmq::msg_t *msg_, int flags_);
+        int xrecv (zmq::msg_t *msg_);
         bool xhas_in ();
         void xread_activated (zmq::pipe_t *pipe_);
         void xterminated (zmq::pipe_t *pipe_);

src/push.cpp

@@ -53,9 +53,9 @@ void zmq::push_t::xterminated (pipe_t *pipe_)
     lb.terminated (pipe_);
 }
 
-int zmq::push_t::xsend (msg_t *msg_, int flags_)
+int zmq::push_t::xsend (msg_t *msg_)
 {
-    return lb.send (msg_, flags_);
+    return lb.send (msg_);
 }
 
 bool zmq::push_t::xhas_out ()

src/push.hpp

@@ -46,7 +46,7 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         bool xhas_out ();
         void xwrite_activated (zmq::pipe_t *pipe_);
         void xterminated (zmq::pipe_t *pipe_);

src/rep.cpp

@@ -35,7 +35,7 @@ zmq::rep_t::~rep_t ()
 {
 }
 
-int zmq::rep_t::xsend (msg_t *msg_, int flags_)
+int zmq::rep_t::xsend (msg_t *msg_)
 {
     //  If we are in the middle of receiving a request, we cannot send reply.
     if (!sending_reply) {
@@ -46,7 +46,7 @@ int zmq::rep_t::xsend (msg_t *msg_, int flags_)
     bool more = msg_->flags () & msg_t::more ? true : false;
 
     //  Push message to the reply pipe.
-    int rc = router_t::xsend (msg_, flags_);
+    int rc = router_t::xsend (msg_);
     if (rc != 0)
         return rc;
 
@@ -57,7 +57,7 @@ int zmq::rep_t::xsend (msg_t *msg_, int flags_)
     return 0;
 }
 
-int zmq::rep_t::xrecv (msg_t *msg_, int flags_)
+int zmq::rep_t::xrecv (msg_t *msg_)
 {
     //  If we are in middle of sending a reply, we cannot receive next request.
     if (sending_reply) {
@@ -69,7 +69,7 @@ int zmq::rep_t::xrecv (msg_t *msg_, int flags_)
     //  to the reply pipe.
     if (request_begins) {
         while (true) {
-            int rc = router_t::xrecv (msg_, flags_);
+            int rc = router_t::xrecv (msg_);
             if (rc != 0)
                 return rc;
 
@@ -78,7 +78,7 @@ int zmq::rep_t::xrecv (msg_t *msg_, int flags_)
                 bool bottom = (msg_->size () == 0);
 
                 //  Push it to the reply pipe.
-                rc = router_t::xsend (msg_, flags_);
+                rc = router_t::xsend (msg_);
                 errno_assert (rc == 0);
 
                 if (bottom)
@@ -95,7 +95,7 @@ int zmq::rep_t::xrecv (msg_t *msg_, int flags_)
     }
 
     //  Get next message part to return to the user.
-    int rc = router_t::xrecv (msg_, flags_);
+    int rc = router_t::xrecv (msg_);
     if (rc != 0)
        return rc;
 

src/rep.hpp

@@ -40,8 +40,8 @@ namespace zmq
         ~rep_t ();
 
         //  Overloads of functions from socket_base_t.
-        int xsend (zmq::msg_t *msg_, int flags_);
-        int xrecv (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
+        int xrecv (zmq::msg_t *msg_);
         bool xhas_in ();
         bool xhas_out ();
 

src/req.cpp

@@ -39,7 +39,7 @@ zmq::req_t::~req_t ()
 {
 }
 
-int zmq::req_t::xsend (msg_t *msg_, int flags_)
+int zmq::req_t::xsend (msg_t *msg_)
 {
     //  If we've sent a request and we still haven't got the reply,
     //  we can't send another request.
@@ -54,7 +54,7 @@ int zmq::req_t::xsend (msg_t *msg_, int flags_)
         int rc = bottom.init ();
         errno_assert (rc == 0);
         bottom.set_flags (msg_t::more);
-        rc = dealer_t::xsend (&bottom, 0);
+        rc = dealer_t::xsend (&bottom);
         if (rc != 0)
             return -1;
         message_begins = false;
@@ -62,7 +62,7 @@ int zmq::req_t::xsend (msg_t *msg_, int flags_)
 
     bool more = msg_->flags () & msg_t::more ? true : false;
 
-    int rc = dealer_t::xsend (msg_, flags_);
+    int rc = dealer_t::xsend (msg_);
     if (rc != 0)
         return rc;
 
@@ -75,7 +75,7 @@ int zmq::req_t::xsend (msg_t *msg_, int flags_)
     return 0;
 }
 
-int zmq::req_t::xrecv (msg_t *msg_, int flags_)
+int zmq::req_t::xrecv (msg_t *msg_)
 {
     //  If request wasn't send, we can't wait for reply.
     if (!receiving_reply) {
@@ -85,14 +85,14 @@ int zmq::req_t::xrecv (msg_t *msg_, int flags_)
 
     //  First part of the reply should be the original request ID.
     if (message_begins) {
-        int rc = dealer_t::xrecv (msg_, flags_);
+        int rc = dealer_t::xrecv (msg_);
         if (rc != 0)
             return rc;
 
         // TODO: This should also close the connection with the peer!
         if (unlikely (!(msg_->flags () & msg_t::more) || msg_->size () != 0)) {
             while (true) {
-                int rc = dealer_t::xrecv (msg_, flags_);
+                int rc = dealer_t::xrecv (msg_);
                 errno_assert (rc == 0);
                 if (!(msg_->flags () & msg_t::more))
                     break;
@@ -106,7 +106,7 @@ int zmq::req_t::xrecv (msg_t *msg_, int flags_)
         message_begins = false;
     }
 
-    int rc = dealer_t::xrecv (msg_, flags_);
+    int rc = dealer_t::xrecv (msg_);
     if (rc != 0)
         return rc;
 

src/req.hpp

@@ -42,8 +42,8 @@ namespace zmq
         ~req_t ();
 
         //  Overloads of functions from socket_base_t.
-        int xsend (zmq::msg_t *msg_, int flags_);
-        int xrecv (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
+        int xrecv (zmq::msg_t *msg_);
         bool xhas_in ();
         bool xhas_out ();
 

src/router.cpp

@@ -140,11 +140,8 @@ void zmq::router_t::xwrite_activated (pipe_t *pipe_)
     it->second.active = true;
 }
 
-int zmq::router_t::xsend (msg_t *msg_, int flags_)
+int zmq::router_t::xsend (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  If this is the first part of the message it's the ID of the
     //  peer to send the message to.
     if (!more_out) {
@@ -227,11 +224,8 @@ int zmq::router_t::xsend (msg_t *msg_, int flags_)
     return 0;
 }
 
-int zmq::router_t::xrecv (msg_t *msg_, int flags_)
+int zmq::router_t::xrecv (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     if (prefetched) {
         if (!identity_sent) {
             int rc = msg_->move (prefetched_id);

src/router.hpp

@@ -50,8 +50,8 @@ namespace zmq
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
         int xsetsockopt (int option_, const void *optval_, size_t optvallen_);
-        int xsend (msg_t *msg_, int flags_);
-        int xrecv (msg_t *msg_, int flags_);
+        int xsend (msg_t *msg_);
+        int xrecv (msg_t *msg_);
         bool xhas_in ();
         bool xhas_out ();
         void xread_activated (zmq::pipe_t *pipe_);

src/socket_base.cpp

@@ -622,7 +622,7 @@ int zmq::socket_base_t::send (msg_t *msg_, int flags_)
         msg_->set_flags (msg_t::more);
 
     //  Try to send the message.
-    rc = xsend (msg_, flags_);
+    rc = xsend (msg_);
     if (rc == 0)
         return 0;
     if (unlikely (errno != EAGAIN))
@@ -644,7 +644,7 @@ int zmq::socket_base_t::send (msg_t *msg_, int flags_)
     while (true) {
         if (unlikely (process_commands (timeout, false) != 0))
             return -1;
-        rc = xsend (msg_, flags_);
+        rc = xsend (msg_);
         if (rc == 0)
             break;
         if (unlikely (errno != EAGAIN))
@@ -689,7 +689,7 @@ int zmq::socket_base_t::recv (msg_t *msg_, int flags_)
     }
 
     //  Get the message.
-    int rc = xrecv (msg_, flags_);
+    int rc = xrecv (msg_);
     if (unlikely (rc != 0 && errno != EAGAIN))
         return -1;
 
@@ -708,7 +708,7 @@ int zmq::socket_base_t::recv (msg_t *msg_, int flags_)
             return -1;
         ticks = 0;
 
-        rc = xrecv (msg_, flags_);
+        rc = xrecv (msg_);
         if (rc < 0)
             return rc;
         extract_flags (msg_);
@@ -726,7 +726,7 @@ int zmq::socket_base_t::recv (msg_t *msg_, int flags_)
     while (true) {
         if (unlikely (process_commands (block ? timeout : 0, false) != 0))
             return -1;
-        rc = xrecv (msg_, flags_);
+        rc = xrecv (msg_);
         if (rc == 0) {
             ticks = 0;
             break;
@@ -886,7 +886,7 @@ bool zmq::socket_base_t::xhas_out ()
     return false;
 }
 
-int zmq::socket_base_t::xsend (msg_t *, int)
+int zmq::socket_base_t::xsend (msg_t *)
 {
     errno = ENOTSUP;
     return -1;
@@ -897,7 +897,7 @@ bool zmq::socket_base_t::xhas_in ()
     return false;
 }
 
-int zmq::socket_base_t::xrecv (msg_t *, int)
+int zmq::socket_base_t::xrecv (msg_t *)
 {
     errno = ENOTSUP;
     return -1;

src/socket_base.hpp

@@ -133,11 +133,11 @@ namespace zmq
 
         //  The default implementation assumes that send is not supported.
         virtual bool xhas_out ();
-        virtual int xsend (zmq::msg_t *msg_, int flags_);
+        virtual int xsend (zmq::msg_t *msg_);
 
         //  The default implementation assumes that recv in not supported.
         virtual bool xhas_in ();
-        virtual int xrecv (zmq::msg_t *msg_, int flags_);
+        virtual int xrecv (zmq::msg_t *msg_);
 
         //  i_pipe_events will be forwarded to these functions.
         virtual void xread_activated (pipe_t *pipe_);

src/sub.cpp

@@ -58,7 +58,7 @@ int zmq::sub_t::xsetsockopt (int option_, const void *optval_,
 
     //  Pass it further on in the stack.
     int err = 0;
-    rc = xsub_t::xsend (&msg, 0);
+    rc = xsub_t::xsend (&msg);
     if (rc != 0)
         err = errno;
     int rc2 = msg.close ();
@@ -68,7 +68,7 @@ int zmq::sub_t::xsetsockopt (int option_, const void *optval_,
     return rc;
 }
 
-int zmq::sub_t::xsend (msg_t *, int)
+int zmq::sub_t::xsend (msg_t *)
 {
     //  Overload the XSUB's send.
     errno = ENOTSUP;

src/sub.hpp

@@ -42,7 +42,7 @@ namespace zmq
     protected:
 
         int xsetsockopt (int option_, const void *optval_, size_t optvallen_);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         bool xhas_out ();
 
     private:

src/xpub.cpp

@@ -115,7 +115,7 @@ void zmq::xpub_t::mark_as_matching (pipe_t *pipe_, void *arg_)
     self->dist.match (pipe_);
 }
 
-int zmq::xpub_t::xsend (msg_t *msg_, int flags_)
+int zmq::xpub_t::xsend (msg_t *msg_)
 {
     bool msg_more = msg_->flags () & msg_t::more ? true : false;
 
@@ -126,7 +126,7 @@ int zmq::xpub_t::xsend (msg_t *msg_, int flags_)
 
     //  Send the message to all the pipes that were marked as matching
     //  in the previous step.
-    int rc = dist.send_to_matching (msg_, flags_);
+    int rc = dist.send_to_matching (msg_);
     if (rc != 0)
         return rc;
 
@@ -145,11 +145,8 @@ bool zmq::xpub_t::xhas_out ()
     return dist.has_out ();
 }
 
-int zmq::xpub_t::xrecv (msg_t *msg_, int flags_)
+int zmq::xpub_t::xrecv (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  If there is at least one 
     if (pending.empty ()) {
         errno = EAGAIN;

src/xpub.hpp

@@ -48,9 +48,9 @@ namespace zmq
 
         //  Implementations of virtual functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_ = false);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         bool xhas_out ();
-        int xrecv (zmq::msg_t *msg_, int flags_);
+        int xrecv (zmq::msg_t *msg_);
         bool xhas_in ();
         void xread_activated (zmq::pipe_t *pipe_);
         void xwrite_activated (zmq::pipe_t *pipe_);

src/xsub.cpp

@@ -82,7 +82,7 @@ void zmq::xsub_t::xhiccuped (pipe_t *pipe_)
     pipe_->flush ();
 }
 
-int zmq::xsub_t::xsend (msg_t *msg_, int flags_)
+int zmq::xsub_t::xsend (msg_t *msg_)
 {
     size_t size = msg_->size ();
     unsigned char *data = (unsigned char*) msg_->data ();
@@ -100,11 +100,11 @@ int zmq::xsub_t::xsend (msg_t *msg_, int flags_)
 	// doing it here as well breaks ZMQ_XPUB_VERBOSE
 	// when there are forwarding devices involved
         subscriptions.add (data + 1, size - 1);
-        return dist.send_to_all (msg_, flags_);
+        return dist.send_to_all (msg_);
     }
     else {
         if (subscriptions.rm (data + 1, size - 1))
-            return dist.send_to_all (msg_, flags_);
+            return dist.send_to_all (msg_);
     }
 
     int rc = msg_->close ();
@@ -121,11 +121,8 @@ bool zmq::xsub_t::xhas_out ()
     return true;
 }
 
-int zmq::xsub_t::xrecv (msg_t *msg_, int flags_)
+int zmq::xsub_t::xrecv (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  If there's already a message prepared by a previous call to zmq_poll,
     //  return it straight ahead.
     if (has_message) {

src/xsub.hpp

@@ -46,9 +46,9 @@ namespace zmq
 
         //  Overloads of functions from socket_base_t.
         void xattach_pipe (zmq::pipe_t *pipe_, bool icanhasall_);
-        int xsend (zmq::msg_t *msg_, int flags_);
+        int xsend (zmq::msg_t *msg_);
         bool xhas_out ();
-        int xrecv (zmq::msg_t *msg_, int flags_);
+        int xrecv (zmq::msg_t *msg_);
         bool xhas_in ();
         void xread_activated (zmq::pipe_t *pipe_);
         void xwrite_activated (zmq::pipe_t *pipe_);