Reduce amount of stringstream misuse

Author: Tan Li Boon

src/binpickingtask.cpp

@@ -1771,9 +1771,7 @@ void BinPickingTaskResource::_HeartbeatMonitorThread(const double reinitializeti
         socket->set(zmq::sockopt::tcp_keepalive_idle, 2); // the interval between the last data packet sent (simple ACKs are not considered data) and the first keepalive probe; after the connection is marked to need keepalive, this counter is not used any further
         socket->set(zmq::sockopt::tcp_keepalive_intvl, 2); // the interval between subsequential keepalive probes, regardless of what the connection has exchanged in the meantime
         socket->set(zmq::sockopt::tcp_keepalive_cnt, 2); // the number of unacknowledged probes to send before considering the connection dead and notifying the application layer
-        std::stringstream ss; ss << std::setprecision(std::numeric_limits<double>::digits10+1);
-        ss << _heartbeatPort;
-        socket->connect("tcp://"+ _mujinControllerIp+":"+ss.str());
+        socket->connect("tcp://" +  _mujinControllerIp + ":" + std::to_string(_heartbeatPort));
         socket->set(zmq::sockopt::subscribe, "");
 
         zmq::pollitem_t pollitem;
@@ -1882,8 +1880,7 @@ std::string GetValueForSmallestSlaveRequestId(const std::string& heartbeat, cons
 {
 
     rapidjson::Document pt(rapidjson::kObjectType);
-    std::stringstream ss(heartbeat);
-    ParseJson(pt, ss.str());
+    ParseJson(pt, heartbeat);
     try {
         const std::string slavereqid = FindSmallestSlaveRequestId(pt);
         std::string result;
@@ -1905,8 +1902,7 @@ std::string mujinclient::utils::GetScenePkFromHeatbeat(const std::string& heartb
 
 std::string utils::GetSlaveRequestIdFromHeatbeat(const std::string& heartbeat) {
     rapidjson::Document pt;
-    std::stringstream ss(heartbeat);
-    ParseJson(pt, ss.str());
+    ParseJson(pt, heartbeat);
     try {
         static const std::string prefix("slaverequestid-");
         return FindSmallestSlaveRequestId(pt).substr(prefix.length());

src/binpickingtaskzmq.cpp

@@ -271,9 +271,7 @@ void BinPickingTaskZmqResource::_HeartbeatMonitorThread(const double reinitializ
         socket->set(zmq::sockopt::tcp_keepalive_idle, 2); // the interval between the last data packet sent (simple ACKs are not considered data) and the first keepalive probe; after the connection is marked to need keepalive, this counter is not used any further
         socket->set(zmq::sockopt::tcp_keepalive_intvl, 2); // the interval between subsequential keepalive probes, regardless of what the connection has exchanged in the meantime
         socket->set(zmq::sockopt::tcp_keepalive_cnt, 2); // the number of unacknowledged probes to send before considering the connection dead and notifying the application layer
-        std::stringstream ss; ss << std::setprecision(std::numeric_limits<double>::digits10+1);
-        ss << _heartbeatPort;
-        socket->connect("tcp://"+ _mujinControllerIp+":"+ss.str());
+        socket->connect("tcp://" +  _mujinControllerIp + ":" + std::to_string(_heartbeatPort));
         socket->set(zmq::sockopt::subscribe, "");
 
         zmq::pollitem_t pollitem;
@@ -288,8 +286,7 @@ void BinPickingTaskZmqResource::_HeartbeatMonitorThread(const double reinitializ
                 socket->recv(reply);
                 rapidjson::Document pt(rapidjson::kObjectType);
                 try{
-                    std::stringstream replystring_ss(reply.to_string());
-                    ParseJson(pt, replystring_ss.str());
+                    ParseJson(pt, reply.to_string());
                     heartbeat.Parse(pt);
                     {
                         boost::mutex::scoped_lock lock(_mutexTaskState);

src/mujinzmq.cpp

@@ -157,9 +157,7 @@ void ZmqSubscriber::_InitializeSocket(boost::shared_ptr<zmq::context_t> context)
     _socket->set(zmq::sockopt::tcp_keepalive_cnt, 2); // the number of unacknowledged probes to send before considering the connection dead and notifying the application layer
     _socket->set(zmq::sockopt::sndhwm, 2);
     _socket->set(zmq::sockopt::linger, 100); // ms
-    std::ostringstream port_stream;
-    port_stream << "tcp://" << _host << ':' << _port;
-    _socket->connect(port_stream.str());
+    _socket->connect("tcp://" + _host + ':' + std::to_string(_port));
     _socket->set(zmq::sockopt::subscribe, "");
 }
 
@@ -209,9 +207,7 @@ void ZmqPublisher::_InitializeSocket(boost::shared_ptr<zmq::context_t> context)
     _socket->set(zmq::sockopt::tcp_keepalive_cnt, 2); // the number of unacknowledged probes to send before considering the connection dead and notifying the application layer
     _socket->set(zmq::sockopt::sndhwm, 2);
     _socket->set(zmq::sockopt::linger, 100); // ms
-    std::ostringstream port_stream;
-    port_stream << "tcp://*:" << _port;
-    _socket->bind(port_stream.str());
+    _socket->bind("tcp://*:" + std::to_string(_port));
 }
 
 void ZmqPublisher::_DestroySocket()
@@ -277,10 +273,9 @@ std::string ZmqClient::Call(const std::string& msg, const double timeout, const
                 _InitializeSocket(_context);
                 recreatedonce = true;
             } else{
-                std::stringstream ss;
-                ss << "Failed to send request after re-creating socket.";
-                MUJIN_LOG_ERROR(ss.str());
-                throw MujinException(ss.str(), MEC_Failed);
+                std::string ss = "Failed to send request after re-creating socket.";
+                MUJIN_LOG_ERROR(ss);
+                throw MujinException(ss, MEC_Failed);
             }
         }
         if( !!_preemptfn ) {
@@ -289,15 +284,14 @@ std::string ZmqClient::Call(const std::string& msg, const double timeout, const
 
     }
     if (GetMilliTime() - starttime > timeout*1000.0) {
-        std::stringstream ss;
-        ss << "Timed out trying to send request.";
-        MUJIN_LOG_ERROR(ss.str());
+        std::string ss = "Timed out trying to send request.";
+        MUJIN_LOG_ERROR(ss);
         if (msg.length() > 1000) {
             MUJIN_LOG_INFO(msg.substr(0,1000) << "...");
         } else {
             MUJIN_LOG_INFO(msg);
         }
-        throw MujinException(ss.str(), MEC_Timeout);
+        throw MujinException(ss, MEC_Timeout);
     }
     //recv
     recreatedonce = false;
@@ -377,15 +371,14 @@ std::string ZmqClient::Call(const std::string& msg, const double timeout, const
         }
     }
     if (GetMilliTime() - starttime > timeout*1000.0) {
-        std::stringstream ss;
-        ss << "timed out trying to receive request";
-        MUJIN_LOG_ERROR(ss.str());
+        std::string ss = "timed out trying to receive request";
+        MUJIN_LOG_ERROR(ss);
         if (msg.length() > 1000) {
             MUJIN_LOG_INFO(msg.substr(0,1000) << "...");
         } else {
             MUJIN_LOG_INFO(msg);
         }
-        throw MujinException(ss.str(), MEC_Failed);
+        throw MujinException(ss, MEC_Failed);
     }
 
     return "";
@@ -405,12 +398,9 @@ void ZmqClient::_InitializeSocket(boost::shared_ptr<zmq::context_t> context)
     _socket->set(zmq::sockopt::tcp_keepalive_idle, 2); // the interval between the last data packet sent (simple ACKs are not considered data) and the first keepalive probe; after the connection is marked to need keepalive, this counter is not used any further
     _socket->set(zmq::sockopt::tcp_keepalive_intvl, 2); // the interval between subsequential keepalive probes, regardless of what the connection has exchanged in the meantime
     _socket->set(zmq::sockopt::tcp_keepalive_cnt, 2); // the number of unacknowledged probes to send before considering the connection dead and notifying the application layer
-    std::ostringstream port_stream;
-    port_stream << "tcp://" << _host << ':' << _port;
-    std::stringstream ss;
-    ss << "connecting to socket at " << _host << ":" << _port;
-    MUJIN_LOG_INFO(ss.str());
-    _socket->connect(port_stream.str());
+    std::string endpoint = "tcp://" + _host + ':' + std::to_string(_port);
+    MUJIN_LOG_INFO("connecting to socket at " + endpoint);
+    _socket->connect(endpoint);
 }
 
 void ZmqClient::_DestroySocket()
@@ -481,12 +471,9 @@ void ZmqServer::_InitializeSocket(boost::shared_ptr<zmq::context_t> context)
     _pollitem.socket = _socket->operator void*();
     _pollitem.events = ZMQ_POLLIN;
 
-    std::ostringstream endpoint;
-    endpoint << "tcp://*:" << _port;
-    _socket->bind(endpoint.str());
-    std::stringstream ss;
-    ss << "binded to " << endpoint.str();
-    MUJIN_LOG_INFO(ss.str());
+    std::string endpoint = "tcp://*:" + std::to_string(_port);
+    _socket->bind(endpoint);
+    MUJIN_LOG_INFO("binded to " + endpoint);
 }
 
 void ZmqServer::_DestroySocket()