Problem: inconsistent naming style for private data members, conflicts with naming of local variables and member functions

Solution: apply and check _lower_case naming style for private data members

src/router.cpp

@@ -38,35 +38,35 @@
 
 zmq::router_t::router_t (class ctx_t *parent_, uint32_t tid_, int sid_) :
     socket_base_t (parent_, tid_, sid_),
-    prefetched (false),
-    routing_id_sent (false),
-    current_in (NULL),
-    terminate_current_in (false),
-    more_in (false),
-    current_out (NULL),
-    more_out (false),
-    next_integral_routing_id (generate_random ()),
-    mandatory (false),
+    _prefetched (false),
+    _routing_id_sent (false),
+    _current_in (NULL),
+    _terminate_current_in (false),
+    _more_in (false),
+    _current_out (NULL),
+    _more_out (false),
+    _next_integral_routing_id (generate_random ()),
+    _mandatory (false),
     //  raw_socket functionality in ROUTER is deprecated
-    raw_socket (false),
-    probe_router (false),
-    handover (false)
+    _raw_socket (false),
+    _probe_router (false),
+    _handover (false)
 {
     options.type = ZMQ_ROUTER;
     options.recv_routing_id = true;
     options.raw_socket = false;
 
-    prefetched_id.init ();
-    prefetched_msg.init ();
+    _prefetched_id.init ();
+    _prefetched_msg.init ();
 }
 
 zmq::router_t::~router_t ()
 {
-    zmq_assert (anonymous_pipes.empty ());
+    zmq_assert (_anonymous_pipes.empty ());
     ;
-    zmq_assert (outpipes.empty ());
-    prefetched_id.close ();
-    prefetched_msg.close ();
+    zmq_assert (_out_pipes.empty ());
+    _prefetched_id.close ();
+    _prefetched_msg.close ();
 }
 
 void zmq::router_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
@@ -75,7 +75,7 @@ void zmq::router_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
 
     zmq_assert (pipe_);
 
