bool ConfigurationReader::parse_generic_options(
const variables_map& vm,
const options_description& visible_options
-)
+) const
{
if ( vm.count( HelpCmdStr ) )
{
const int argc,
char *argv[],
variables_map &vm
-)
+) const
{
try
{
}
}
- catch ( std::exception &e )
+ catch ( const std::exception &ex )
{
- cerr << e.what() << endl;
+ cerr << ex.what() << endl;
return false;
}
bool ConfigurationReader::process_configuration_file(
const string &config_file_name,
variables_map &vm
-)
+) const
{
BOOST_ASSERT( !config_file_name.empty() );
bool parse_generic_options(
const boost::program_options::variables_map &vm,
const boost::program_options::options_description &visible_options
- );
+ ) const;
boost::program_options::options_description get_configuration_options() const;
bool parse_configuration_options(
const int argc,
char *argv[],
boost::program_options::variables_map &vm
- );
+ ) const;
bool process_configuration_file(
boost::program_options::variables_map &vm
);
bool process_configuration_file(
const std::string &config_file_name,
boost::program_options::variables_map &vm
- );
+ ) const;
private:
Configuration Config;
try
{
- io_service io_service;
- tcp::resolver resolver( io_service );
+ io_service io_serv;
+ tcp::resolver resolver( io_serv );
tcp::resolver::query query( tcp::v4(), HostDnsAddress, "" );
tcp::resolver::iterator it_first = resolver.resolve( query );
tcp::resolver::iterator it_last = tcp::resolver::iterator();
while ( it_first != it_last )
{
- string ip = (*it_first).endpoint().address().to_string();
+ string dest_ip = (*it_first).endpoint().address().to_string();
HostAddress resolved_host;
- resolved_host.set_ip( ip );
+ resolved_host.set_ip( dest_ip );
ResolvedHostAddressList.push_back( resolved_host );
- cerr << ip << endl;
+ cerr << dest_ip << endl;
++it_first;
}
}
- catch ( boost::system::system_error& ex )
+ catch ( const std::exception &ex )
{
- cerr << "Error: host " << HostDnsAddress << " could not be resolved."
- << endl;
+ cerr << "Error: host " << HostDnsAddress << " could not be resolved. "
+ << ex.what() << endl;
return false;
}
/**
* @return the amount of IPs resolved for the DNS.
*/
-int DnsResolver::get_resolved_ip_count()
+int DnsResolver::get_resolved_ip_count() const
{
int resolved_ip_count = ResolvedHostAddressList.size();
virtual ~DnsResolver();
bool resolve();
- int get_resolved_ip_count();
+ int get_resolved_ip_count() const;
std::string get_next_ip();
private:
{
public:
ChecksumCalculator(
- Iterator body_begin,
- Iterator body_end
+ const Iterator &body_begin,
+ const Iterator &body_end
);
uint16_t compute(
template<typename Iterator>
ChecksumCalculator<Iterator>::ChecksumCalculator(
- Iterator body_begin,
- Iterator body_end
+ const Iterator &body_begin,
+ const Iterator &body_end
) :
- BodyBegin(),
- BodyEnd()
+ BodyBegin( body_begin ),
+ BodyEnd( body_end )
{
- this->BodyBegin = body_begin;
- this->BodyEnd = body_end;
}
template<typename Iterator>
IcmpHeader::IcmpType type,
uint16_t identifier,
uint16_t sequence_number
-)
+) const
{
bool type_match = IcmpPayloadHeader.get_type() == type;
bool identifier_match = IcmpPayloadHeader.get_identifier() == identifier;
IcmpHeader::IcmpType type,
uint16_t identifier,
uint16_t sequence_number
- );
+ ) const;
friend std::istream& operator>>(
std::istream &is,
bool read_success = config_reader.parse( argc, argv );
if ( read_success )
{
- io_service io_service;
+ io_service io_serv;
Configuration config = config_reader.get_configuration();
int ping_interval_in_sec = (*host).get_interval_in_sec();
PingSchedulerItem scheduler(
new PingScheduler(
- io_service,
+ io_serv,
ping_address,
ping_interval_in_sec,
ping_fail_limit,
}
// Main loop to handle scheduled ping requests
- io_service.run();
+ io_serv.run();
}
return 0;
BOOST_ASSERT( !value.empty() );
BOOST_ASSERT( !CommandStr.empty() );
- size_t token_begin_pos = CommandStr.find( token );
+ const size_t token_begin_pos = CommandStr.find( token );
if ( token_begin_pos == string::npos )
{
return false; // token string not found!
return true;
}
-bool StatusNotifierCommand::execute()
+bool StatusNotifierCommand::execute() const
{
BOOST_ASSERT( !CommandStr.empty() );
const std::string &value
);
- bool execute();
+ bool execute() const;
private:
std::string get_application_string() const;
//-----------------------------------------------------------------------------
BoostPinger::BoostPinger(
- boost::asio::io_service &io_service,
+ boost::asio::io_service &io_serv,
const int echo_reply_timeout_in_sec
) :
- IoService( io_service ),
- Resolver( io_service ),
+ IoService( io_serv ),
+ Resolver( io_serv ),
DestinationEndpoint(),
- Socket( io_service, icmp::v4() ),
- Timer( io_service ),
+ Socket( io_serv, icmp::v4() ),
+ Timer( io_serv ),
SequenceNumber( 0 ),
TimeSent( microsec_clock::universal_time() ),
ReplyBuffer(),
{
public:
BoostPinger(
- boost::asio::io_service &io_service,
+ boost::asio::io_service &io_serv,
const int echo_reply_timeout_in_sec
);
virtual ~BoostPinger();
{
PingStatus_NotSent,
PingStatus_SuccessReply,
- PingStatus_FailureTimeout,
+ PingStatus_FailureTimeout
};
private:
//-----------------------------------------------------------------------------
PingScheduler::PingScheduler(
- boost::asio::io_service &io_service,
+ boost::asio::io_service &io_serv,
const string &ping_address,
const long ping_interval_in_sec,
const int ping_fail_percentage_limit,
shared_ptr<LinkStatusAnalyzer> link_analyzer
) :
- IoService( io_service ),
- Timer( io_service ),
+ IoService( io_serv ),
+ Timer( io_serv ),
TimeSentLastPing( microsec_clock::universal_time() ),
PingIntervalInSec( ping_interval_in_sec ),
IpList( ping_address ),
{
public:
PingScheduler(
- boost::asio::io_service &io_service,
+ boost::asio::io_service &io_serv,
const std::string &ping_address,
const long ping_interval_in_sec,
const int ping_fail_percentage_limit,