Problem: tipc_connector_t data members not conforming to naming conventions

Solution: add underscore prefix to data members

src/tipc_connecter.cpp

@@ -60,30 +60,30 @@ zmq::tipc_connecter_t::tipc_connecter_t (class io_thread_t *io_thread_,
                                          bool delayed_start_) :
     own_t (io_thread_, options_),
     io_object_t (io_thread_),
-    addr (addr_),
-    s (retired_fd),
-    handle_valid (false),
-    delayed_start (delayed_start_),
-    timer_started (false),
-    session (session_),
-    current_reconnect_ivl (options.reconnect_ivl)
+    _addr (addr_),
+    _s (retired_fd),
+    _handle_valid (false),
+    _delayed_start (delayed_start_),
+    _timer_started (false),
+    _session (session_),
+    _current_reconnect_ivl (options.reconnect_ivl)
 {
-    zmq_assert (addr);
-    zmq_assert (addr->protocol == "tipc");
-    addr->to_string (endpoint);
-    socket = session->get_socket ();
+    zmq_assert (_addr);
+    zmq_assert (_addr->protocol == "tipc");
+    _addr->to_string (_endpoint);
+    _socket = _session->get_socket ();
 }
 
 zmq::tipc_connecter_t::~tipc_connecter_t ()
 {
-    zmq_assert (!timer_started);
-    zmq_assert (!handle_valid);
-    zmq_assert (s == retired_fd);
+    zmq_assert (!_timer_started);
+    zmq_assert (!_handle_valid);
+    zmq_assert (_s == retired_fd);
 }
 
 void zmq::tipc_connecter_t::process_plug ()
 {
-    if (delayed_start)
+    if (_delayed_start)
         add_reconnect_timer ();
     else
         start_connecting ();
@@ -91,17 +91,17 @@ void zmq::tipc_connecter_t::process_plug ()
 
 void zmq::tipc_connecter_t::process_term (int linger_)
 {
-    if (timer_started) {
+    if (_timer_started) {
         cancel_timer (reconnect_timer_id);
-        timer_started = false;
+        _timer_started = false;
     }
 
-    if (handle_valid) {
-        rm_fd (handle);
-        handle_valid = false;
+    if (_handle_valid) {
+        rm_fd (_handle);
+        _handle_valid = false;
     }
 
-    if (s != retired_fd)
+    if (_s != retired_fd)
         close ();
 
     own_t::process_term (linger_);
@@ -118,8 +118,8 @@ void zmq::tipc_connecter_t::in_event ()
 void zmq::tipc_connecter_t::out_event ()
 {
     fd_t fd = connect ();
-    rm_fd (handle);
-    handle_valid = false;
+    rm_fd (_handle);
+    _handle_valid = false;
 
     //  Handle the error condition by attempt to reconnect.
     if (fd == retired_fd) {
@@ -129,22 +129,22 @@ void zmq::tipc_connecter_t::out_event ()
     }
     //  Create the engine object for this connection.
     stream_engine_t *engine =
-      new (std::nothrow) stream_engine_t (fd, options, endpoint);
+      new (std::nothrow) stream_engine_t (fd, options, _endpoint);
     alloc_assert (engine);
 
     //  Attach the engine to the corresponding session object.
-    send_attach (session, engine);
+    send_attach (_session, engine);
 
     //  Shut the connecter down.
     terminate ();
 
-    socket->event_connected (endpoint, fd);
+    _socket->event_connected (_endpoint, fd);
 }
 
 void zmq::tipc_connecter_t::timer_event (int id_)
 {
     zmq_assert (id_ == reconnect_timer_id);
-    timer_started = false;
+    _timer_started = false;
     start_connecting ();
 }
 
@@ -155,22 +155,22 @@ void zmq::tipc_connecter_t::start_connecting ()
 
     //  Connect may succeed in synchronous manner.
     if (rc == 0) {
-        handle = add_fd (s);
-        handle_valid = true;
+        _handle = add_fd (_s);
+        _handle_valid = true;
         out_event ();
     }
 
     //  Connection establishment may be delayed. Poll for its completion.
     else if (rc == -1 && errno == EINPROGRESS) {
-        handle = add_fd (s);
-        handle_valid = true;
-        set_pollout (handle);
-        socket->event_connect_delayed (endpoint, zmq_errno ());
+        _handle = add_fd (_s);
+        _handle_valid = true;
+        set_pollout (_handle);
+        _socket->event_connect_delayed (_endpoint, zmq_errno ());
     }
 
     //  Handle any other error condition by eventual reconnect.
     else {
-        if (s != retired_fd)
+        if (_s != retired_fd)
             close ();
         add_reconnect_timer ();
     }
@@ -181,8 +181,8 @@ void zmq::tipc_connecter_t::add_reconnect_timer ()
     if (options.reconnect_ivl != -1) {
         int rc_ivl = get_new_reconnect_ivl ();
         add_timer (rc_ivl, reconnect_timer_id);
-        socket->event_connect_retried (endpoint, rc_ivl);
-        timer_started = true;
+        _socket->event_connect_retried (_endpoint, rc_ivl);
+        _timer_started = true;
     }
 }
 
@@ -190,16 +190,16 @@ int zmq::tipc_connecter_t::get_new_reconnect_ivl ()
 {
     //  The new interval is the current interval + random value.
     int this_interval =
-      current_reconnect_ivl + (generate_random () % options.reconnect_ivl);
+      _current_reconnect_ivl + (generate_random () % options.reconnect_ivl);
 
     //  Only change the current reconnect interval  if the maximum reconnect
     //  interval was set and if it's larger than the reconnect interval.
     if (options.reconnect_ivl_max > 0
         && options.reconnect_ivl_max > options.reconnect_ivl) {
         //  Calculate the next interval
-        current_reconnect_ivl = current_reconnect_ivl * 2;
-        if (current_reconnect_ivl >= options.reconnect_ivl_max) {
-            current_reconnect_ivl = options.reconnect_ivl_max;
+        _current_reconnect_ivl = _current_reconnect_ivl * 2;
+        if (_current_reconnect_ivl >= options.reconnect_ivl_max) {
+            _current_reconnect_ivl = options.reconnect_ivl_max;
         }
     }
     return this_interval;
@@ -207,27 +207,27 @@ int zmq::tipc_connecter_t::get_new_reconnect_ivl ()
 
 int zmq::tipc_connecter_t::open ()
 {
-    zmq_assert (s == retired_fd);
+    zmq_assert (_s == retired_fd);
 
     // Cannot connect to random tipc addresses
-    if (addr->resolved.tipc_addr->is_random ()) {
+    if (_addr->resolved.tipc_addr->is_random ()) {
         errno = EINVAL;
         return -1;
     }
     //  Create the socket.
-    s = open_socket (AF_TIPC, SOCK_STREAM, 0);
-    if (s == -1)
+    _s = open_socket (AF_TIPC, SOCK_STREAM, 0);
+    if (_s == -1)
         return -1;
 
     //  Set the non-blocking flag.
-    unblock_socket (s);
+    unblock_socket (_s);
     //  Connect to the remote peer.
 #ifdef ZMQ_HAVE_VXWORKS
     int rc = ::connect (s, (sockaddr *) addr->resolved.tipc_addr->addr (),
                         addr->resolved.tipc_addr->addrlen ());
 #else
-    int rc = ::connect (s, addr->resolved.tipc_addr->addr (),
-                        addr->resolved.tipc_addr->addrlen ());
+    int rc = ::connect (_s, _addr->resolved.tipc_addr->addr (),
+                        _addr->resolved.tipc_addr->addrlen ());
 #endif
     //  Connect was successful immediately.
     if (rc == 0)
@@ -245,11 +245,11 @@ int zmq::tipc_connecter_t::open ()
 
 void zmq::tipc_connecter_t::close ()
 {
-    zmq_assert (s != retired_fd);
-    int rc = ::close (s);
+    zmq_assert (_s != retired_fd);
+    int rc = ::close (_s);
     errno_assert (rc == 0);
-    socket->event_closed (endpoint, s);
-    s = retired_fd;
+    _socket->event_closed (_endpoint, _s);
+    _s = retired_fd;
 }
 
 zmq::fd_t zmq::tipc_connecter_t::connect ()
@@ -262,7 +262,7 @@ zmq::fd_t zmq::tipc_connecter_t::connect ()
 #else
     socklen_t len = sizeof (err);
 #endif
-    int rc = getsockopt (s, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
+    int rc = getsockopt (_s, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
     if (rc == -1)
         err = errno;
     if (err != 0) {
@@ -275,8 +275,8 @@ zmq::fd_t zmq::tipc_connecter_t::connect ()
 
         return retired_fd;
     }
-    fd_t result = s;
-    s = retired_fd;
+    fd_t result = _s;
+    _s = retired_fd;
     return result;
 }
 

src/tipc_connecter.hpp

@@ -87,35 +87,35 @@ class tipc_connecter_t : public own_t, public io_object_t
     fd_t connect ();
 
     //  Address to connect to. Owned by session_base_t.
-    const address_t *addr;
+    const address_t *_addr;
 
     //  Underlying socket.
-    fd_t s;
+    fd_t _s;
 
     //  Handle corresponding to the listening socket.
-    handle_t handle;
+    handle_t _handle;
 
     //  If true file descriptor is registered with the poller and 'handle'
     //  contains valid value.
-    bool handle_valid;
+    bool _handle_valid;
 
     //  If true, connecter is waiting a while before trying to connect.
-    const bool delayed_start;
+    const bool _delayed_start;
 
     //  True iff a timer has been started.
-    bool timer_started;
+    bool _timer_started;
 
     //  Reference to the session we belong to.
-    zmq::session_base_t *session;
+    zmq::session_base_t *_session;
 
     //  Current reconnect ivl, updated for backoff strategy
-    int current_reconnect_ivl;
+    int _current_reconnect_ivl;
 
     // String representation of endpoint to connect to
-    std::string endpoint;
+    std::string _endpoint;
 
     // Socket
-    zmq::socket_base_t *socket;
+    zmq::socket_base_t *_socket;
 
     //  Internal function to return a reconnect backoff delay.
     //  Will modify the current_reconnect_ivl used for next call