-    if (probe_router) {
+    if (_probe_router) {
         msg_t probe_msg;
         int rc = probe_msg.init ();
         errno_assert (rc == 0);
@@ -90,9 +90,9 @@ void zmq::router_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
 
     bool routing_id_ok = identify_peer (pipe_);
     if (routing_id_ok)
-        fq.attach (pipe_);
+        _fq.attach (pipe_);
     else
-        anonymous_pipes.insert (pipe_);
+        _anonymous_pipes.insert (pipe_);
 }
 
 int zmq::router_t::xsetsockopt (int option_,
@@ -116,8 +116,8 @@ int zmq::router_t::xsetsockopt (int option_,
 
         case ZMQ_ROUTER_RAW:
             if (is_int && value >= 0) {
-                raw_socket = (value != 0);
-                if (raw_socket) {
+                _raw_socket = (value != 0);
+                if (_raw_socket) {
                     options.recv_routing_id = false;
                     options.raw_socket = true;
                 }
@@ -127,21 +127,21 @@ int zmq::router_t::xsetsockopt (int option_,
 
         case ZMQ_ROUTER_MANDATORY:
             if (is_int && value >= 0) {
-                mandatory = (value != 0);
+                _mandatory = (value != 0);
                 return 0;
             }
             break;
 
         case ZMQ_PROBE_ROUTER:
             if (is_int && value >= 0) {
-                probe_router = (value != 0);
+                _probe_router = (value != 0);
                 return 0;
             }
             break;
 
         case ZMQ_ROUTER_HANDOVER:
             if (is_int && value >= 0) {
-                handover = (value != 0);
+                _handover = (value != 0);
                 return 0;
             }
             break;
@@ -156,30 +156,30 @@ int zmq::router_t::xsetsockopt (int option_,
 
 void zmq::router_t::xpipe_terminated (pipe_t *pipe_)
 {
-    std::set<pipe_t *>::iterator it = anonymous_pipes.find (pipe_);
-    if (it != anonymous_pipes.end ())
-        anonymous_pipes.erase (it);
+    std::set<pipe_t *>::iterator it = _anonymous_pipes.find (pipe_);
+    if (it != _anonymous_pipes.end ())
+        _anonymous_pipes.erase (it);
     else {
-        outpipes_t::iterator iter = outpipes.find (pipe_->get_routing_id ());
-        zmq_assert (iter != outpipes.end ());
-        outpipes.erase (iter);
-        fq.pipe_terminated (pipe_);
+        outpipes_t::iterator iter = _out_pipes.find (pipe_->get_routing_id ());
+        zmq_assert (iter != _out_pipes.end ());
+        _out_pipes.erase (iter);
+        _fq.pipe_terminated (pipe_);
         pipe_->rollback ();
-        if (pipe_ == current_out)
-            current_out = NULL;
+        if (pipe_ == _current_out)
+            _current_out = NULL;
     }
 }
 
 void zmq::router_t::xread_activated (pipe_t *pipe_)
 {
-    std::set<pipe_t *>::iterator it = anonymous_pipes.find (pipe_);
-    if (it == anonymous_pipes.end ())
-        fq.activated (pipe_);
+    std::set<pipe_t *>::iterator it = _anonymous_pipes.find (pipe_);
+    if (it == _anonymous_pipes.end ())
+        _fq.activated (pipe_);
     else {
         bool routing_id_ok = identify_peer (pipe_);
         if (routing_id_ok) {
-            anonymous_pipes.erase (it);
-            fq.attach (pipe_);
+            _anonymous_pipes.erase (it);
+            _fq.attach (pipe_);
         }
     }
 }
@@ -187,11 +187,11 @@ void zmq::router_t::xread_activated (pipe_t *pipe_)
 void zmq::router_t::xwrite_activated (pipe_t *pipe_)
 {
     outpipes_t::iterator it;
-    for (it = outpipes.begin (); it != outpipes.end (); ++it)
+    for (it = _out_pipes.begin (); it != _out_pipes.end (); ++it)
         if (it->second.pipe == pipe_)
             break;
 
-    zmq_assert (it != outpipes.end ());
+    zmq_assert (it != _out_pipes.end ());
     zmq_assert (!it->second.active);
     it->second.active = true;
 }
@@ -200,34 +200,34 @@ int zmq::router_t::xsend (msg_t *msg_)
 {
     //  If this is the first part of the message it's the ID of the
     //  peer to send the message to.
-    if (!more_out) {
-        zmq_assert (!current_out);
+    if (!_more_out) {
+        zmq_assert (!_current_out);
 
         //  If we have malformed message (prefix with no subsequent message)
         //  then just silently ignore it.
         //  TODO: The connections should be killed instead.
         if (msg_->flags () & msg_t::more) {
-            more_out = true;
+            _more_out = true;
 
             //  Find the pipe associated with the routing id stored in the prefix.
             //  If there's no such pipe just silently ignore the message, unless
             //  router_mandatory is set.
             blob_t routing_id (static_cast<unsigned char *> (msg_->data ()),
                                msg_->size (), zmq::reference_tag_t ());
-            outpipes_t::iterator it = outpipes.find (routing_id);
+            outpipes_t::iterator it = _out_pipes.find (routing_id);
 
-            if (it != outpipes.end ()) {
-                current_out = it->second.pipe;
+            if (it != _out_pipes.end ()) {
+                _current_out = it->second.pipe;
 
                 // Check whether pipe is closed or not
-                if (!current_out->check_write ()) {
+                if (!_current_out->check_write ()) {
                     // Check whether pipe is full or not
-                    bool pipe_full = !current_out->check_hwm ();
+                    bool pipe_full = !_current_out->check_hwm ();
                     it->second.active = false;
-                    current_out = NULL;
+                    _current_out = NULL;
 
-                    if (mandatory) {
-                        more_out = false;
+                    if (_mandatory) {
+                        _more_out = false;
                         if (pipe_full)
                             errno = EAGAIN;
                         else
@@ -235,8 +235,8 @@ int zmq::router_t::xsend (msg_t *msg_)
                         return -1;
                     }
                 }
-            } else if (mandatory) {
-                more_out = false;
+            } else if (_mandatory) {
+                _more_out = false;
                 errno = EHOSTUNREACH;
                 return -1;
             }
@@ -254,36 +254,36 @@ int zmq::router_t::xsend (msg_t *msg_)
         msg_->reset_flags (msg_t::more);
 
     //  Check whether this is the last part of the message.
-    more_out = (msg_->flags () & msg_t::more) != 0;
+    _more_out = (msg_->flags () & msg_t::more) != 0;
 
     //  Push the message into the pipe. If there's no out pipe, just drop it.
-    if (current_out) {
+    if (_current_out) {
         // Close the remote connection if user has asked to do so
         // by sending zero length message.
         // Pending messages in the pipe will be dropped (on receiving term- ack)
-        if (raw_socket && msg_->size () == 0) {
-            current_out->terminate (false);
+        if (_raw_socket && msg_->size () == 0) {
+            _current_out->terminate (false);
             int rc = msg_->close ();
             errno_assert (rc == 0);
             rc = msg_->init ();
             errno_assert (rc == 0);
-            current_out = NULL;
+            _current_out = NULL;
             return 0;
         }
 
-        bool ok = current_out->write (msg_);
+        bool ok = _current_out->write (msg_);
         if (unlikely (!ok)) {
             // Message failed to send - we must close it ourselves.
             int rc = msg_->close ();
             errno_assert (rc == 0);
             // HWM was checked before, so the pipe must be gone. Roll back
             // messages that were piped, for example REP labels.
-            current_out->rollback ();
-            current_out = NULL;
+            _current_out->rollback ();
+            _current_out = NULL;
         } else {
-            if (!more_out) {
-                current_out->flush ();
-                current_out = NULL;
+            if (!_more_out) {
+                _current_out->flush ();
+                _current_out = NULL;
             }
         }
     } else {
@@ -300,36 +300,36 @@ int zmq::router_t::xsend (msg_t *msg_)
 
 int zmq::router_t::xrecv (msg_t *msg_)
 {
-    if (prefetched) {
-        if (!routing_id_sent) {
-            int rc = msg_->move (prefetched_id);
+    if (_prefetched) {
+        if (!_routing_id_sent) {
+            int rc = msg_->move (_prefetched_id);
             errno_assert (rc == 0);
-            routing_id_sent = true;
+            _routing_id_sent = true;
         } else {
-            int rc = msg_->move (prefetched_msg);
+            int rc = msg_->move (_prefetched_msg);
             errno_assert (rc == 0);
-            prefetched = false;
+            _prefetched = false;
         }
-        more_in = (msg_->flags () & msg_t::more) != 0;
+        _more_in = (msg_->flags () & msg_t::more) != 0;
 
-        if (!more_in) {
-            if (terminate_current_in) {
-                current_in->terminate (true);
-                terminate_current_in = false;
+        if (!_more_in) {
+            if (_terminate_current_in) {
+                _current_in->terminate (true);
+                _terminate_current_in = false;
             }
-            current_in = NULL;
+            _current_in = NULL;
         }
         return 0;
     }
 
     pipe_t *pipe = NULL;
-    int rc = fq.recvpipe (msg_, &pipe);
+    int rc = _fq.recvpipe (msg_, &pipe);
 
     //  It's possible that we receive peer's routing id. That happens
     //  after reconnection. The current implementation assumes that
     //  the peer always uses the same routing id.
     while (rc == 0 && msg_->is_routing_id ())
-        rc = fq.recvpipe (msg_, &pipe);
+        rc = _fq.recvpipe (msg_, &pipe);
 
     if (rc != 0)
         return -1;
@@ -337,33 +337,33 @@ int zmq::router_t::xrecv (msg_t *msg_)
     zmq_assert (pipe != NULL);
 
     //  If we are in the middle of reading a message, just return the next part.
-    if (more_in) {
-        more_in = (msg_->flags () & msg_t::more) != 0;
+    if (_more_in) {
+        _more_in = (msg_->flags () & msg_t::more) != 0;
 
-        if (!more_in) {
-            if (terminate_current_in) {
-                current_in->terminate (true);
-                terminate_current_in = false;
+        if (!_more_in) {
+            if (_terminate_current_in) {
+                _current_in->terminate (true);
+                _terminate_current_in = false;
             }
-            current_in = NULL;
+            _current_in = NULL;
         }
     } else {
         //  We are at the beginning of a message.
         //  Keep the message part we have in the prefetch buffer
         //  and return the ID of the peer instead.
-        rc = prefetched_msg.move (*msg_);
+        rc = _prefetched_msg.move (*msg_);
         errno_assert (rc == 0);
-        prefetched = true;
-        current_in = pipe;
+        _prefetched = true;
+        _current_in = pipe;
 
         const blob_t &routing_id = pipe->get_routing_id ();
         rc = msg_->init_size (routing_id.size ());
         errno_assert (rc == 0);
         memcpy (msg_->data (), routing_id.data (), routing_id.size ());
         msg_->set_flags (msg_t::more);
-        if (prefetched_msg.metadata ())
-            msg_->set_metadata (prefetched_msg.metadata ());
-        routing_id_sent = true;
+        if (_prefetched_msg.metadata ())
+            msg_->set_metadata (_prefetched_msg.metadata ());
+        _routing_id_sent = true;
     }
 
     return 0;
@@ -371,10 +371,10 @@ int zmq::router_t::xrecv (msg_t *msg_)
 
 int zmq::router_t::rollback ()
 {
-    if (current_out) {
-        current_out->rollback ();
-        current_out = NULL;
-        more_out = false;
+    if (_current_out) {
+        _current_out->rollback ();
+        _current_out = NULL;
+        _more_out = false;
     }
     return 0;
 }
@@ -383,24 +383,24 @@ bool zmq::router_t::xhas_in ()
 {
     //  If we are in the middle of reading the messages, there are
     //  definitely more parts available.
-    if (more_in)
+    if (_more_in)
         return true;
 
     //  We may already have a message pre-fetched.
-    if (prefetched)
+    if (_prefetched)
         return true;
 
     //  Try to read the next message.
     //  The message, if read, is kept in the pre-fetch buffer.
     pipe_t *pipe = NULL;
-    int rc = fq.recvpipe (&prefetched_msg, &pipe);
+    int rc = _fq.recvpipe (&_prefetched_msg, &pipe);
 
     //  It's possible that we receive peer's routing id. That happens
     //  after reconnection. The current implementation assumes that
     //  the peer always uses the same routing id.
     //  TODO: handle the situation when the peer changes its routing id.
-    while (rc == 0 && prefetched_msg.is_routing_id ())
-        rc = fq.recvpipe (&prefetched_msg, &pipe);
+    while (rc == 0 && _prefetched_msg.is_routing_id ())
+        rc = _fq.recvpipe (&_prefetched_msg, &pipe);
 
     if (rc != 0)
         return false;
@@ -408,14 +408,14 @@ bool zmq::router_t::xhas_in ()
     zmq_assert (pipe != NULL);
 
     const blob_t &routing_id = pipe->get_routing_id ();
-    rc = prefetched_id.init_size (routing_id.size ());
+    rc = _prefetched_id.init_size (routing_id.size ());
     errno_assert (rc == 0);
-    memcpy (prefetched_id.data (), routing_id.data (), routing_id.size ());
-    prefetched_id.set_flags (msg_t::more);
+    memcpy (_prefetched_id.data (), routing_id.data (), routing_id.size ());
+    _prefetched_id.set_flags (msg_t::more);
 
-    prefetched = true;
-    routing_id_sent = false;
-    current_in = pipe;
+    _prefetched = true;
+    _routing_id_sent = false;
+    _current_in = pipe;
 
     return true;
 }
@@ -426,12 +426,12 @@ bool zmq::router_t::xhas_out ()
     //  MANDATORY is set). Whether actual attempt to write succeeds depends
     //  on whitch pipe the message is going to be routed to.
 
-    if (!mandatory)
+    if (!_mandatory)
         return true;
 
     bool has_out = false;
     outpipes_t::iterator it;
-    for (it = outpipes.begin (); it != outpipes.end (); ++it)
+    for (it = _out_pipes.begin (); it != _out_pipes.end (); ++it)
         has_out |= it->second.pipe->check_hwm ();
 
     return has_out;
@@ -439,7 +439,7 @@ bool zmq::router_t::xhas_out ()
 
 const zmq::blob_t &zmq::router_t::get_credential () const
 {
-    return fq.get_credential ();
+    return _fq.get_credential ();
 }
 
 int zmq::router_t::get_peer_state (const void *routing_id_,
@@ -448,13 +448,13 @@ int zmq::router_t::get_peer_state (const void *routing_id_,
     int res = 0;
 
     blob_t routing_id_blob ((unsigned char *) routing_id_, routing_id_size_);
-    outpipes_t::const_iterator it = outpipes.find (routing_id_blob);
-    if (it == outpipes.end ()) {
+    outpipes_t::const_iterator it = _out_pipes.find (routing_id_blob);
+    if (it == _out_pipes.end ()) {
         errno = EHOSTUNREACH;
         return -1;
     }
 
-    const outpipe_t &outpipe = it->second;
+    const out_pipe_t &outpipe = it->second;
     if (outpipe.pipe->check_hwm ())
         res |= ZMQ_POLLOUT;
 
@@ -473,15 +473,15 @@ bool zmq::router_t::identify_peer (pipe_t *pipe_)
         routing_id.set ((unsigned char *) connect_routing_id.c_str (),
                         connect_routing_id.length ());
         connect_routing_id.clear ();
-        outpipes_t::iterator it = outpipes.find (routing_id);
-        if (it != outpipes.end ())
+        outpipes_t::iterator it = _out_pipes.find (routing_id);
+        if (it != _out_pipes.end ())
             zmq_assert (false); //  Not allowed to duplicate an existing rid
     } else if (
       options
         .raw_socket) { //  Always assign an integral routing id for raw-socket
         unsigned char buf[5];
         buf[0] = 0;
-        put_uint32 (buf + 1, next_integral_routing_id++);
+        put_uint32 (buf + 1, _next_integral_routing_id++);
         routing_id.set (buf, sizeof buf);
     } else if (!options.raw_socket) {
         //  Pick up handshake cases and also case where next integral routing id is set
@@ -494,17 +494,17 @@ bool zmq::router_t::identify_peer (pipe_t *pipe_)
             //  Fall back on the auto-generation
             unsigned char buf[5];
             buf[0] = 0;
-            put_uint32 (buf + 1, next_integral_routing_id++);
+            put_uint32 (buf + 1, _next_integral_routing_id++);
             routing_id.set (buf, sizeof buf);
             msg.close ();
         } else {
             routing_id.set (static_cast<unsigned char *> (msg.data ()),
                             msg.size ());
-            outpipes_t::iterator it = outpipes.find (routing_id);
+            outpipes_t::iterator it = _out_pipes.find (routing_id);
             msg.close ();
 
-            if (it != outpipes.end ()) {
-                if (!handover)
+            if (it != _out_pipes.end ()) {
+                if (!_handover)
                     //  Ignore peers with duplicate ID
                     return false;
 
@@ -513,14 +513,14 @@ bool zmq::router_t::identify_peer (pipe_t *pipe_)
                 //  existing pipe so we can terminate it asynchronously.
                 unsigned char buf[5];
                 buf[0] = 0;
-                put_uint32 (buf + 1, next_integral_routing_id++);
+                put_uint32 (buf + 1, _next_integral_routing_id++);
                 blob_t new_routing_id (buf, sizeof buf);
 
                 it->second.pipe->set_router_socket_routing_id (new_routing_id);
-                outpipe_t existing_outpipe = {it->second.pipe,
-                                              it->second.active};
+                out_pipe_t existing_outpipe = {it->second.pipe,
+                                               it->second.active};
 
-                ok = outpipes
+                ok = _out_pipes
                        .ZMQ_MAP_INSERT_OR_EMPLACE (ZMQ_MOVE (new_routing_id),
                                                    existing_outpipe)
                        .second;
@@ -528,10 +528,10 @@ bool zmq::router_t::identify_peer (pipe_t *pipe_)
 
                 //  Remove the existing routing id entry to allow the new
                 //  connection to take the routing id.
-                outpipes.erase (it);
+                _out_pipes.erase (it);
 
-                if (existing_outpipe.pipe == current_in)
-                    terminate_current_in = true;
+                if (existing_outpipe.pipe == _current_in)
+                    _terminate_current_in = true;
                 else
                     existing_outpipe.pipe->terminate (true);
             }
@@ -540,8 +540,8 @@ bool zmq::router_t::identify_peer (pipe_t *pipe_)
 
     pipe_->set_router_socket_routing_id (routing_id);
     //  Add the record into output pipes lookup table
-    outpipe_t outpipe = {pipe_, true};
-    ok = outpipes.ZMQ_MAP_INSERT_OR_EMPLACE (ZMQ_MOVE (routing_id), outpipe)
+    out_pipe_t outpipe = {pipe_, true};
+    ok = _out_pipes.ZMQ_MAP_INSERT_OR_EMPLACE (ZMQ_MOVE (routing_id), outpipe)
            .second;
     zmq_assert (ok);