diff --git a/src/requester.cpp b/src/requester.cpp
index ef839c0..7ace36c 100644
--- a/src/requester.cpp
+++ b/src/requester.cpp
@@ -66,7 +66,7 @@
 optional<CaProfile>
 Requester::onCaProfileResponse(const Data& reply)
 {
-  auto caItem = InfoEncoder::decodeDataContent(reply.getContent());
+  auto caItem = infoEncoder::decodeDataContent(reply.getContent());
   if (!security::verifySignature(reply, *caItem.m_cert)) {
     NDN_LOG_ERROR("Cannot verify replied Data packet signature.");
     NDN_THROW(std::runtime_error("Cannot verify replied Data packet signature."));
@@ -77,7 +77,7 @@
 optional<CaProfile>
 Requester::onCaProfileResponseAfterRedirection(const Data& reply, const Name& caCertFullName)
 {
-  auto caItem = InfoEncoder::decodeDataContent(reply.getContent());
+  auto caItem = infoEncoder::decodeDataContent(reply.getContent());
   auto certBlock = caItem.m_cert->wireEncode();
   caItem.m_cert = std::make_shared<security::Certificate>(certBlock);
   if (caItem.m_cert->getFullName() != caCertFullName) {
@@ -95,7 +95,7 @@
   auto interest =std::make_shared<Interest>(interestName);
   interest->setMustBeFresh(true);
   interest->setCanBePrefix(false);
-  interest->setApplicationParameters(ProbeEncoder::encodeApplicationParameters(std::move(probeInfo)));
+  interest->setApplicationParameters(probeEncoder::encodeApplicationParameters(std::move(probeInfo)));
   return interest;
 }
 
@@ -109,7 +109,7 @@
     return;
   }
   processIfError(reply);
-  ProbeEncoder::decodeDataContent(reply.getContent(), identityNames, otherCas);
+  probeEncoder::decodeDataContent(reply.getContent(), identityNames, otherCas);
 }
 
 shared_ptr<Interest>
@@ -165,7 +165,7 @@
   interest->setMustBeFresh(true);
   interest->setCanBePrefix(false);
   interest->setApplicationParameters(
-      NewRenewRevokeEncoder::encodeApplicationParameters(RequestType::NEW, state.m_ecdh.getSelfPubKey(), certRequest));
+          newRenewRevokeEncoder::encodeApplicationParameters(RequestType::NEW, state.m_ecdh.getSelfPubKey(), certRequest));
 
   // sign the Interest packet
   state.m_keyChain.sign(*interest, signingByKey(keyName));
@@ -185,7 +185,7 @@
   interest->setMustBeFresh(true);
   interest->setCanBePrefix(false);
   interest->setApplicationParameters(
-      NewRenewRevokeEncoder::encodeApplicationParameters(RequestType::REVOKE, state.m_ecdh.getSelfPubKey(), certificate));
+          newRenewRevokeEncoder::encodeApplicationParameters(RequestType::REVOKE, state.m_ecdh.getSelfPubKey(), certificate));
   return interest;
 }
 
@@ -201,7 +201,7 @@
   auto contentTLV = reply.getContent();
   std::vector<uint8_t> ecdhKey;
   std::array<uint8_t, 32> salt;
-  auto challenges = NewRenewRevokeEncoder::decodeDataContent(contentTLV, ecdhKey, salt, state.m_requestId, state.m_status);
+  auto challenges = newRenewRevokeEncoder::decodeDataContent(contentTLV, ecdhKey, salt, state.m_requestId, state.m_status);
 
   // ECDH and HKDF
   auto sharedSecret = state.m_ecdh.deriveSecret(ecdhKey);
@@ -261,7 +261,7 @@
     NDN_THROW(std::runtime_error("Cannot verify replied Data packet signature."));
   }
   processIfError(reply);
-  ChallengeEncoder::decodeDataContent(reply.getContent(), state);
+  challengeEncoder::decodeDataContent(reply.getContent(), state);
 }
 
 shared_ptr<Interest>
@@ -309,7 +309,7 @@
 void
 Requester::processIfError(const Data& data)
 {
-  auto errorInfo = ErrorEncoder::decodefromDataContent(data.getContent());
+  auto errorInfo = errorEncoder::decodefromDataContent(data.getContent());
   if (std::get<0>(errorInfo) == ErrorCode::NO_ERROR) {
     return;
   }
