ping( destination_ip);
 }
 
-void PingScheduler::ping_done_handler(bool ping_success)
+void PingScheduler::ping_done_handler( bool ping_success )
 {
     update_ping_statistics( ping_success );
     update_ping_elapsed_time();
 
 
 uint16_t IcmpDestinationUnreachableMessage::get_checksum() const
 {
-    return Payload.decode( 2, 3 );
+    return Payload.decode16( 2, 3 );
 }
 
 void IcmpDestinationUnreachableMessage::set_checksum( uint16_t checksum )
 {
-    Payload.encode( 2, 3, checksum );
+    Payload.encode16( 2, 3, checksum );
 }
 
 uint16_t IcmpDestinationUnreachableMessage::get_identifier() const
 {
-    return Payload.decode( 32, 33 );
+    return Payload.decode16( 32, 33 );
 }
 
 void IcmpDestinationUnreachableMessage::set_identifier(
         const uint16_t identifier
 )
 {
-    Payload.encode( 32, 33, identifier );
+    Payload.encode16( 32, 33, identifier );
 }
 
 uint16_t IcmpDestinationUnreachableMessage::get_sequence_number() const
 {
-    return Payload.decode( 34, 35 );
+    return Payload.decode16( 34, 35 );
 }
 
 void IcmpDestinationUnreachableMessage::set_sequence_number(
         const uint16_t sequence_number
 )
 {
-    Payload.encode( 34, 35, sequence_number );
+    Payload.encode16( 34, 35, sequence_number );
 }
 
 std::istream& IcmpDestinationUnreachableMessage::read( std::istream &is )
 
 
 uint16_t IcmpEchoReplyMessage::get_checksum() const
 {
-    return Payload.decode( 2, 3 );
+    return Payload.decode16( 2, 3 );
 }
 
 void IcmpEchoReplyMessage::set_checksum( uint16_t checksum )
 {
-    Payload.encode( 2, 3, checksum );
+    Payload.encode16( 2, 3, checksum );
 }
 
 uint16_t IcmpEchoReplyMessage::get_identifier() const
 {
-    return Payload.decode( 4, 5 );
+    return Payload.decode16( 4, 5 );
 }
 
 void IcmpEchoReplyMessage::set_identifier(
         const uint16_t identifier
 )
 {
-    Payload.encode( 4, 5, identifier );
+    Payload.encode16( 4, 5, identifier );
 }
 
 uint16_t IcmpEchoReplyMessage::get_sequence_number() const
 {
-    return Payload.decode( 6, 7 );
+    return Payload.decode16( 6, 7 );
 }
 
 void IcmpEchoReplyMessage::set_sequence_number(
         const uint16_t sequence_number
 )
 {
-    Payload.encode( 6, 7, sequence_number );
+    Payload.encode16( 6, 7, sequence_number );
 }
 
 std::istream& IcmpEchoReplyMessage::read( std::istream &is )
 
 
 uint16_t IcmpEchoRequestMessage::get_checksum() const
 {
-    return Payload.decode( 2, 3 );
+    return Payload.decode16( 2, 3 );
 }
 
 void IcmpEchoRequestMessage::set_checksum( uint16_t checksum )
 {
-    Payload.encode( 2, 3, checksum );
+    Payload.encode16( 2, 3, checksum );
 }
 
 uint16_t IcmpEchoRequestMessage::get_identifier() const
 {
-    return Payload.decode( 4, 5 );
+    return Payload.decode16( 4, 5 );
 }
 
 void IcmpEchoRequestMessage::set_identifier(
         const uint16_t identifier
 )
 {
-    Payload.encode( 4, 5, identifier );
+    Payload.encode16( 4, 5, identifier );
 }
 
 uint16_t IcmpEchoRequestMessage::get_sequence_number() const
 {
-    return Payload.decode( 6, 7 );
+    return Payload.decode16( 6, 7 );
 }
 
 void IcmpEchoRequestMessage::set_sequence_number(
         const uint16_t sequence_number
 )
 {
-    Payload.encode( 6, 7, sequence_number );
+    Payload.encode16( 6, 7, sequence_number );
 }
 
 std::istream& IcmpEchoRequestMessage::read( std::istream &is )
 
  * @return a concatenation of the byte indexed by left_byte with the byte
  * indexed by right_byte
  */
-uint16_t IcmpMessagePayload::decode(
+uint16_t IcmpMessagePayload::decode16(
         const int left_byte,
         const int right_byte
 ) const
  * @param value a 16 bits data be saved in the bytes indexed by left_byte and
  * right_byte.
  */
-void IcmpMessagePayload::encode(
+void IcmpMessagePayload::encode16(
         const int left_byte,
         const int right_byte,
         const uint16_t value
  */
 istream& IcmpMessagePayload::read( istream &is )
 {
-    char *data_array = reinterpret_cast<char *> ( Payload.get() );
-    (void) is.read( data_array, PayloadSizeInBytes );
+    char *payload_data_array = reinterpret_cast<char *> ( Payload.get() );
+    (void) is.read( payload_data_array, PayloadSizeInBytes );
 
     size_t data_received_in_bytes = static_cast<size_t>( is.gcount() );
     if ( data_received_in_bytes != PayloadSizeInBytes )
 
     const uint8_t& operator[]( std::size_t offset ) const;
     uint8_t& operator[]( std::size_t offset );
 
-    uint16_t decode(
+    uint16_t decode16(
             const int left_byte,
             const int right_byte
     ) const;
-    void encode(
+    void encode16(
             const int left_byte,
             const int right_byte,
             const uint16_t value