Fix signed-unsigned comparison warnings, plus lots of other cleanups.
Change-Id: I09a5c0e97dd40c6f321948e2304883e53aafe0d4
diff --git a/src/ndn-traffic-client.cpp b/src/ndn-traffic-client.cpp
index 2e1b910..379ae96 100644
--- a/src/ndn-traffic-client.cpp
+++ b/src/ndn-traffic-client.cpp
@@ -1,21 +1,33 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
/**
- * Copyright (C) 2014 University of Arizona.
+ * Copyright (C) 2014-2015 University of Arizona.
*
- * GNU 3.0 License, see the LICENSE file for more information
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Author: Jerald Paul Abraham <jeraldabraham@email.arizona.edu>
*/
+#include <cctype>
+#include <cstdlib>
#include <fstream>
-#include <sstream>
#include <string>
+#include <unistd.h>
#include <vector>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/filesystem.hpp>
-#include <boost/lexical_cast.hpp>
#include <boost/noncopyable.hpp>
#include <ndn-cxx/exclude.hpp>
@@ -29,11 +41,11 @@
class NdnTrafficClient : boost::noncopyable
{
public:
-
explicit
- NdnTrafficClient(char* programName)
+ NdnTrafficClient(const char* programName)
: m_programName(programName)
, m_logger("NdnTrafficClient")
+ , m_instanceId(std::to_string(std::rand()))
, m_hasError(false)
, m_hasQuietLogging(false)
, m_interestInterval(getDefaultInterestInterval())
@@ -46,7 +58,6 @@
, m_maximumInterestRoundTripTime(0)
, m_totalInterestRoundTripTime(0)
{
- m_instanceId = boost::lexical_cast<std::string>(std::rand());
}
class InterestTrafficConfiguration
@@ -74,7 +85,7 @@
{
}
- time::milliseconds
+ static time::milliseconds
getDefaultInterestLifetime()
{
return time::milliseconds(-1);
@@ -83,81 +94,74 @@
void
printTrafficConfiguration(Logger& logger)
{
- std::string detail = "";
+ std::string detail;
+
if (m_trafficPercentage > 0)
- detail += "TrafficPercentage=" +
- boost::lexical_cast<std::string>(m_trafficPercentage) + ", ";
- if (m_name != "")
+ detail += "TrafficPercentage=" + std::to_string(m_trafficPercentage) + ", ";
+ if (!m_name.empty())
detail += "Name=" + m_name + ", ";
if (m_nameAppendBytes > 0)
- detail += "NameAppendBytes=" + boost::lexical_cast<std::string>(m_nameAppendBytes) + ", ";
+ detail += "NameAppendBytes=" + std::to_string(m_nameAppendBytes) + ", ";
if (m_nameAppendSequenceNumber > 0)
- detail += "NameAppendSequenceNumber=" +
- boost::lexical_cast<std::string>(m_nameAppendSequenceNumber) + ", ";
+ detail += "NameAppendSequenceNumber=" + std::to_string(m_nameAppendSequenceNumber) + ", ";
if (m_minSuffixComponents >= 0)
- detail += "MinSuffixComponents=" +
- boost::lexical_cast<std::string>(m_minSuffixComponents) + ", ";
+ detail += "MinSuffixComponents=" + std::to_string(m_minSuffixComponents) + ", ";
if (m_maxSuffixComponents >= 0)
- detail += "MaxSuffixComponents=" +
- boost::lexical_cast<std::string>(m_maxSuffixComponents) + ", ";
- if (m_excludeBefore != "")
+ detail += "MaxSuffixComponents=" + std::to_string(m_maxSuffixComponents) + ", ";
+ if (!m_excludeBefore.empty())
detail += "ExcludeBefore=" + m_excludeBefore + ", ";
- if (m_excludeAfter != "")
+ if (!m_excludeAfter.empty())
detail += "ExcludeAfter=" + m_excludeAfter + ", ";
if (m_excludeBeforeBytes > 0)
- detail += "ExcludeBeforeBytes=" +
- boost::lexical_cast<std::string>(m_excludeBeforeBytes) + ", ";
+ detail += "ExcludeBeforeBytes=" + std::to_string(m_excludeBeforeBytes) + ", ";
if (m_excludeAfterBytes > 0)
- detail += "ExcludeAfterBytes=" +
- boost::lexical_cast<std::string>(m_excludeAfterBytes) + ", ";
+ detail += "ExcludeAfterBytes=" + std::to_string(m_excludeAfterBytes) + ", ";
if (m_childSelector >= 0)
- detail += "ChildSelector=" +
- boost::lexical_cast<std::string>(m_childSelector) + ", ";
+ detail += "ChildSelector=" + std::to_string(m_childSelector) + ", ";
if (m_mustBeFresh >= 0)
- detail += "MustBeFresh=" +
- boost::lexical_cast<std::string>(m_mustBeFresh) + ", ";
+ detail += "MustBeFresh=" + std::to_string(m_mustBeFresh) + ", ";
if (m_nonceDuplicationPercentage > 0)
detail += "NonceDuplicationPercentage=" +
- boost::lexical_cast<std::string>(m_nonceDuplicationPercentage) + ", ";
+ std::to_string(m_nonceDuplicationPercentage) + ", ";
if (m_scope >= 0)
- detail += "Scope="+boost::lexical_cast<std::string>(m_scope) + ", ";
+ detail += "Scope=" + std::to_string(m_scope) + ", ";
if (m_interestLifetime >= time::milliseconds(0))
- detail += "InterestLifetime=" +
- boost::lexical_cast<std::string>(m_interestLifetime.count()) + ", ";
- if (m_expectedContent != "")
+ detail += "InterestLifetime=" + std::to_string(m_interestLifetime.count()) + ", ";
+ if (!m_expectedContent.empty())
detail += "ExpectedContent=" + m_expectedContent + ", ";
if (detail.length() >= 2)
- detail = detail.substr(0, detail.length() - 2); //Removing suffix ", "
+ detail = detail.substr(0, detail.length() - 2); // Removing suffix ", "
+
logger.log(detail, false, false);
}
bool
- extractParameterValue(const std::string& detail,
- std::string& parameter,
- std::string& value)
+ extractParameterValue(const std::string& detail, std::string& parameter, std::string& value)
{
std::string allowedCharacters = ":/+._-%";
+ std::size_t i = 0;
+
parameter = "";
value = "";
- int i = 0;
- while (detail[i] != '=' && i < detail.length())
- {
- parameter += detail[i];
- i++;
- }
+ while (detail[i] != '=' && i < detail.length()) {
+ parameter += detail[i];
+ i++;
+ }
if (i == detail.length())
return false;
+
i++;
while ((std::isalnum(detail[i]) ||
- allowedCharacters.find(detail[i]) != std::string::npos) &&
- i < detail.length())
- {
- value += detail[i];
- i++;
- }
- if (parameter == "" || value == "")
+ allowedCharacters.find(detail[i]) != std::string::npos) &&
+ i < detail.length()) {
+ value += detail[i];
+ i++;
+ }
+
+ if (parameter.empty() || value.empty())
return false;
- return true;
+ else
+ return true;
}
bool
@@ -167,44 +171,44 @@
if (extractParameterValue(detail, parameter, value))
{
if (parameter == "TrafficPercentage")
- m_trafficPercentage = boost::lexical_cast<int>(value);
+ m_trafficPercentage = std::stoi(value);
else if (parameter == "Name")
m_name = value;
else if (parameter == "NameAppendBytes")
- m_nameAppendBytes = boost::lexical_cast<int>(value);
+ m_nameAppendBytes = std::stoi(value);
else if (parameter == "NameAppendSequenceNumber")
- m_nameAppendSequenceNumber = boost::lexical_cast<int>(value);
+ m_nameAppendSequenceNumber = std::stoi(value);
else if (parameter == "MinSuffixComponents")
- m_minSuffixComponents = boost::lexical_cast<int>(value);
+ m_minSuffixComponents = std::stoi(value);
else if (parameter == "MaxSuffixComponents")
- m_maxSuffixComponents = boost::lexical_cast<int>(value);
+ m_maxSuffixComponents = std::stoi(value);
else if (parameter == "ExcludeBefore")
m_excludeBefore = value;
else if (parameter == "ExcludeAfter")
m_excludeAfter = value;
else if (parameter == "ExcludeBeforeBytes")
- m_excludeBeforeBytes = boost::lexical_cast<int>(value);
+ m_excludeBeforeBytes = std::stoi(value);
else if (parameter == "ExcludeAfterBytes")
- m_excludeAfterBytes = boost::lexical_cast<int>(value);
+ m_excludeAfterBytes = std::stoi(value);
else if (parameter == "ChildSelector")
- m_childSelector = boost::lexical_cast<int>(value);
+ m_childSelector = std::stoi(value);
else if (parameter == "MustBeFresh")
- m_mustBeFresh = boost::lexical_cast<int>(value);
+ m_mustBeFresh = std::stoi(value);
else if (parameter == "NonceDuplicationPercentage")
- m_nonceDuplicationPercentage = boost::lexical_cast<int>(value);
+ m_nonceDuplicationPercentage = std::stoi(value);
else if (parameter == "Scope")
- m_scope = boost::lexical_cast<int>(value);
+ m_scope = std::stoi(value);
else if (parameter == "InterestLifetime")
- m_interestLifetime = time::milliseconds(boost::lexical_cast<int>(value));
+ m_interestLifetime = time::milliseconds(std::stoi(value));
else if (parameter == "ExpectedContent")
m_expectedContent = value;
else
- logger.log("Line " + boost::lexical_cast<std::string>(lineNumber) +
+ logger.log("Line " + std::to_string(lineNumber) +
" \t- Invalid Parameter='" + parameter + "'", false, true);
}
else
{
- logger.log("Line " + boost::lexical_cast<std::string>(lineNumber) +
+ logger.log("Line " + std::to_string(lineNumber) +
" \t- Improper Traffic Configuration Line- " + detail, false, true);
return false;
}
@@ -217,6 +221,7 @@
return true;
}
+ private:
int m_trafficPercentage;
std::string m_name;
int m_nameAppendBytes;
@@ -243,6 +248,8 @@
int m_nContentInconsistencies;
std::string m_expectedContent;
+
+ friend class NdnTrafficClient;
}; // class InterestTrafficConfiguration
bool
@@ -252,21 +259,25 @@
}
void
- usage()
+ usage() const
{
- std::cout << "\nUsage: " << m_programName << " [options] <Traffic_Configuration_File>\n"
- "Generate Interest Traffic as per provided Traffic Configuration File\n"
- "Interests are continuously generated unless a total number is specified.\n"
- "Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.\n"
- " [-i interval] - set interest generation interval in milliseconds (default "
+ std::cout << "Usage:\n"
+ << " " << m_programName << " [options] <Traffic_Configuration_File>\n"
+ << "\n"
+ << "Generate Interest traffic as per provided Traffic Configuration File.\n"
+ << "Interests are continuously generated unless a total number is specified.\n"
+ << "Set environment variable NDN_TRAFFIC_LOGFOLDER to redirect output to a log file.\n"
+ << "\n"
+ << "Options:\n"
+ << " [-i interval] - set interest generation interval in milliseconds (default "
<< getDefaultInterestInterval() << ")\n"
- " [-c count] - set total number of interests to be generated\n"
- " [-q] - quiet logging - no interest generation/data reception messages\n"
- " [-h] - print help and exit\n\n";
- exit(1);
+ << " [-c count] - set total number of interests to be generated\n"
+ << " [-q] - quiet mode: no interest reception/data generation logging\n"
+ << " [-h] - print this help text and exit\n";
+ exit(EXIT_FAILURE);
}
- time::milliseconds
+ static time::milliseconds
getDefaultInterestInterval()
{
return time::milliseconds(1000);
@@ -304,13 +315,12 @@
signalHandler()
{
logStatistics();
+
m_logger.shutdownLogger();
m_face.shutdown();
m_ioService.stop();
- if (m_hasError)
- exit(1);
- else
- exit(0);
+
+ exit(m_hasError ? EXIT_FAILURE : EXIT_SUCCESS);
}
void
@@ -318,18 +328,19 @@
{
m_logger.log("\n\n== Interest Traffic Report ==\n", false, true);
m_logger.log("Total Traffic Pattern Types = " +
- boost::lexical_cast<std::string>(static_cast<int>(m_trafficPatterns.size())), false, true);
+ std::to_string(m_trafficPatterns.size()), false, true);
m_logger.log("Total Interests Sent = " +
- boost::lexical_cast<std::string>(m_nInterestsSent), false, true);
+ std::to_string(m_nInterestsSent), false, true);
m_logger.log("Total Responses Received = " +
- boost::lexical_cast<std::string>(m_nInterestsReceived), false, true);
+ std::to_string(m_nInterestsReceived), false, true);
+
double loss = 0;
if (m_nInterestsSent > 0)
loss = (m_nInterestsSent - m_nInterestsReceived) * 100.0 / m_nInterestsSent;
- m_logger.log("Total Interest Loss = " +
- boost::lexical_cast<std::string>(loss) + "%", false, true);
+ m_logger.log("Total Interest Loss = " + std::to_string(loss) + "%", false, true);
if (m_nContentInconsistencies != 0 || m_nInterestsSent != m_nInterestsReceived)
m_hasError = true;
+
double average = 0;
double inconsistency = 0;
if (m_nInterestsReceived > 0)
@@ -338,23 +349,21 @@
inconsistency = m_nContentInconsistencies * 100.0 / m_nInterestsReceived;
}
m_logger.log("Total Data Inconsistency = " +
- boost::lexical_cast<std::string>(inconsistency) + "%", false, true);
+ std::to_string(inconsistency) + "%", false, true);
m_logger.log("Total Round Trip Time = " +
- boost::lexical_cast<std::string>(m_totalInterestRoundTripTime) + "ms", false, true);
+ std::to_string(m_totalInterestRoundTripTime) + "ms", false, true);
m_logger.log("Average Round Trip Time = " +
- boost::lexical_cast<std::string>(average) + "ms\n", false, true);
+ std::to_string(average) + "ms\n", false, true);
- for (int patternId = 0; patternId < m_trafficPatterns.size(); patternId++)
+ for (std::size_t patternId = 0; patternId < m_trafficPatterns.size(); patternId++)
{
m_logger.log("Traffic Pattern Type #" +
- boost::lexical_cast<std::string>(patternId + 1), false, true);
+ std::to_string(patternId + 1), false, true);
m_trafficPatterns[patternId].printTrafficConfiguration(m_logger);
m_logger.log("Total Interests Sent = " +
- boost::lexical_cast<std::string>(
- m_trafficPatterns[patternId].m_nInterestsSent), false, true);
+ std::to_string(m_trafficPatterns[patternId].m_nInterestsSent), false, true);
m_logger.log("Total Responses Received = " +
- boost::lexical_cast<std::string>(
- m_trafficPatterns[patternId].m_nInterestsReceived), false, true);
+ std::to_string(m_trafficPatterns[patternId].m_nInterestsReceived), false, true);
loss = 0;
if (m_trafficPatterns[patternId].m_nInterestsSent > 0)
{
@@ -363,8 +372,7 @@
loss *= 100.0;
loss /= m_trafficPatterns[patternId].m_nInterestsSent;
}
- m_logger.log("Total Interest Loss = " +
- boost::lexical_cast<std::string>(loss) + "%", false, true);
+ m_logger.log("Total Interest Loss = " + std::to_string(loss) + "%", false, true);
average = 0;
inconsistency = 0;
if (m_trafficPatterns[patternId].m_nInterestsReceived > 0)
@@ -372,16 +380,15 @@
average = (m_trafficPatterns[patternId].m_totalInterestRoundTripTime /
m_trafficPatterns[patternId].m_nInterestsReceived);
inconsistency = m_trafficPatterns[patternId].m_nContentInconsistencies;
- inconsistency =
- inconsistency * 100.0 / m_trafficPatterns[patternId].m_nInterestsReceived;
+ inconsistency *= 100.0 / m_trafficPatterns[patternId].m_nInterestsReceived;
}
m_logger.log("Total Data Inconsistency = " +
- boost::lexical_cast<std::string>(inconsistency) + "%", false, true);
+ std::to_string(inconsistency) + "%", false, true);
m_logger.log("Total Round Trip Time = " +
- boost::lexical_cast<std::string>(
- m_trafficPatterns[patternId].m_totalInterestRoundTripTime) + "ms", false, true);
+ std::to_string(m_trafficPatterns[patternId].m_totalInterestRoundTripTime) +
+ "ms", false, true);
m_logger.log("Average Round Trip Time = " +
- boost::lexical_cast<std::string>(average) + "ms\n", false, true);
+ std::to_string(average) + "ms\n", false, true);
}
}
@@ -397,10 +404,10 @@
std::string patternLine;
std::ifstream patternFile;
m_logger.log("Analyzing Traffic Configuration File: " + m_configurationFile, true, true);
+
patternFile.open(m_configurationFile.c_str());
if (patternFile.is_open())
{
- int patternId = 0;
int lineNumber = 0;
while (getline(patternFile, patternLine))
{
@@ -409,7 +416,6 @@
{
InterestTrafficConfiguration interestData;
bool shouldSkipLine = false;
- patternId++;
if (interestData.processConfigurationDetail(patternLine, m_logger, lineNumber))
{
while (getline(patternFile, patternLine) && std::isalpha(patternLine[0]))
@@ -439,13 +445,13 @@
m_logger.log("ERROR - Traffic Configuration Provided Is Not Proper- " +
m_configurationFile, false, true);
m_logger.shutdownLogger();
- exit(1);
+ exit(EXIT_FAILURE);
}
m_logger.log("Traffic Configuration File Processing Completed\n", true, false);
- for (patternId = 0; patternId < m_trafficPatterns.size(); patternId++)
+ for (std::size_t patternId = 0; patternId < m_trafficPatterns.size(); patternId++)
{
m_logger.log("Traffic Pattern Type #" +
- boost::lexical_cast<std::string>(patternId + 1), false, false);
+ std::to_string(patternId + 1), false, false);
m_trafficPatterns[patternId].printTrafficConfiguration(m_logger);
m_logger.log("", false, false);
}
@@ -455,7 +461,7 @@
m_logger.log("ERROR - Unable To Open Traffic Configuration File: " +
m_configurationFile, false, true);
m_logger.shutdownLogger();
- exit(1);
+ exit(EXIT_FAILURE);
}
}
@@ -473,7 +479,7 @@
m_logger.log("ERROR - Traffic Configuration File Is Not A Regular File: " +
m_configurationFile, false, true);
m_logger.shutdownLogger();
- exit(1);
+ exit(EXIT_FAILURE);
}
}
else
@@ -481,7 +487,7 @@
m_logger.log("ERROR - Traffic Configuration File Does Not Exist: " +
m_configurationFile, false, true);
m_logger.shutdownLogger();
- exit(1);
+ exit(EXIT_FAILURE);
}
}
@@ -510,10 +516,10 @@
}
static std::string
- getRandomByteString(int randomSize)
+ getRandomByteString(std::size_t randomSize)
{
std::string randomString;
- for (int i = 0; i < randomSize; i++)
+ for (std::size_t i = 0; i < randomSize; i++)
randomString += static_cast<char>(std::rand() % 128);
return randomString;
}
@@ -526,15 +532,14 @@
int patternId,
time::steady_clock::TimePoint sentTime)
{
- std::string logLine =
- "Data Received - PatternType=" + boost::lexical_cast<std::string>(patternId+1);
- logLine += ", GlobalID=" + boost::lexical_cast<std::string>(globalReference);
- logLine += ", LocalID=" + boost::lexical_cast<std::string>(localReference);
+ std::string logLine = "Data Received - PatternType=" + std::to_string(patternId + 1);
+ logLine += ", GlobalID=" + std::to_string(globalReference);
+ logLine += ", LocalID=" + std::to_string(localReference);
logLine += ", Name=" + interest.getName().toUri();
m_nInterestsReceived++;
m_trafficPatterns[patternId].m_nInterestsReceived++;
- if (m_trafficPatterns[patternId].m_expectedContent != "")
+ if (!m_trafficPatterns[patternId].m_expectedContent.empty())
{
std::string receivedContent = reinterpret_cast<const char*>(data.getContent().value());
int receivedContentLength = data.getContent().value_size();
@@ -578,10 +583,9 @@
int localReference,
int patternId)
{
- std::string logLine = "Interest Timed Out - PatternType=" +
- boost::lexical_cast<std::string>(patternId + 1);
- logLine += ", GlobalID=" + boost::lexical_cast<std::string>(globalReference);
- logLine += ", LocalID=" + boost::lexical_cast<std::string>(localReference);
+ std::string logLine = "Interest Timed Out - PatternType=" + std::to_string(patternId + 1);
+ logLine += ", GlobalID=" + std::to_string(globalReference);
+ logLine += ", LocalID=" + std::to_string(localReference);
logLine += ", Name=" + interest.getName().toUri();
m_logger.log(logLine, true, false);
if (m_nMaximumInterests >= 0 && globalReference == m_nMaximumInterests)
@@ -594,13 +598,13 @@
}
void
- generateTraffic(boost::asio::deadline_timer* deadlineTimer)
+ generateTraffic(boost::asio::deadline_timer* timer)
{
if (m_nMaximumInterests < 0 || m_nInterestsSent < m_nMaximumInterests)
{
int trafficKey = std::rand() % 100;
int cumulativePercentage = 0;
- int patternId;
+ std::size_t patternId;
for (patternId = 0; patternId < m_trafficPatterns.size(); patternId++)
{
cumulativePercentage += m_trafficPatterns[patternId].m_trafficPercentage;
@@ -613,10 +617,10 @@
if (m_trafficPatterns[patternId].m_nameAppendSequenceNumber >= 0)
{
interestName.append(
- boost::lexical_cast<std::string>(
- m_trafficPatterns[patternId].m_nameAppendSequenceNumber));
+ std::to_string(m_trafficPatterns[patternId].m_nameAppendSequenceNumber));
m_trafficPatterns[patternId].m_nameAppendSequenceNumber++;
}
+
Interest interest(interestName);
if (m_trafficPatterns[patternId].m_minSuffixComponents >= 0)
interest.setMinSuffixComponents(
@@ -624,9 +628,10 @@
if (m_trafficPatterns[patternId].m_maxSuffixComponents >= 0)
interest.setMaxSuffixComponents(
m_trafficPatterns[patternId].m_maxSuffixComponents);
+
Exclude exclude;
- if (m_trafficPatterns[patternId].m_excludeBefore != "" &&
- m_trafficPatterns[patternId].m_excludeAfter != "")
+ if (!m_trafficPatterns[patternId].m_excludeBefore.empty() &&
+ !m_trafficPatterns[patternId].m_excludeAfter.empty())
{
exclude.excludeRange(
name::Component(
@@ -634,13 +639,13 @@
name::Component(m_trafficPatterns[patternId].m_excludeBefore));
interest.setExclude(exclude);
}
- else if (m_trafficPatterns[patternId].m_excludeBefore != "")
+ else if (!m_trafficPatterns[patternId].m_excludeBefore.empty())
{
exclude.excludeBefore(
name::Component(m_trafficPatterns[patternId].m_excludeBefore));
interest.setExclude(exclude);
}
- else if (m_trafficPatterns[patternId].m_excludeAfter != "")
+ else if (!m_trafficPatterns[patternId].m_excludeAfter.empty())
{
exclude.excludeAfter(
name::Component(m_trafficPatterns[patternId].m_excludeAfter));
@@ -711,34 +716,32 @@
this, _1, m_nInterestsSent,
m_trafficPatterns[patternId].m_nInterestsSent,
patternId));
- std::string logLine = "";
- logLine += "Sending Interest - PatternType=" +
- boost::lexical_cast<std::string>(patternId+1);
- logLine += ", GlobalID=" + boost::lexical_cast<std::string>(m_nInterestsSent);
- logLine += ", LocalID=" + boost::lexical_cast<std::string>(
- m_trafficPatterns[patternId].m_nInterestsSent);
- logLine += ", Name="+interest.getName().toUri();
- if (!m_hasQuietLogging)
+
+ if (!m_hasQuietLogging) {
+ std::string logLine =
+ "Sending Interest - PatternType=" + std::to_string(patternId + 1) +
+ ", GlobalID=" + std::to_string(m_nInterestsSent) +
+ ", LocalID=" +
+ std::to_string(m_trafficPatterns[patternId].m_nInterestsSent) +
+ ", Name=" + interest.getName().toUri();
m_logger.log(logLine, true, false);
- deadlineTimer->expires_at(deadlineTimer->expires_at() +
- boost::posix_time::millisec(
- m_interestInterval.count()));
- deadlineTimer->async_wait(bind(&NdnTrafficClient::generateTraffic,
- this, deadlineTimer));
+ }
+
+ timer->expires_at(timer->expires_at() +
+ boost::posix_time::millisec(m_interestInterval.count()));
+ timer->async_wait(bind(&NdnTrafficClient::generateTraffic, this, timer));
}
- catch (std::exception& e) {
- m_logger.log("ERROR: " + static_cast<std::string>(e.what()), true, true);
+ catch (const std::exception& e) {
+ m_logger.log("ERROR: " + std::string(e.what()), true, true);
}
break;
}
}
if (patternId == m_trafficPatterns.size())
{
- deadlineTimer->expires_at(deadlineTimer->expires_at() +
- boost::posix_time::millisec(
- m_interestInterval.count()));
- deadlineTimer->async_wait(bind(&NdnTrafficClient::generateTraffic,
- this, deadlineTimer));
+ timer->expires_at(timer->expires_at() +
+ boost::posix_time::millisec(m_interestInterval.count()));
+ timer->async_wait(bind(&NdnTrafficClient::generateTraffic, this, timer));
}
}
}
@@ -758,16 +761,15 @@
return;
}
- boost::asio::deadline_timer deadlineTimer(
- m_ioService,
+ boost::asio::deadline_timer deadlineTimer(m_ioService,
boost::posix_time::millisec(m_interestInterval.count()));
- deadlineTimer.async_wait(bind(&NdnTrafficClient::generateTraffic,
- this, &deadlineTimer));
+ deadlineTimer.async_wait(bind(&NdnTrafficClient::generateTraffic, this, &deadlineTimer));
+
try {
m_face.processEvents();
}
- catch(std::exception& e) {
- m_logger.log("ERROR: " + static_cast<std::string>(e.what()), true, true);
+ catch (const std::exception& e) {
+ m_logger.log("ERROR: " + std::string(e.what()), true, true);
m_logger.shutdownLogger();
m_hasError = true;
m_ioService.stop();
@@ -775,7 +777,6 @@
}
private:
-
std::string m_programName;
Logger m_logger;
std::string m_instanceId;
@@ -797,7 +798,6 @@
double m_minimumInterestRoundTripTime;
double m_maximumInterestRoundTripTime;
double m_totalInterestRoundTripTime;
-
};
} // namespace ndn
@@ -805,25 +805,26 @@
int
main(int argc, char* argv[])
{
- std::srand(std::time(0));
- ndn::NdnTrafficClient ndnTrafficClient (argv[0]);
+ std::srand(std::time(nullptr));
+
+ ndn::NdnTrafficClient client(argv[0]);
int option;
while ((option = getopt(argc, argv, "hqi:c:")) != -1) {
switch (option) {
case 'h':
- ndnTrafficClient.usage();
+ client.usage();
break;
case 'i':
- ndnTrafficClient.setInterestInterval(atoi(optarg));
+ client.setInterestInterval(atoi(optarg));
break;
case 'c':
- ndnTrafficClient.setMaximumInterests(atoi(optarg));
+ client.setMaximumInterests(atoi(optarg));
break;
case 'q':
- ndnTrafficClient.setQuietLogging();
+ client.setQuietLogging();
break;
default:
- ndnTrafficClient.usage();
+ client.usage();
break;
}
}
@@ -831,14 +832,11 @@
argc -= optind;
argv += optind;
- if (argv[0] == 0)
- ndnTrafficClient.usage();
+ if (!argc)
+ client.usage();
- ndnTrafficClient.setConfigurationFile(argv[0]);
- ndnTrafficClient.run();
+ client.setConfigurationFile(argv[0]);
+ client.run();
- if (ndnTrafficClient.hasError())
- return 1;
- else
- return 0;
+ return client.hasError() ? EXIT_FAILURE : EXIT_SUCCESS;
}