diff --git a/src/data.hpp b/src/data.hpp
index 4d84933..ee84615 100644
--- a/src/data.hpp
+++ b/src/data.hpp
@@ -241,7 +241,7 @@
 inline size_t
 Data::wireEncode(EncodingImpl<T>& block, bool unsignedPortion/* = false*/) const
 {
-  size_t total_len = 0;
+  size_t totalLength = 0;
 
   // Data ::= DATA-TLV TLV-LENGTH
   //            Name
@@ -259,27 +259,27 @@
   if (!unsignedPortion)
     {
       // SignatureValue
-      total_len += prependBlock(block, m_signature.getValue());
+      totalLength += prependBlock(block, m_signature.getValue());
     }
 
   // SignatureInfo
-  total_len += prependBlock(block, m_signature.getInfo());
+  totalLength += prependBlock(block, m_signature.getInfo());
 
   // Content
-  total_len += prependBlock(block, getContent());
+  totalLength += prependBlock(block, getContent());
 
   // MetaInfo
-  total_len += getMetaInfo().wireEncode(block);
+  totalLength += getMetaInfo().wireEncode(block);
 
   // Name
-  total_len += getName().wireEncode(block);
+  totalLength += getName().wireEncode(block);
 
   if (!unsignedPortion)
     {
-      total_len += block.prependVarNumber (total_len);
-      total_len += block.prependVarNumber (Tlv::Data);
+      totalLength += block.prependVarNumber (totalLength);
+      totalLength += block.prependVarNumber (Tlv::Data);
     }
-  return total_len;
+  return totalLength;
 }
 
 inline const Block&
diff --git a/src/detail/pending-interest.hpp b/src/detail/pending-interest.hpp
index 4cfc48a..c481acc 100644
--- a/src/detail/pending-interest.hpp
+++ b/src/detail/pending-interest.hpp
@@ -20,62 +20,64 @@
   typedef function<void(const Interest&)> OnTimeout;
 
   /**
-   * Create a new PitEntry and set the timeoutTime_ based on the current time and the interest lifetime.
-   * @param interest A shared_ptr for the interest.
+   * @brief Create a new PitEntry and set the timeout based on the current time and
+   *        the interest lifetime.
+   *
+   * @param interest A shared_ptr for the interest
    * @param onData A function object to call when a matching data packet is received.
-   * @param onTimeout A function object to call if the interest times out.  If onTimeout is an empty OnTimeout(), this does not use it.
+   * @param onTimeout A function object to call if the interest times out.
+   *                  If onTimeout is an empty OnTimeout(), this does not use it.
    */
-  PendingInterest(const shared_ptr<const Interest>& interest, const OnData& onData, 
+  PendingInterest(const shared_ptr<const Interest>& interest, const OnData& onData,
                   const OnTimeout& onTimeout)
-    : interest_(interest),
-      onData_(onData), onTimeout_(onTimeout)
+    : interest_(interest)
+    , onData_(onData)
+    , m_onTimeout(onTimeout)
   {
     if (interest_->getInterestLifetime() >= time::milliseconds::zero())
-      timeout_ = time::steady_clock::now() + interest_->getInterestLifetime();
+      m_timeout = time::steady_clock::now() + interest_->getInterestLifetime();
     else
-      timeout_ = time::steady_clock::now() + DEFAULT_INTEREST_LIFETIME;
+      m_timeout = time::steady_clock::now() + DEFAULT_INTEREST_LIFETIME;
   }
-    
-  const shared_ptr<const Interest>& 
+
+  const shared_ptr<const Interest>&
   getInterest()
   {
     return interest_;
   }
-    
-  const OnData& 
+
+  const OnData&
   getOnData()
   {
     return onData_;
   }
-    
+
   /**
    * Check if this interest is timed out.
    * @return true if this interest timed out, otherwise false.
    */
-  bool 
+  bool
   isTimedOut(const time::steady_clock::TimePoint& now)
   {
-    return now >= timeout_;
+    return now >= m_timeout;
   }
 
   /**
-   * Call onTimeout_ (if defined).  This ignores exceptions from the onTimeout_.
+   * Call m_onTimeout (if defined).  This ignores exceptions from the m_onTimeout.
    */
-  void 
+  void
   callTimeout()
   {
-    if (onTimeout_) {
-      onTimeout_(*interest_);
+    if (m_onTimeout) {
+      m_onTimeout(*interest_);
     }
   }
-    
+
 private:
   shared_ptr<const Interest> interest_;
   const OnData onData_;
-  const OnTimeout onTimeout_;
-
-  /** The time when the interest times out in time::milliseconds according to getNowMilliseconds, or -1 for no timeout. */
-  time::steady_clock::TimePoint timeout_;
+  const OnTimeout m_onTimeout;
+  time::steady_clock::TimePoint m_timeout;
 };
 
 
@@ -86,18 +88,18 @@
  */
 struct MatchPendingInterestId
 {
-  MatchPendingInterestId(const PendingInterestId *pendingInterestId)
-    : id_(pendingInterestId)
+  MatchPendingInterestId(const PendingInterestId* pendingInterestId)
+    : m_id(pendingInterestId)
   {
   }
 
   bool
-  operator()(const shared_ptr<const PendingInterest> &pendingInterest) const
+  operator()(const shared_ptr<const PendingInterest>& pendingInterest) const
   {
-    return (reinterpret_cast<const PendingInterestId *>(pendingInterest.get()) == id_);
+    return (reinterpret_cast<const PendingInterestId*>(pendingInterest.get()) == m_id);
   }
 private:
-  const PendingInterestId *id_;
+  const PendingInterestId* m_id;
 };
 
 
diff --git a/src/detail/registered-prefix.hpp b/src/detail/registered-prefix.hpp
index 02a0ed7..36a55fa 100644
--- a/src/detail/registered-prefix.hpp
+++ b/src/detail/registered-prefix.hpp
@@ -13,10 +13,10 @@
 
 namespace ndn {
 
-class RegisteredPrefix {
+class RegisteredPrefix
+{
 public:
-  typedef function<void
-  (const Name&, const Interest&)> OnInterest;
+  typedef function<void (const Name&, const Interest&)> OnInterest;
 
   /**
    * Create a new PrefixEntry.
@@ -24,26 +24,26 @@
    * @param onInterest A function object to call when a matching data packet is received.
    */
   RegisteredPrefix(const Name& prefix, const OnInterest& onInterest)
-    : prefix_(new Name(prefix))
-    , onInterest_(onInterest)
+    : m_prefix(new Name(prefix))
+    , m_onInterest(onInterest)
   {
   }
-    
-  const Name& 
+
+  const Name&
   getPrefix() const
   {
-    return *prefix_;
+    return* m_prefix;
   }
-    
-  const OnInterest& 
+
+  const OnInterest&
   getOnInterest() const
   {
-    return onInterest_;
+    return m_onInterest;
   }
-    
+
 private:
-  shared_ptr<Name> prefix_;
-  const OnInterest onInterest_;
+  shared_ptr<Name> m_prefix;
+  const OnInterest m_onInterest;
 };
 
 
@@ -54,18 +54,18 @@
  */
 struct MatchRegisteredPrefixId
 {
-  MatchRegisteredPrefixId(const RegisteredPrefixId *registeredPrefixId)
-    : id_(registeredPrefixId)
+  MatchRegisteredPrefixId(const RegisteredPrefixId* registeredPrefixId)
+    : m_id(registeredPrefixId)
   {
   }
 
   bool
-  operator()(const shared_ptr<RegisteredPrefix> &registeredPrefix) const
+  operator()(const shared_ptr<RegisteredPrefix>& registeredPrefix) const
   {
-    return (reinterpret_cast<const RegisteredPrefixId *>(registeredPrefix.get()) == id_);
+    return (reinterpret_cast<const RegisteredPrefixId*>(registeredPrefix.get()) == m_id);
   }
 private:
-  const RegisteredPrefixId *id_;
+  const RegisteredPrefixId* m_id;
 };
 
 } // namespace ndn
diff --git a/src/encoding/block-helpers.hpp b/src/encoding/block-helpers.hpp
index c3ae196..e29a20c 100644
--- a/src/encoding/block-helpers.hpp
+++ b/src/encoding/block-helpers.hpp
@@ -25,7 +25,7 @@
 }
 
 inline uint64_t
-readNonNegativeInteger(const Block &block)
+readNonNegativeInteger(const Block& block)
 {
   Buffer::const_iterator begin = block.value_begin();
   return Tlv::readNonNegativeInteger(block.value_size(), begin, block.value_end());
@@ -41,7 +41,7 @@
 }
 
 inline Block
-dataBlock(uint32_t type, const char *data, size_t dataSize)
+dataBlock(uint32_t type, const char* data, size_t dataSize)
 {
   OBufferStream os;
   Tlv::writeVarNumber(os, type);
@@ -52,7 +52,7 @@
 }
 
 inline Block
-dataBlock(uint32_t type, const unsigned char *data, size_t dataSize)
+dataBlock(uint32_t type, const unsigned char* data, size_t dataSize)
 {
   return dataBlock(type, reinterpret_cast<const char*>(data), dataSize);
 }
diff --git a/src/encoding/block.cpp b/src/encoding/block.cpp
index a734c13..9c91aa8 100644
--- a/src/encoding/block.cpp
+++ b/src/encoding/block.cpp
@@ -110,7 +110,7 @@
   buf[0] = *tmp_begin;
   is.read(buf+1, length-1);
 
-  if(length != static_cast<uint64_t>(is.gcount()) + 1)
+  if (length != static_cast<uint64_t>(is.gcount()) + 1)
     {
       delete [] buf;
       throw Tlv::Error("Not enough data in the buffer to fully parse TLV");
diff --git a/src/encoding/block.hpp b/src/encoding/block.hpp
index eef9b3d..388bac5 100644
--- a/src/encoding/block.hpp
+++ b/src/encoding/block.hpp
@@ -385,7 +385,7 @@
 
 
 inline void
-Block::push_back(const Block &element)
+Block::push_back(const Block& element)
 {
   resetWire();
   m_subBlocks.push_back(element);
diff --git a/src/encoding/buffer.hpp b/src/encoding/buffer.hpp
index a97edc1..0b9c327 100644
--- a/src/encoding/buffer.hpp
+++ b/src/encoding/buffer.hpp
@@ -50,7 +50,7 @@
    * @param buf const pointer to buffer
    * @param length length of the buffer to copy
    */
-  Buffer(const void *buf, size_t length)
+  Buffer(const void* buf, size_t length)
     : std::vector<uint8_t>(reinterpret_cast<const uint8_t*>(buf),
                            reinterpret_cast<const uint8_t*>(buf) + length)
   {
@@ -69,7 +69,7 @@
     : std::vector<uint8_t>(first, last)
   {
   }
-  
+
   /**
    * @brief Get pointer to the first byte of the buffer
    */
@@ -126,7 +126,7 @@
   get() const
   {
     return reinterpret_cast<const T*>(&front());
-  }  
+  }
 };
 
 /// @cond include_hidden
@@ -138,19 +138,19 @@
 public:
   typedef char char_type;
   typedef boost::iostreams::sink_tag category;
-  
+
   buffer_append_device(Buffer& container)
   : m_container(container)
   {
   }
-  
+
   std::streamsize
   write(const char_type* s, std::streamsize n)
   {
     std::copy(s, s+n, std::back_inserter(m_container));
     return n;
   }
-  
+
 protected:
   Buffer& m_container;
 };
diff --git a/src/encoding/cryptopp/asn_ext.cpp b/src/encoding/cryptopp/asn_ext.cpp
index 7741314..052226a 100644
--- a/src/encoding/cryptopp/asn_ext.cpp
+++ b/src/encoding/cryptopp/asn_ext.cpp
@@ -17,7 +17,8 @@
 namespace ndn {
 
 size_t
-DEREncodeGeneralTime(CryptoPP::BufferedTransformation &bt, const time::system_clock::TimePoint& time)
+DEREncodeGeneralTime(CryptoPP::BufferedTransformation& bt,
+                     const time::system_clock::TimePoint& time)
 {
   std::string str = time::toIsoString(time);
   // For example, 20131226T232254
@@ -32,7 +33,8 @@
 }
 
 void
-BERDecodeTime(CryptoPP::BufferedTransformation &bt, time::system_clock::TimePoint& time)
+BERDecodeTime(CryptoPP::BufferedTransformation& bt,
+              time::system_clock::TimePoint& time)
 {
   byte b;
   if (!bt.Get(b) || (b != GENERALIZED_TIME && b != UTC_TIME))
@@ -48,14 +50,14 @@
 
   std::string str;
   str.assign (time_str.begin(), time_str.end());
-  
+
   if (b == UTC_TIME) {
     if (boost::lexical_cast<int>(str.substr(0,2)) < 50)
       str = "20" + str;
     else
       str = "19" + str;
   }
- 
+
   time = time::fromIsoString(str.substr(0, 8) + "T" + str.substr(8, 6));
 }
 
diff --git a/src/encoding/cryptopp/asn_ext.hpp b/src/encoding/cryptopp/asn_ext.hpp
index 9140ed9..5d726dc 100644
--- a/src/encoding/cryptopp/asn_ext.hpp
+++ b/src/encoding/cryptopp/asn_ext.hpp
@@ -15,17 +15,28 @@
 
 namespace ndn {
 
-namespace Asn {
-struct Error : public std::runtime_error { Error(const std::string& what) : std::runtime_error(what) {} };
-}
+namespace asn {
+
+class Error : public std::runtime_error
+{
+public:
+  explicit
+  Error(const std::string& what)
+    : std::runtime_error(what)
+  {
+  }
+};
+
+} // namespace asn
 
 size_t
-DEREncodeGeneralTime(CryptoPP::BufferedTransformation& bt, const time::system_clock::TimePoint& time);
+DEREncodeGeneralTime(CryptoPP::BufferedTransformation& bt,
+                     const time::system_clock::TimePoint& time);
 
 void
-BERDecodeTime(CryptoPP::BufferedTransformation& bt, time::system_clock::TimePoint& time);
+BERDecodeTime(CryptoPP::BufferedTransformation& bt,
+              time::system_clock::TimePoint& time);
 
 } // namespace ndn
 
 #endif // NDN_ASN_EXT_HPP
-
diff --git a/src/encoding/encoding-buffer.hpp b/src/encoding/encoding-buffer.hpp
index 4251fa9..78b1628 100644
--- a/src/encoding/encoding-buffer.hpp
+++ b/src/encoding/encoding-buffer.hpp
@@ -12,10 +12,6 @@
 
 #include "../common.hpp"
 
-#include <list>
-#include <exception>
-#include <algorithm>
-
 #include "buffer.hpp"
 #include "tlv.hpp"
 #include "block.hpp"
@@ -48,11 +44,11 @@
    * The caller should make sure that that reserveFromBack does not exceed totalReserve,
    * otherwise behavior is undefined.
    */
-  EncodingImpl (size_t totalReserve = 8800,
-                size_t reserveFromBack = 400)
-    : m_buffer (new Buffer (totalReserve))
+  EncodingImpl(size_t totalReserve = 8800,
+               size_t reserveFromBack = 400)
+    : m_buffer(new Buffer(totalReserve))
   {
-    m_begin = m_end = m_buffer->end () - (reserveFromBack < totalReserve ? reserveFromBack : 0);
+    m_begin = m_end = m_buffer->end() - (reserveFromBack < totalReserve ? reserveFromBack : 0);
   }
 
   /**
@@ -66,24 +62,24 @@
    * after sign operation.
    */
   explicit
-  EncodingImpl (const Block& block)
+  EncodingImpl(const Block& block)
     : m_buffer(const_pointer_cast<Buffer>(block.m_buffer))
     , m_begin(m_buffer->begin() + (block.begin() - m_buffer->begin()))
     , m_end(m_buffer->begin()   + (block.end()   - m_buffer->begin()))
   {
   }
-  
-  inline size_t
-  size () const;
 
   inline size_t
-  capacity () const;
+  size() const;
+
+  inline size_t
+  capacity() const;
 
   inline uint8_t*
-  buf ();
+  buf();
 
   inline const uint8_t*
-  buf () const;
+  buf() const;
 
   /**
    * @brief Create Block from the underlying EncodingBuffer
@@ -93,59 +89,59 @@
    *                     length in the Block, otherwise ignored
    */
   inline Block
-  block (bool verifyLength = true) const;
+  block(bool verifyLength = true) const;
 
   inline void
-  resize (size_t sz, bool addInFront);
+  resize(size_t size, bool addInFront);
 
   inline Buffer::iterator
-  begin ();
+  begin();
 
   inline Buffer::iterator
-  end ();
+  end();
 
   inline Buffer::const_iterator
-  begin () const;
+  begin() const;
 
   inline Buffer::const_iterator
-  end () const;
+  end() const;
 
   inline size_t
-  prependByte (uint8_t val);
+  prependByte(uint8_t value);
 
   inline size_t
-  prependByteArray (const uint8_t *arr, size_t len);
+  prependByteArray(const uint8_t* array, size_t length);
 
   inline size_t
-  prependNonNegativeInteger (uint64_t varNumber);
+  prependNonNegativeInteger(uint64_t varNumber);
 
   inline size_t
-  prependVarNumber (uint64_t varNumber);
+  prependVarNumber(uint64_t varNumber);
 
   inline size_t
-  appendByte (uint8_t val);
+  appendByte(uint8_t value);
 
   inline size_t
-  appendByteArray (const uint8_t *arr, size_t len);
+  appendByteArray(const uint8_t* array, size_t length);
 
   inline size_t
-  appendNonNegativeInteger (uint64_t varNumber);
+  appendNonNegativeInteger(uint64_t varNumber);
 
   inline size_t
-  appendVarNumber (uint64_t varNumber);
+  appendVarNumber(uint64_t varNumber);
 
   // inline void
-  // removeByteFromFront ();
+  // removeByteFromFront();
 
   // inline void
-  // removeByteFromEnd ();
+  // removeByteFromEnd();
 
   // inline void
-  // removeVarNumberFromFront (uint64_t varNumber);
+  // removeVarNumberFromFront(uint64_t varNumber);
 
   // inline void
-  // removeVarNumberFromBack (uint64_t varNumber);
-  
+  // removeVarNumberFromBack(uint64_t varNumber);
+
 private:
   BufferPtr m_buffer;
 
@@ -165,34 +161,34 @@
 class EncodingImpl<encoding::Estimator>
 {
 public:
-  EncodingImpl (size_t totalReserve = 8800,
-                size_t reserveFromBack = 400)
+  EncodingImpl(size_t totalReserve = 8800,
+               size_t reserveFromBack = 400)
   {
   }
 
   inline size_t
-  prependByte (uint8_t val);
+  prependByte(uint8_t value);
 
   inline size_t
-  prependByteArray (const uint8_t *arr, size_t len);
+  prependByteArray(const uint8_t* array, size_t length);
 
   inline size_t
-  prependNonNegativeInteger (uint64_t varNumber);
+  prependNonNegativeInteger(uint64_t varNumber);
 
   inline size_t
-  prependVarNumber (uint64_t varNumber);
+  prependVarNumber(uint64_t varNumber);
 
   inline size_t
-  appendByte (uint8_t val);
+  appendByte(uint8_t value);
 
   inline size_t
-  appendByteArray (const uint8_t *arr, size_t len);
+  appendByteArray(const uint8_t* array, size_t length);
 
   inline size_t
-  appendNonNegativeInteger (uint64_t varNumber);
+  appendNonNegativeInteger(uint64_t varNumber);
 
   inline size_t
-  appendVarNumber (uint64_t varNumber);
+  appendVarNumber(uint64_t varNumber);
 };
 
 
@@ -201,31 +197,31 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 inline size_t
-EncodingImpl<encoding::Buffer>::size () const
+EncodingImpl<encoding::Buffer>::size() const
 {
   return m_end - m_begin;
 }
 
 inline size_t
-EncodingImpl<encoding::Buffer>::capacity () const
+EncodingImpl<encoding::Buffer>::capacity() const
 {
-  return m_buffer->size ();
+  return m_buffer->size();
 }
 
 inline uint8_t*
-EncodingImpl<encoding::Buffer>::buf ()
+EncodingImpl<encoding::Buffer>::buf()
 {
   return &(*m_begin);
 }
 
 inline const uint8_t*
-EncodingImpl<encoding::Buffer>::buf () const
+EncodingImpl<encoding::Buffer>::buf() const
 {
   return &(*m_begin);
 }
 
 inline Block
-EncodingImpl<encoding::Buffer>::block (bool verifyLength/* = true*/) const
+EncodingImpl<encoding::Buffer>::block(bool verifyLength/* = true*/) const
 {
   return Block(m_buffer,
                m_begin, m_end,
@@ -233,56 +229,56 @@
 }
 
 inline void
-EncodingImpl<encoding::Buffer>::resize (size_t sz, bool addInFront)
+EncodingImpl<encoding::Buffer>::resize(size_t size, bool addInFront)
 {
   if (addInFront)
     {
-      size_t diff_end = m_buffer->end () - m_end;
-      size_t diff_begin = m_buffer->end () - m_begin;
+      size_t diff_end = m_buffer->end() - m_end;
+      size_t diff_begin = m_buffer->end() - m_begin;
 
-      Buffer* buf = new Buffer (sz);
-      std::copy_backward (m_buffer->begin (), m_buffer->end (), buf->end ());
+      Buffer* buf = new Buffer(size);
+      std::copy_backward(m_buffer->begin(), m_buffer->end(), buf->end());
 
-      m_buffer.reset (buf);
+      m_buffer.reset(buf);
 
-      m_end = m_buffer->end () - diff_end;
-      m_begin = m_buffer->end () - diff_begin;
+      m_end = m_buffer->end() - diff_end;
+      m_begin = m_buffer->end() - diff_begin;
     }
   else
     {
-      size_t diff_end = m_end - m_buffer->begin ();
-      size_t diff_begin = m_begin - m_buffer->begin ();
+      size_t diff_end = m_end - m_buffer->begin();
+      size_t diff_begin = m_begin - m_buffer->begin();
 
-      Buffer* buf = new Buffer (sz);
-      std::copy (m_buffer->begin (), m_buffer->end (), buf->begin ());
+      Buffer* buf = new Buffer(size);
+      std::copy(m_buffer->begin(), m_buffer->end(), buf->begin());
 
-      m_buffer.reset (buf);
+      m_buffer.reset(buf);
 
-      m_end = m_buffer->begin () + diff_end;
-      m_begin = m_buffer->begin () + diff_begin;      
+      m_end = m_buffer->begin() + diff_end;
+      m_begin = m_buffer->begin() + diff_begin;
     }
 }
 
 inline Buffer::iterator
-EncodingImpl<encoding::Buffer>::begin ()
+EncodingImpl<encoding::Buffer>::begin()
 {
   return m_begin;
 }
 
 inline Buffer::iterator
-EncodingImpl<encoding::Buffer>::end ()
+EncodingImpl<encoding::Buffer>::end()
 {
   return m_end;
 }
 
 inline Buffer::const_iterator
-EncodingImpl<encoding::Buffer>::begin () const
+EncodingImpl<encoding::Buffer>::begin() const
 {
   return m_begin;
 }
 
 inline Buffer::const_iterator
-EncodingImpl<encoding::Buffer>::end () const
+EncodingImpl<encoding::Buffer>::end() const
 {
   return m_end;
 }
@@ -293,69 +289,69 @@
 //////////////////////////////////////////////////////////
 
 inline size_t
-EncodingImpl<encoding::Buffer>::prependByte (uint8_t val)
+EncodingImpl<encoding::Buffer>::prependByte(uint8_t value)
 {
-  if (m_begin == m_buffer->begin ())
-    resize (m_buffer->size () * 2, true);
+  if (m_begin == m_buffer->begin())
+    resize(m_buffer->size() * 2, true);
 
   m_begin--;
-  *m_begin = val;
+  *m_begin = value;
   return 1;
 }
 
 inline size_t
-EncodingImpl<encoding::Estimator>::prependByte (uint8_t val)
+EncodingImpl<encoding::Estimator>::prependByte(uint8_t value)
 {
   return 1;
 }
 
 inline size_t
-EncodingImpl<encoding::Buffer>::prependByteArray (const uint8_t *arr, size_t len)
+EncodingImpl<encoding::Buffer>::prependByteArray(const uint8_t* array, size_t length)
 {
-  if ((m_buffer->begin () + len) > m_begin)
-    resize (m_buffer->size () * 2 + len, true);
+  if ((m_buffer->begin() + length) > m_begin)
+    resize(m_buffer->size() * 2 + length, true);
 
-  m_begin -= len;
-  std::copy (arr, arr + len, m_begin);
-  return len;
+  m_begin -= length;
+  std::copy(array, array + length, m_begin);
+  return length;
 }
 
 inline size_t
-EncodingImpl<encoding::Estimator>::prependByteArray (const uint8_t *arr, size_t len)
+EncodingImpl<encoding::Estimator>::prependByteArray(const uint8_t* array, size_t length)
 {
-  return len;
+  return length;
 }
 
 inline size_t
-EncodingImpl<encoding::Buffer>::prependNonNegativeInteger (uint64_t varNumber)
+EncodingImpl<encoding::Buffer>::prependNonNegativeInteger(uint64_t varNumber)
 {
   if (varNumber <= std::numeric_limits<uint8_t>::max()) {
-    return prependByte (static_cast<uint8_t> (varNumber));
+    return prependByte(static_cast<uint8_t>(varNumber));
   }
-  else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
-    uint16_t value = htobe16 (static_cast<uint16_t> (varNumber));
-    return prependByteArray (reinterpret_cast<const uint8_t*> (&value), 2);
+  else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
+    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+    return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
   }
-  else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
-    uint32_t value = htobe32 (static_cast<uint32_t> (varNumber));
-    return prependByteArray (reinterpret_cast<const uint8_t*> (&value), 4);
+  else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
+    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+    return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
   }
   else {
-    uint64_t value = htobe64 (varNumber);
-    return prependByteArray (reinterpret_cast<const uint8_t*> (&value), 8);
+    uint64_t value = htobe64(varNumber);
+    return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
   }
 }
 
 inline size_t
-EncodingImpl<encoding::Estimator>::prependNonNegativeInteger (uint64_t varNumber)
+EncodingImpl<encoding::Estimator>::prependNonNegativeInteger(uint64_t varNumber)
 {
   if (varNumber <= std::numeric_limits<uint8_t>::max()) {
     return 1;
   }
-  else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
+  else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
     return 2;
   }
-  else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
+  else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
     return 4;
   }
   else {
@@ -364,42 +360,42 @@
 }
 
 inline size_t
-EncodingImpl<encoding::Buffer>::prependVarNumber (uint64_t varNumber)
+EncodingImpl<encoding::Buffer>::prependVarNumber(uint64_t varNumber)
 {
   if (varNumber < 253) {
-    prependByte (static_cast<uint8_t> (varNumber));
+    prependByte(static_cast<uint8_t>(varNumber));
     return 1;
   }
-  else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
-    uint16_t value = htobe16 (static_cast<uint16_t> (varNumber));
-    prependByteArray (reinterpret_cast<const uint8_t*> (&value), 2);
-    prependByte (253);
+  else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
+    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+    prependByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
+    prependByte(253);
     return 3;
   }
-  else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
-    uint32_t value = htobe32 (static_cast<uint32_t> (varNumber));
-    prependByteArray (reinterpret_cast<const uint8_t*> (&value), 4);
-    prependByte (254);
+  else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
+    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+    prependByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
+    prependByte(254);
     return 5;
   }
   else {
-    uint64_t value = htobe64 (varNumber);
-    prependByteArray (reinterpret_cast<const uint8_t*> (&value), 8);
-    prependByte (255);
+    uint64_t value = htobe64(varNumber);
+    prependByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
+    prependByte(255);
     return 9;
   }
 }
 
 inline size_t
-EncodingImpl<encoding::Estimator>::prependVarNumber (uint64_t varNumber)
+EncodingImpl<encoding::Estimator>::prependVarNumber(uint64_t varNumber)
 {
   if (varNumber < 253) {
     return 1;
   }
-  else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
+  else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
     return 3;
   }
-  else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
+  else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
     return 5;
   }
   else {
@@ -412,94 +408,94 @@
 /////////////////////////////////////////////////////////
 
 inline size_t
-EncodingImpl<encoding::Buffer>::appendByte (uint8_t val)
+EncodingImpl<encoding::Buffer>::appendByte(uint8_t value)
 {
-  if (m_end == m_buffer->end ())
-    resize (m_buffer->size () * 2, false);
+  if (m_end == m_buffer->end())
+    resize(m_buffer->size() * 2, false);
 
-  *m_end = val;
+  *m_end = value;
   m_end++;
   return 1;
 }
 
 inline size_t
-EncodingImpl<encoding::Estimator>::appendByte (uint8_t val)
+EncodingImpl<encoding::Estimator>::appendByte(uint8_t value)
 {
   return 1;
 }
 
 inline size_t
-EncodingImpl<encoding::Buffer>::appendByteArray (const uint8_t *arr, size_t len)
+EncodingImpl<encoding::Buffer>::appendByteArray(const uint8_t* array, size_t length)
 {
-  if ((m_end + len) > m_buffer->end ())
-    resize (m_buffer->size () * 2 + len, false);
+  if ((m_end + length) > m_buffer->end())
+    resize(m_buffer->size() * 2 + length, false);
 
-  std::copy (arr, arr + len, m_end);
-  m_end += len;
-  return len;
+  std::copy(array, array + length, m_end);
+  m_end += length;
+  return length;
 }
 
 inline size_t
-EncodingImpl<encoding::Estimator>::appendByteArray (const uint8_t *arr, size_t len)
+EncodingImpl<encoding::Estimator>::appendByteArray(const uint8_t* array, size_t length)
 {
-  return prependByteArray(arr, len);
+  return prependByteArray(array, length);
 }
 
 inline size_t
-EncodingImpl<encoding::Buffer>::appendNonNegativeInteger (uint64_t varNumber)
+EncodingImpl<encoding::Buffer>::appendNonNegativeInteger(uint64_t varNumber)
 {
-  if (varNumber <= std::numeric_limits<uint8_t>::max ()) {
-    return appendByte (static_cast<uint8_t> (varNumber));
+  if (varNumber <= std::numeric_limits<uint8_t>::max()) {
+    return appendByte(static_cast<uint8_t>(varNumber));
   }
-  else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
-    uint16_t value = htobe16 (static_cast<uint16_t> (varNumber));
-    return appendByteArray (reinterpret_cast<const uint8_t*> (&value), 2);
+  else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
+    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+    return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
   }
-  else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
-    uint32_t value = htobe32 (static_cast<uint32_t> (varNumber));
-    return appendByteArray (reinterpret_cast<const uint8_t*> (&value), 4);
+  else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
+    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+    return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
   }
   else {
-    uint64_t value = htobe64 (varNumber);
-    return appendByteArray (reinterpret_cast<const uint8_t*> (&value), 8);
+    uint64_t value = htobe64(varNumber);
+    return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
   }
 }
 
 inline size_t
-EncodingImpl<encoding::Estimator>::appendNonNegativeInteger (uint64_t varNumber)
+EncodingImpl<encoding::Estimator>::appendNonNegativeInteger(uint64_t varNumber)
 {
   return prependNonNegativeInteger(varNumber);
 }
 
 inline size_t
-EncodingImpl<encoding::Buffer>::appendVarNumber (uint64_t varNumber)
+EncodingImpl<encoding::Buffer>::appendVarNumber(uint64_t varNumber)
 {
   if (varNumber < 253) {
-    appendByte (static_cast<uint8_t> (varNumber));
+    appendByte(static_cast<uint8_t>(varNumber));
     return 1;
   }
-  else if (varNumber <= std::numeric_limits<uint16_t>::max ()) {
-    appendByte (253);
-    uint16_t value = htobe16 (static_cast<uint16_t> (varNumber));
-    appendByteArray (reinterpret_cast<const uint8_t*> (&value), 2);
+  else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
+    appendByte(253);
+    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
+    appendByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
     return 3;
   }
-  else if (varNumber <= std::numeric_limits<uint32_t>::max ()) {
-    appendByte (254);
-    uint32_t value = htobe32 (static_cast<uint32_t> (varNumber));
-    appendByteArray (reinterpret_cast<const uint8_t*> (&value), 4);
+  else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
+    appendByte(254);
+    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
+    appendByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
     return 5;
   }
   else {
-    appendByte (255);
-    uint64_t value = htobe64 (varNumber);
-    appendByteArray (reinterpret_cast<const uint8_t*> (&value), 8);
+    appendByte(255);
+    uint64_t value = htobe64(varNumber);
+    appendByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
     return 9;
   }
 }
 
 inline size_t
-EncodingImpl<encoding::Estimator>::appendVarNumber (uint64_t varNumber)
+EncodingImpl<encoding::Estimator>::appendVarNumber(uint64_t varNumber)
 {
   return prependVarNumber(varNumber);
 }
@@ -508,56 +504,57 @@
 
 template<bool P>
 inline size_t
-prependNonNegativeIntegerBlock(EncodingImpl<P>& blk, uint32_t type, uint64_t number)
+prependNonNegativeIntegerBlock(EncodingImpl<P>& encoder, uint32_t type, uint64_t number)
 {
-  size_t var_len = blk.prependNonNegativeInteger(number);
-  size_t total_len = var_len;
-  total_len += blk.prependVarNumber(var_len);
-  total_len += blk.prependVarNumber(type);
+  size_t valueLength = encoder.prependNonNegativeInteger(number);
+  size_t totalLength = valueLength;
+  totalLength += encoder.prependVarNumber(valueLength);
+  totalLength += encoder.prependVarNumber(type);
 
-  return total_len;
+  return totalLength;
 }
 
 template<bool P>
 inline size_t
-prependByteArrayBlock(EncodingImpl<P>& blk, uint32_t type, const uint8_t* array, size_t arraySize)
+prependByteArrayBlock(EncodingImpl<P>& encoder, uint32_t type,
+                      const uint8_t* array, size_t arraySize)
 {
-  size_t var_len = blk.prependByteArray(array, arraySize);
-  size_t total_len = var_len;
-  total_len += blk.prependVarNumber(var_len);
-  total_len += blk.prependVarNumber(type);
+  size_t valueLength = encoder.prependByteArray(array, arraySize);
+  size_t totalLength = valueLength;
+  totalLength += encoder.prependVarNumber(valueLength);
+  totalLength += encoder.prependVarNumber(type);
 
-  return total_len;
+  return totalLength;
 }
 
 template<bool P>
 inline size_t
-prependBooleanBlock(EncodingImpl<P>& blk, uint32_t type)
+prependBooleanBlock(EncodingImpl<P>& encoder, uint32_t type)
 {
-  size_t total_len = blk.prependVarNumber(0);
-  total_len += blk.prependVarNumber(type);
+  size_t totalLength = encoder.prependVarNumber(0);
+  totalLength += encoder.prependVarNumber(type);
 
-  return total_len;
+  return totalLength;
 }
 
 
 template<bool P, class U>
 inline size_t
-prependNestedBlock(EncodingImpl<P>& blk, uint32_t type, const U& nestedBlock)
+prependNestedBlock(EncodingImpl<P>& encoder, uint32_t type, const U& nestedBlock)
 {
-  size_t var_len = nestedBlock.wireEncode(blk);
-  size_t total_len = var_len;
-  total_len += blk.prependVarNumber(var_len);
-  total_len += blk.prependVarNumber(type);
+  size_t valueLength = nestedBlock.wireEncode(encoder);
+  size_t totalLength = valueLength;
+  totalLength += encoder.prependVarNumber(valueLength);
+  totalLength += encoder.prependVarNumber(type);
 
-  return total_len;
+  return totalLength;
 }
 
 template<bool P>
 inline size_t
-prependBlock(EncodingImpl<P>& blk, const Block& block)
+prependBlock(EncodingImpl<P>& encoder, const Block& block)
 {
-  return blk.prependByteArray(block.wire(), block.size());
+  return encoder.prependByteArray(block.wire(), block.size());
 }
 
 
diff --git a/src/encoding/oid.cpp b/src/encoding/oid.cpp
index 5f36473..cff98cd 100644
--- a/src/encoding/oid.cpp
+++ b/src/encoding/oid.cpp
@@ -16,7 +16,7 @@
 
 namespace ndn {
 
-OID::OID(const char *oid)
+OID::OID(const char* oid)
 {
   construct(oid);
 }
@@ -27,21 +27,21 @@
 }
 
 void
-OID::construct(const std::string &oid)
+OID::construct(const std::string& oid)
 {
   string str = oid + ".";
 
   size_t pos = 0;
   size_t ppos = 0;
 
-  while(string::npos != pos){
+  while (string::npos != pos) {
     ppos = pos;
 
     pos = str.find_first_of('.', pos);
-    if(pos == string::npos)
+    if (pos == string::npos)
       break;
 
-    oid_.push_back(atoi(str.substr(ppos, pos - ppos).c_str()));
+    m_oid.push_back(atoi(str.substr(ppos, pos - ppos).c_str()));
 
     pos++;
   }
@@ -50,54 +50,53 @@
 string OID::toString() const
 {
   ostringstream convert;
-  
-  vector<int>::const_iterator it = oid_.begin();
-  for(; it < oid_.end(); it++){
-    if(it != oid_.begin())
+
+  for (vector<int>::const_iterator it = m_oid.begin(); it != m_oid.end(); ++it) {
+    if (it != m_oid.begin())
       convert << ".";
     convert << *it;
   }
-  
+
   return convert.str();
 }
 
 bool
 OID::equal(const OID& oid) const
 {
-  vector<int>::const_iterator i = oid_.begin();
-  vector<int>::const_iterator j = oid.oid_.begin();
-    
-  for (; i != oid_.end () && j != oid.oid_.end (); i++, j++) {
-    if(*i != *j)
+  vector<int>::const_iterator i = m_oid.begin();
+  vector<int>::const_iterator j = oid.m_oid.begin();
+
+  for (; i != m_oid.end () && j != oid.m_oid.end (); i++, j++) {
+    if (*i != *j)
       return false;
   }
 
-  if (i == oid_.end () && j == oid.oid_.end ())
+  if (i == m_oid.end () && j == oid.m_oid.end ())
     return true;
   else
     return false;
 }
 
 inline void
-EncodeValue(BufferedTransformation &bt, word32 v)
+EncodeValue(BufferedTransformation& bt, word32 v)
 {
-  for (unsigned int i=RoundUpToMultipleOf(STDMAX(7U,BitPrecision(v)), 7U)-7; i != 0; i-=7)
+  for (unsigned int i = RoundUpToMultipleOf(STDMAX(7U,BitPrecision(v)), 7U) - 7; i != 0; i -= 7)
     bt.Put((byte)(0x80 | ((v >> i) & 0x7f)));
   bt.Put((byte)(v & 0x7f));
 }
 
 inline size_t
-DecodeValue(BufferedTransformation &bt, word32 &v)
+DecodeValue(BufferedTransformation& bt, word32& v)
 {
-  byte b;
-  size_t i=0;
   v = 0;
+  size_t i = 0;
   while (true)
     {
+      byte b;
       if (!bt.Get(b))
         BERDecodeError();
       i++;
-      if (v >> (8*sizeof(v)-7))	// v about to overflow
+      if (v >> (8*sizeof(v) - 7)) // v about to overflow
         BERDecodeError();
       v <<= 7;
       v += b & 0x7f;
@@ -107,20 +106,22 @@
 }
 
 void
-OID::encode(CryptoPP::BufferedTransformation &out) const
+OID::encode(CryptoPP::BufferedTransformation& out) const
 {
-  assert(oid_.size() >= 2);
+  BOOST_ASSERT(m_oid.size() >= 2);
+
   ByteQueue temp;
-  temp.Put(byte(oid_[0] * 40 + oid_[1]));
-  for (size_t i=2; i<oid_.size(); i++)
-    EncodeValue(temp, oid_[i]);
+  temp.Put(byte(m_oid[0] * 40 + m_oid[1]));
+  for (size_t i = 2; i < m_oid.size(); i++)
+    EncodeValue(temp, m_oid[i]);
+
   out.Put(OBJECT_IDENTIFIER);
   DERLengthEncode(out, temp.CurrentSize());
   temp.TransferTo(out);
 }
 
 void
-OID::decode(CryptoPP::BufferedTransformation &in)
+OID::decode(CryptoPP::BufferedTransformation& in)
 {
   byte b;
   if (!in.Get(b) || b != OBJECT_IDENTIFIER)
@@ -132,11 +133,11 @@
 
   if (!in.Get(b))
     BERDecodeError();
-	
+
   length--;
-  oid_.resize(2);
-  oid_[0] = b / 40;
-  oid_[1] = b % 40;
+  m_oid.resize(2);
+  m_oid[0] = b / 40;
+  m_oid[1] = b % 40;
 
   while (length > 0)
     {
@@ -144,9 +145,9 @@
       size_t valueLen = DecodeValue(in, v);
       if (valueLen > length)
         BERDecodeError();
-      oid_.push_back(v);
+      m_oid.push_back(v);
       length -= valueLen;
     }
 }
 
-}
+} // namespace ndn
diff --git a/src/encoding/oid.hpp b/src/encoding/oid.hpp
index 308da8e..e7b1beb 100644
--- a/src/encoding/oid.hpp
+++ b/src/encoding/oid.hpp
@@ -17,31 +17,31 @@
 
 class OID {
 public:
-  OID () 
+  OID ()
   {
   }
-    
-  OID(const char *oid);
+
+  OID(const char* oid);
 
   OID(const std::string& oid);
 
   OID(const std::vector<int>& oid)
-  : oid_(oid)
+    : m_oid(oid)
   {
   }
 
-  const std::vector<int> &
+  const std::vector<int>&
   getIntegerList() const
   {
-    return oid_;
+    return m_oid;
   }
 
   void
   setIntegerList(const std::vector<int>& value){
-    oid_ = value;
+    m_oid = value;
   }
 
-  std::string 
+  std::string
   toString() const;
 
   bool operator == (const OID& oid) const
@@ -55,21 +55,21 @@
   }
 
   void
-  encode(CryptoPP::BufferedTransformation &out) const;
+  encode(CryptoPP::BufferedTransformation& out) const;
 
   void
-  decode(CryptoPP::BufferedTransformation &in);
+  decode(CryptoPP::BufferedTransformation& in);
 
 
 private:
   void
-  construct(const std::string &value);
-  
+  construct(const std::string& value);
+
   bool
   equal(const OID& oid) const;
 
 private:
-  std::vector<int> oid_;
+  std::vector<int> m_oid;
 };
 
 }
diff --git a/src/exclude.hpp b/src/exclude.hpp
index c38e9f9..9fb5c3a 100644
--- a/src/exclude.hpp
+++ b/src/exclude.hpp
@@ -44,6 +44,15 @@
   Exclude();
 
   /**
+   * @brief Create from wire encoding
+   */
+  explicit
+  Exclude(const Block& wire)
+  {
+    wireDecode(wire);
+  }
+
+  /**
    * @brief Fast encoding or block size estimation
    */
   template<bool T>
@@ -245,7 +254,7 @@
 inline size_t
 Exclude::wireEncode(EncodingImpl<T>& block) const
 {
-  size_t total_len = 0;
+  size_t totalLength = 0;
 
   // Exclude ::= EXCLUDE-TYPE TLV-LENGTH Any? (NameComponent (Any)?)+
   // Any     ::= ANY-TYPE TLV-LENGTH(=0)
@@ -254,17 +263,17 @@
     {
       if (i->second)
         {
-          total_len += prependBooleanBlock(block, Tlv::Any);
+          totalLength += prependBooleanBlock(block, Tlv::Any);
         }
       if (!i->first.empty())
         {
-          total_len += i->first.wireEncode(block);
+          totalLength += i->first.wireEncode(block);
         }
     }
 
-  total_len += block.prependVarNumber(total_len);
-  total_len += block.prependVarNumber(Tlv::Exclude);
-  return total_len;
+  totalLength += block.prependVarNumber(totalLength);
+  totalLength += block.prependVarNumber(Tlv::Exclude);
+  return totalLength;
 }
 
 inline const Block&
diff --git a/src/face.cpp b/src/face.cpp
index 04e2570..3e5a4b1 100644
--- a/src/face.cpp
+++ b/src/face.cpp
@@ -271,12 +271,12 @@
       m_ioService->run();
       m_ioService->reset(); // so it is possible to run processEvents again (if necessary)
     }
-  catch(Face::ProcessEventsTimeout&)
+  catch (Face::ProcessEventsTimeout&)
     {
       // break
       m_ioService->reset();
     }
-  catch(const std::exception&)
+  catch (const std::exception&)
     {
       m_ioService->reset();
       m_pendingInterestTable.clear();
diff --git a/src/face.hpp b/src/face.hpp
index d168e73..2920a7d 100644
--- a/src/face.hpp
+++ b/src/face.hpp
@@ -54,7 +54,15 @@
 class Face : noncopyable
 {
 public:
-  struct Error : public std::runtime_error { Error(const std::string& what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
   /**
    * @brief Create a new Face for communication with an NDN Forwarder using the default UnixTransport.
@@ -110,7 +118,7 @@
    */
   void
   setController(const shared_ptr<Controller>& controller);
-  
+
   /**
    * @brief Express Interest
    *
@@ -140,7 +148,7 @@
   expressInterest(const Name& name,
                   const Interest& tmpl,
                   const OnData& onData, const OnTimeout& onTimeout = OnTimeout());
-  
+
   /**
    * Remove the pending interest entry with the pendingInterestId from the pending interest table.
    * This does not affect another pending interest with a different pendingInterestId, even it if has the same interest name.
@@ -149,7 +157,7 @@
    */
   void
   removePendingInterest(const PendingInterestId* pendingInterestId);
-  
+
   /**
    * Register prefix with the connected NDN hub and call onInterest when a matching interest is received.
    * @param prefix A reference to a Name for the prefix to register.  This copies the Name.
@@ -166,7 +174,7 @@
                     const OnSetInterestFilterFailed& onSetInterestFilterFailed);
 
   /**
-   * Remove the registered prefix entry with the registeredPrefixId from the pending interest table.  
+   * Remove the registered prefix entry with the registeredPrefixId from the pending interest table.
    * This does not affect another registered prefix with a different registeredPrefixId, even it if has the same prefix name.
    * If there is no entry with the registeredPrefixId, do nothing.
    * @param registeredPrefixId The ID returned from registerPrefix.
@@ -182,7 +190,7 @@
    */
   void
   put(const Data& data);
- 
+
   /**
    * Process any data to receive or call timeout callbacks.
    *
@@ -199,14 +207,14 @@
    * @throw This may throw an exception for reading data or in the callback for processing the data.  If you
    * call this from an main event loop, you may want to catch and log/disregard all exceptions.
    */
-  void 
+  void
   processEvents(const time::milliseconds& timeout = time::milliseconds::zero(),
                 bool keepThread = false);
 
-  void 
+  void
   shutdown();
 
-  shared_ptr<boost::asio::io_service> 
+  shared_ptr<boost::asio::io_service>
   ioService() { return m_ioService; }
 
 private:
@@ -226,11 +234,11 @@
 
   bool
   isSupportedNdndProtocol(const std::string& protocol);
-  
+
   struct ProcessEventsTimeout {};
   typedef std::list<shared_ptr<PendingInterest> > PendingInterestTable;
   typedef std::list<shared_ptr<RegisteredPrefix> > RegisteredPrefixTable;
-  
+
   void
   asyncExpressInterest(const shared_ptr<const Interest>& interest,
                        const OnData& onData, const OnTimeout& onTimeout);
@@ -243,13 +251,13 @@
 
   void
   finalizeUnsetInterestFilter(RegisteredPrefixTable::iterator item);
-  
-  void 
+
+  void
   onReceiveElement(const Block& wire);
 
   void
   asyncShutdown();
-  
+
   static void
   fireProcessEventsTimeout(const boost::system::error_code& error);
 
@@ -258,7 +266,7 @@
 
   void
   processInterestFilters(Interest& interest);
-    
+
   void
   checkPitExpire();
 
@@ -268,7 +276,7 @@
   shared_ptr<monotonic_deadline_timer> m_pitTimeoutCheckTimer;
   bool m_pitTimeoutCheckTimerActive;
   shared_ptr<monotonic_deadline_timer> m_processEventsTimeoutTimer;
-  
+
   shared_ptr<Transport> m_transport;
 
   PendingInterestTable m_pendingInterestTable;
diff --git a/src/interest.cpp b/src/interest.cpp
index 314bdca..64dc817 100644
--- a/src/interest.cpp
+++ b/src/interest.cpp
@@ -11,8 +11,6 @@
 #include "util/random.hpp"
 #include "data.hpp"
 
-using namespace std;
-
 namespace ndn {
 
 const uint32_t&
diff --git a/src/interest.hpp b/src/interest.hpp
index 2e2b8af..3cfacf1 100644
--- a/src/interest.hpp
+++ b/src/interest.hpp
@@ -104,6 +104,9 @@
   {
   }
 
+  /**
+   * @brief Create from wire encoding
+   */
   explicit
   Interest(const Block& wire)
   {
@@ -462,7 +465,7 @@
 inline size_t
 Interest::wireEncode(EncodingImpl<T>& block) const
 {
-  size_t total_len = 0;
+  size_t totalLength = 0;
 
   // Interest ::= INTEREST-TYPE TLV-LENGTH
   //                Name
@@ -474,33 +477,35 @@
   // (reverse encoding)
 
   // InterestLifetime
-  if (getInterestLifetime() >= time::milliseconds::zero()
-      && getInterestLifetime() != DEFAULT_INTEREST_LIFETIME)
+  if (getInterestLifetime() >= time::milliseconds::zero() &&
+      getInterestLifetime() != DEFAULT_INTEREST_LIFETIME)
     {
-      total_len += prependNonNegativeIntegerBlock(block, Tlv::InterestLifetime, getInterestLifetime().count());
+      totalLength += prependNonNegativeIntegerBlock(block,
+                                                    Tlv::InterestLifetime,
+                                                    getInterestLifetime().count());
     }
 
   // Scope
   if (getScope() >= 0)
     {
-      total_len += prependNonNegativeIntegerBlock(block, Tlv::Scope, getScope());
+      totalLength += prependNonNegativeIntegerBlock(block, Tlv::Scope, getScope());
     }
 
   // Nonce
-  total_len += prependNonNegativeIntegerBlock(block, Tlv::Nonce, getNonce());
+  totalLength += prependNonNegativeIntegerBlock(block, Tlv::Nonce, getNonce());
 
   // Selectors
   if (!getSelectors().empty())
     {
-      total_len += getSelectors().wireEncode(block);
+      totalLength += getSelectors().wireEncode(block);
     }
 
   // Name
-  total_len += getName().wireEncode(block);
+  totalLength += getName().wireEncode(block);
 
-  total_len += block.prependVarNumber (total_len);
-  total_len += block.prependVarNumber (Tlv::Interest);
-  return total_len;
+  totalLength += block.prependVarNumber (totalLength);
+  totalLength += block.prependVarNumber (Tlv::Interest);
+  return totalLength;
 }
 
 inline const Block&
diff --git a/src/key-locator.hpp b/src/key-locator.hpp
index a139bf7..14a1b5e 100644
--- a/src/key-locator.hpp
+++ b/src/key-locator.hpp
@@ -37,7 +37,19 @@
   {
   }
 
-  KeyLocator(const Name& name);
+  KeyLocator(const Name& name)
+  {
+    setName(name);
+  }
+
+  /**
+   * @brief Create from wire encoding
+   */
+  explicit
+  KeyLocator(const Block& wire)
+  {
+    wireDecode(wire);
+  }
 
   ///////////////////////////////////////////////////////////////////////////////
 
@@ -53,7 +65,7 @@
 
   ///////////////////////////////////////////////////////////////////////////////
 
-   bool
+  bool
   empty() const
   {
     return m_type == KeyLocator_None;
@@ -87,12 +99,6 @@
   mutable Block m_wire;
 };
 
-inline
-KeyLocator::KeyLocator(const Name& name)
-{
-  setName(name);
-}
-
 template<bool T>
 inline size_t
 KeyLocator::wireEncode(EncodingImpl<T>& block) const
@@ -105,21 +111,21 @@
 
   // KeyLocatorDigest ::= KEY-LOCATOR-DIGEST-TYPE TLV-LENGTH BYTE+
 
-  size_t total_len = 0;
+  size_t totalLength = 0;
 
   switch (m_type) {
   case KeyLocator_None:
     break;
   case KeyLocator_Name:
-    total_len += m_name.wireEncode(block);
+    totalLength += m_name.wireEncode(block);
     break;
   default:
     throw Error("Unsupported KeyLocator type");
   }
 
-  total_len += block.prependVarNumber(total_len);
-  total_len += block.prependVarNumber(Tlv::KeyLocator);
-  return total_len;
+  totalLength += block.prependVarNumber(totalLength);
+  totalLength += block.prependVarNumber(Tlv::KeyLocator);
+  return totalLength;
 }
 
 inline const Block&
diff --git a/src/management/ndnd-controller.cpp b/src/management/ndnd-controller.cpp
index a283826..32a19cd 100644
--- a/src/management/ndnd-controller.cpp
+++ b/src/management/ndnd-controller.cpp
@@ -197,7 +197,7 @@
 
   Block::element_const_iterator val = content.elements_begin();
 
-  switch(val->type())
+  switch (val->type())
     {
     case tlv::ndnd::FaceInstance:
       {
@@ -243,7 +243,7 @@
 
   Block::element_const_iterator val = content.elements_begin();
 
-  switch(val->type())
+  switch (val->type())
     {
     case tlv::ndnd::ForwardingEntry:
       {
diff --git a/src/management/ndnd-face-instance.hpp b/src/management/ndnd-face-instance.hpp
index 60c07dc..530f10d 100644
--- a/src/management/ndnd-face-instance.hpp
+++ b/src/management/ndnd-face-instance.hpp
@@ -19,12 +19,12 @@
  */
 class FaceInstance {
 public:
-  FaceInstance(const std::string &action,
+  FaceInstance(const std::string& action,
                int64_t     faceId,
                uint32_t    ipProto,
-               const std::string &host,
-               const std::string &port,
-               const std::string &multicastInterface,
+               const std::string& host,
+               const std::string& port,
+               const std::string& multicastInterface,
                uint32_t    multicastTtl,
                const time::milliseconds& freshnessPeriod)
     : action_(action)
@@ -46,6 +46,15 @@
   {
   }
 
+  /**
+   * @brief Create from wire encoding
+   */
+  explicit
+  FaceInstance(const Block& wire)
+  {
+    wireDecode(wire);
+  }
+
   // Action
   const std::string&
   getAction() const { return action_; }
@@ -79,7 +88,7 @@
   getPort() const { return port_; }
 
   void
-  setPort(const std::string &port) { port_ = port; wire_.reset(); }
+  setPort(const std::string& port) { port_ = port; wire_.reset(); }
 
   // MulticastInterface
   const std::string&
@@ -113,7 +122,7 @@
   wireEncode() const;
 
   inline void
-  wireDecode(const Block &wire);
+  wireDecode(const Block& wire);
 
 private:
   std::string action_;
@@ -207,7 +216,7 @@
 }
 
 inline void
-FaceInstance::wireDecode(const Block &wire)
+FaceInstance::wireDecode(const Block& wire)
 {
   action_.clear();
   faceId_ = -1;
@@ -289,7 +298,7 @@
 }
 
 inline std::ostream&
-operator << (std::ostream &os, const FaceInstance &entry)
+operator << (std::ostream& os, const FaceInstance& entry)
 {
   os << "FaceInstance(";
 
diff --git a/src/management/ndnd-forwarding-entry.hpp b/src/management/ndnd-forwarding-entry.hpp
index 03272b1..a084964 100644
--- a/src/management/ndnd-forwarding-entry.hpp
+++ b/src/management/ndnd-forwarding-entry.hpp
@@ -40,6 +40,15 @@
   {
   }
 
+  /**
+   * @brief Create from wire encoding
+   */
+  explicit
+  ForwardingEntry(const Block& wire)
+  {
+    wireDecode(wire);
+  }
+
   const std::string&
   getAction() const { return action_; }
 
@@ -50,7 +59,7 @@
   getPrefix() const { return prefix_; }
 
   void
-  setPrefix(const Name &prefix) { prefix_ = prefix; wire_.reset(); }
+  setPrefix(const Name& prefix) { prefix_ = prefix; wire_.reset(); }
 
   int
   getFaceId() const { return faceId_; }
@@ -74,7 +83,7 @@
   wireEncode() const;
 
   inline void
-  wireDecode(const Block &wire);
+  wireDecode(const Block& wire);
 
 private:
   std::string action_;   /**< empty for none. */
@@ -135,7 +144,7 @@
 }
 
 inline void
-ForwardingEntry::wireDecode(const Block &wire)
+ForwardingEntry::wireDecode(const Block& wire)
 {
   action_.clear();
   prefix_.clear();
@@ -190,7 +199,7 @@
 }
 
 inline std::ostream&
-operator << (std::ostream &os, const ForwardingEntry &entry)
+operator << (std::ostream& os, const ForwardingEntry& entry)
 {
   os << "ForwardingEntry(";
 
diff --git a/src/management/ndnd-forwarding-flags.hpp b/src/management/ndnd-forwarding-flags.hpp
index f238d06..803dabc 100644
--- a/src/management/ndnd-forwarding-flags.hpp
+++ b/src/management/ndnd-forwarding-flags.hpp
@@ -24,7 +24,7 @@
   /**
    * Create a new ForwardingFlags with "active" and "childInherit" set and all other flags cleared.
    */
-  ForwardingFlags() 
+  ForwardingFlags()
     : active_(true)
     , childInherit_(true)
     , advertise_(false)
@@ -37,47 +37,56 @@
   }
 
   /**
+   * @brief Create from wire encoding
+   */
+  explicit
+  ForwardingFlags(const Block& wire)
+  {
+    wireDecode(wire);
+  }
+
+  /**
    * Get the value of the "active" flag.
    * @return true if the flag is set, false if it is cleared.
    */
   bool getActive() const { return active_; }
-  
+
   /**
    * Get the value of the "childInherit" flag.
    * @return true if the flag is set, false if it is cleared.
    */
   bool getChildInherit() const { return childInherit_; }
-  
+
   /**
    * Get the value of the "advertise" flag.
    * @return true if the flag is set, false if it is cleared.
    */
   bool getAdvertise() const { return advertise_; }
-  
+
   /**
    * Get the value of the "last" flag.
    * @return true if the flag is set, false if it is cleared.
    */
   bool getLast() const { return last_; }
-  
+
   /**
    * Get the value of the "capture" flag.
    * @return true if the flag is set, false if it is cleared.
    */
   bool getCapture() const { return capture_; }
-  
+
   /**
    * Get the value of the "local" flag.
    * @return true if the flag is set, false if it is cleared.
    */
   bool getLocal() const { return local_; }
-  
+
   /**
    * Get the value of the "tap" flag.
    * @return true if the flag is set, false if it is cleared.
    */
   bool getTap() const { return tap_; }
-  
+
   /**
    * Get the value of the "captureOk" flag.
    * @return true if the flag is set, false if it is cleared.
@@ -87,57 +96,57 @@
   /**
    * Set the value of the "active" flag
    * @param active true to set the flag, false to clear it.
-   */  
+   */
   void setActive(bool active) { this->active_ = active; wire_.reset(); }
-  
+
   /**
    * Set the value of the "childInherit" flag
    * @param childInherit true to set the flag, false to clear it.
-   */  
+   */
   void setChildInherit(bool childInherit) { this->childInherit_ = childInherit; wire_.reset(); }
-  
+
   /**
    * Set the value of the "advertise" flag
    * @param advertise true to set the flag, false to clear it.
-   */  
+   */
   void setAdvertise(bool advertise) { this->advertise_ = advertise; wire_.reset(); }
-  
+
   /**
    * Set the value of the "last" flag
    * @param last true to set the flag, false to clear it.
-   */  
+   */
   void setLast(bool last) { this->last_ = last; wire_.reset(); }
-  
+
   /**
    * Set the value of the "capture" flag
    * @param capture true to set the flag, false to clear it.
-   */  
+   */
   void setCapture(bool capture) { this->capture_ = capture; wire_.reset(); }
-  
+
   /**
    * Set the value of the "local" flag
    * @param local true to set the flag, false to clear it.
-   */  
+   */
   void setLocal(bool local) { this->local_ = local; wire_.reset(); }
-  
+
   /**
    * Set the value of the "tap" flag
    * @param tap true to set the flag, false to clear it.
-   */  
+   */
   void setTap(bool tap) { this->tap_ = tap; wire_.reset(); }
-  
+
   /**
    * Set the value of the "captureOk" flag
    * @param captureOk true to set the flag, false to clear it.
-   */  
+   */
   void setCaptureOk(bool captureOk) { this->captureOk_ = captureOk; wire_.reset(); }
 
   inline const Block&
   wireEncode() const;
 
   inline void
-  wireDecode(const Block &block);
-  
+  wireDecode(const Block& block);
+
 private:
   bool active_;
   bool childInherit_;
@@ -174,19 +183,19 @@
     result |= tlv::ndnd::FORW_TAP;
   if (captureOk_)
     result |= tlv::ndnd::FORW_CAPTURE_OK;
-  
+
   wire_ = nonNegativeIntegerBlock(tlv::ndnd::ForwardingFlags, result);
 
   return wire_;
 }
 
 inline void
-ForwardingFlags::wireDecode(const Block &wire)
+ForwardingFlags::wireDecode(const Block& wire)
 {
   wire_ = wire;
 
   uint32_t flags = readNonNegativeInteger(wire_);
-  
+
   active_       = (flags & tlv::ndnd::FORW_ACTIVE)        ? true : false;
   childInherit_ = (flags & tlv::ndnd::FORW_CHILD_INHERIT) ? true : false;
   advertise_    = (flags & tlv::ndnd::FORW_ADVERTISE)     ? true : false;
@@ -198,7 +207,7 @@
 }
 
 inline std::ostream&
-operator << (std::ostream &os, const ForwardingFlags &flags)
+operator << (std::ostream& os, const ForwardingFlags& flags)
 {
   if (flags.getActive())
     os << "ACTIVE ";
diff --git a/src/management/ndnd-status-response.hpp b/src/management/ndnd-status-response.hpp
index e58de7e..23597b9 100644
--- a/src/management/ndnd-status-response.hpp
+++ b/src/management/ndnd-status-response.hpp
@@ -20,30 +20,39 @@
   {
   }
 
-  StatusResponse(uint32_t code, const std::string &info)
+  StatusResponse(uint32_t code, const std::string& info)
     : code_(code)
     , info_(info)
   {
   }
-  
+
+  /**
+   * @brief Create from wire encoding
+   */
+  explicit
+  StatusResponse(const Block& wire)
+  {
+    wireDecode(wire);
+  }
+
   inline uint32_t
   getCode() const;
 
   inline void
   setCode(uint32_t code);
 
-  inline const std::string &
+  inline const std::string&
   getInfo() const;
 
   inline void
-  setInfo(const std::string &info);
+  setInfo(const std::string& info);
 
   inline const Block&
   wireEncode() const;
 
   inline void
-  wireDecode(const Block &block);
-  
+  wireDecode(const Block& block);
+
 private:
   uint32_t code_;
   std::string info_;
@@ -64,14 +73,14 @@
   wire_.reset();
 }
 
-inline const std::string &
+inline const std::string&
 StatusResponse::getInfo() const
 {
   return info_;
 }
 
 inline void
-StatusResponse::setInfo(const std::string &info)
+StatusResponse::setInfo(const std::string& info)
 {
   info_ = info;
   wire_.reset();
@@ -93,13 +102,13 @@
       wire_.push_back
         (dataBlock(tlv::ndnd::StatusText, info_.c_str(), info_.size()));
     }
-  
-  wire_.encode();  
+
+  wire_.encode();
   return wire_;
 }
 
 inline void
-StatusResponse::wireDecode(const Block &wire)
+StatusResponse::wireDecode(const Block& wire)
 {
   wire_ = wire;
   wire_.parse();
@@ -114,7 +123,7 @@
 }
 
 inline std::ostream&
-operator << (std::ostream &os, const StatusResponse &status)
+operator << (std::ostream& os, const StatusResponse& status)
 {
   os << status.getCode() << " " << status.getInfo();
   return os;
diff --git a/src/management/nfd-control-response.hpp b/src/management/nfd-control-response.hpp
index c959407..a4a5ae3 100644
--- a/src/management/nfd-control-response.hpp
+++ b/src/management/nfd-control-response.hpp
@@ -20,14 +20,22 @@
  */
 class ControlResponse {
 public:
-  struct Error : public Tlv::Error { Error(const std::string &what) : Tlv::Error(what) {} };
+  class Error : public Tlv::Error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : Tlv::Error(what)
+    {
+    }
+  };
 
   ControlResponse()
     : m_code(200)
   {
   }
 
-  ControlResponse(uint32_t code, const std::string &text)
+  ControlResponse(uint32_t code, const std::string& text)
     : m_code(code)
     , m_text(text)
   {
@@ -37,31 +45,31 @@
   {
     wireDecode(block);
   }
-  
+
   inline uint32_t
   getCode() const;
 
   inline void
   setCode(uint32_t code);
 
-  inline const std::string &
+  inline const std::string&
   getText() const;
 
   inline void
-  setText(const std::string &text);
+  setText(const std::string& text);
 
   inline const Block&
   getBody() const;
 
   inline void
   setBody(const Block& body);
-  
+
   inline const Block&
   wireEncode() const;
 
   inline void
-  wireDecode(const Block &block);
-  
+  wireDecode(const Block& block);
+
 protected:
   uint32_t m_code;
   std::string m_text;
@@ -83,14 +91,14 @@
   m_wire.reset();
 }
 
-inline const std::string &
+inline const std::string&
 ControlResponse::getText() const
 {
   return m_text;
 }
 
 inline void
-ControlResponse::setText(const std::string &text)
+ControlResponse::setText(const std::string& text)
 {
   m_text = text;
   m_wire.reset();
@@ -128,27 +136,27 @@
     {
       m_wire.push_back(m_body);
     }
-  
-  m_wire.encode();  
+
+  m_wire.encode();
   return m_wire;
 }
 
 inline void
-ControlResponse::wireDecode(const Block &wire)
+ControlResponse::wireDecode(const Block& wire)
 {
   m_wire = wire;
   m_wire.parse();
 
   if (m_wire.type() != tlv::nfd::ControlResponse)
-    throw Error("Requested decoding of ControlResponse, but Block is of different type");  
-  
+    throw Error("Requested decoding of ControlResponse, but Block is of different type");
+
   Block::element_const_iterator val = m_wire.elements_begin();
   if (val == m_wire.elements_end() ||
       val->type() != tlv::nfd::StatusCode)
     {
       throw Error("Incorrect ControlResponse format (StatusCode missing or not the first item)");
     }
-  
+
   m_code = readNonNegativeInteger(*val);
   ++val;
 
@@ -167,7 +175,7 @@
 }
 
 inline std::ostream&
-operator << (std::ostream &os, const ControlResponse &status)
+operator << (std::ostream& os, const ControlResponse& status)
 {
   os << status.getCode() << " " << status.getText();
   return os;
diff --git a/src/management/nfd-local-control-header.hpp b/src/management/nfd-local-control-header.hpp
index d09fe8a..9bbdebf 100644
--- a/src/management/nfd-local-control-header.hpp
+++ b/src/management/nfd-local-control-header.hpp
@@ -16,7 +16,15 @@
 class LocalControlHeader
 {
 public:
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
   LocalControlHeader()
     : m_incomingFaceId(INVALID_FACE_ID)
@@ -25,6 +33,18 @@
   }
 
   /**
+   * @brief Create from wire encoding
+   *
+   * @sa wireDecode
+   */
+  explicit
+  LocalControlHeader(const Block& wire,
+                     bool encodeIncomingFaceId = true, bool encodeNextHopFaceId = true)
+  {
+    wireDecode(wire, encodeIncomingFaceId, encodeNextHopFaceId);
+  }
+
+  /**
    * @brief Create wire encoding with options LocalControlHeader and the supplied item
    *
    * The caller is responsible of checking whether LocalControlHeader contains
@@ -47,20 +67,20 @@
   inline Block
   wireEncode(const U& payload,
              bool encodeIncomingFaceId, bool encodeNextHopFaceId) const;
-  
+
   /**
    * @brief Decode from the wire format and set LocalControlHeader on the supplied item
    *
    * The supplied wire MUST contain LocalControlHeader.  Determination whether the optional
    * LocalControlHeader should be done before calling this method.
    */
-  inline void 
+  inline void
   wireDecode(const Block& wire,
              bool encodeIncomingFaceId = true, bool encodeNextHopFaceId = true);
 
   inline static const Block&
   getPayload(const Block& wire);
-  
+
   ///////////////////////////////////////////////////////////////////////////////
   ///////////////////////////////////////////////////////////////////////////////
   ///////////////////////////////////////////////////////////////////////////////
@@ -72,15 +92,15 @@
     return !((encodeIncomingFaceId && hasIncomingFaceId()) ||
              (encodeNextHopFaceId  && hasNextHopFaceId()));
   }
-  
+
   //
-  
+
   bool
   hasIncomingFaceId() const
   {
     return m_incomingFaceId != INVALID_FACE_ID;
   }
-  
+
   uint64_t
   getIncomingFaceId() const
   {
@@ -100,7 +120,7 @@
   {
     return m_nextHopFaceId != INVALID_FACE_ID;
   }
-  
+
   uint64_t
   getNextHopFaceId() const
   {
@@ -118,7 +138,7 @@
   inline size_t
   wireEncode(EncodingImpl<T>& block, size_t payloadSize,
              bool encodeIncomingFaceId, bool encodeNextHopFaceId) const;
-  
+
 private:
   uint64_t m_incomingFaceId;
   uint64_t m_nextHopFaceId;
@@ -133,23 +153,23 @@
 LocalControlHeader::wireEncode(EncodingImpl<T>& block, size_t payloadSize,
                                bool encodeIncomingFaceId, bool encodeNextHopFaceId) const
 {
-  size_t total_len = payloadSize;
+  size_t totalLength = payloadSize;
 
   if (encodeIncomingFaceId && hasIncomingFaceId())
     {
-      total_len += prependNonNegativeIntegerBlock(block,
-                                                  tlv::nfd::IncomingFaceId, getIncomingFaceId());
+      totalLength += prependNonNegativeIntegerBlock(block,
+                                                    tlv::nfd::IncomingFaceId, getIncomingFaceId());
     }
 
   if (encodeNextHopFaceId && hasNextHopFaceId())
     {
-      total_len += prependNonNegativeIntegerBlock(block,
-                                                  tlv::nfd::NextHopFaceId, getNextHopFaceId());
+      totalLength += prependNonNegativeIntegerBlock(block,
+                                                    tlv::nfd::NextHopFaceId, getNextHopFaceId());
     }
-  
-  total_len += block.prependVarNumber(total_len);
-  total_len += block.prependVarNumber(tlv::nfd::LocalControlHeader);
-  return total_len;
+
+  totalLength += block.prependVarNumber(totalLength);
+  totalLength += block.prependVarNumber(tlv::nfd::LocalControlHeader);
+  return totalLength;
 }
 
 template<class U>
@@ -164,7 +184,7 @@
   EncodingEstimator estimator;
   size_t length = wireEncode(estimator, payload.wireEncode().size(),
                              encodeIncomingFaceId, encodeNextHopFaceId);
-  
+
   EncodingBuffer buffer(length);
   wireEncode(buffer, payload.wireEncode().size(),
              encodeIncomingFaceId, encodeNextHopFaceId);
@@ -172,7 +192,7 @@
   return buffer.block(false);
 }
 
-inline void 
+inline void
 LocalControlHeader::wireDecode(const Block& wire,
                                bool encodeIncomingFaceId/* = true*/, bool encodeNextHopFaceId/* = true*/)
 {
@@ -186,7 +206,7 @@
        i != wire.elements_end();
        ++i)
     {
-      switch(i->type())
+      switch (i->type())
         {
         case tlv::nfd::IncomingFaceId:
           if (encodeIncomingFaceId)
diff --git a/src/management/nrd-controller.cpp b/src/management/nrd-controller.cpp
index 1d0e7a1..66156d2 100644
--- a/src/management/nrd-controller.cpp
+++ b/src/management/nrd-controller.cpp
@@ -115,7 +115,7 @@
       PrefixRegOptions options(response.getBody());
       return onSuccess(options);
     }
-  catch(ndn::Tlv::Error& e)
+  catch (ndn::Tlv::Error& e)
     {
       if (static_cast<bool>(onFail))
         return onFail(e.what());
diff --git a/src/management/nrd-prefix-reg-options.hpp b/src/management/nrd-prefix-reg-options.hpp
index c80d04b..2c37c4a 100644
--- a/src/management/nrd-prefix-reg-options.hpp
+++ b/src/management/nrd-prefix-reg-options.hpp
@@ -26,7 +26,15 @@
  */
 class PrefixRegOptions {
 public:
-  struct Error : public Tlv::Error { Error(const std::string& what) : Tlv::Error(what) {} };
+  class Error : public Tlv::Error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : Tlv::Error(what)
+    {
+    }
+  };
 
   PrefixRegOptions()
     : m_faceId(INVALID_FACE_ID)
@@ -36,6 +44,7 @@
   {
   }
 
+  explicit
   PrefixRegOptions(const Block& block)
   {
     wireDecode(block);
@@ -162,7 +171,7 @@
 inline size_t
 PrefixRegOptions::wireEncode(EncodingImpl<T>& block) const
 {
-  size_t total_len = 0;
+  size_t totalLength = 0;
 
   // PrefixRegOptions ::= PREFIX-REG-OPTIONS-TYPE TLV-LENGTH
   //                        Name
@@ -177,44 +186,44 @@
   // Protocol
   if (!m_protocol.empty())
     {
-      total_len += prependByteArrayBlock(block,
-                                         tlv::nrd::Protocol,
-                                         reinterpret_cast<const uint8_t*>(m_protocol.c_str()),
-                                         m_protocol.size());
+      totalLength += prependByteArrayBlock(block,
+                                           tlv::nrd::Protocol,
+                                           reinterpret_cast<const uint8_t*>(m_protocol.c_str()),
+                                           m_protocol.size());
     }
 
   // ExpirationPeriod
   if (m_expirationPeriod > time::milliseconds::zero())
     {
-      total_len += prependNonNegativeIntegerBlock(block,
-                                                  tlv::nrd::ExpirationPeriod,
-                                                  m_expirationPeriod.count());
+      totalLength += prependNonNegativeIntegerBlock(block,
+                                                    tlv::nrd::ExpirationPeriod,
+                                                    m_expirationPeriod.count());
     }
 
   // Cost
   if (m_cost != DEFAULT_COST)
     {
-      total_len += prependNonNegativeIntegerBlock(block, tlv::nrd::Cost, m_cost);
+      totalLength += prependNonNegativeIntegerBlock(block, tlv::nrd::Cost, m_cost);
     }
 
   // Flags
   if (m_flags != DEFAULT_FLAGS)
     {
-      total_len += prependNonNegativeIntegerBlock(block, tlv::nrd::Flags, m_flags);
+      totalLength += prependNonNegativeIntegerBlock(block, tlv::nrd::Flags, m_flags);
     }
 
   // FaceId
   if (m_faceId != INVALID_FACE_ID)
     {
-      total_len += prependNonNegativeIntegerBlock(block, tlv::nrd::FaceId, m_faceId);
+      totalLength += prependNonNegativeIntegerBlock(block, tlv::nrd::FaceId, m_faceId);
     }
 
   // Name
-  total_len += m_name.wireEncode(block);
+  totalLength += m_name.wireEncode(block);
 
-  total_len += block.prependVarNumber(total_len);
-  total_len += block.prependVarNumber(tlv::nrd::PrefixRegOptions);
-  return total_len;
+  totalLength += block.prependVarNumber(totalLength);
+  totalLength += block.prependVarNumber(tlv::nrd::PrefixRegOptions);
+  return totalLength;
 }
 
 inline const Block&
@@ -303,7 +312,7 @@
 }
 
 inline std::ostream&
-operator << (std::ostream &os, const PrefixRegOptions &option)
+operator << (std::ostream& os, const PrefixRegOptions& option)
 {
   os << "PrefixRegOptions(";
 
diff --git a/src/meta-info.hpp b/src/meta-info.hpp
index 8042f8b..4153911 100644
--- a/src/meta-info.hpp
+++ b/src/meta-info.hpp
@@ -28,6 +28,9 @@
   {
   }
 
+  /**
+   * @brief Create from wire encoding
+   */
   MetaInfo(const Block& block)
   {
     wireDecode(block);
@@ -118,30 +121,30 @@
   //                FreshnessPeriod?
   //                FinalBlockId?
 
-  size_t total_len = 0;
+  size_t totalLength = 0;
 
   // FinalBlockId
   if (!m_finalBlockId.empty())
     {
-      total_len += prependNestedBlock(blk, Tlv::FinalBlockId, m_finalBlockId);
+      totalLength += prependNestedBlock(blk, Tlv::FinalBlockId, m_finalBlockId);
     }
 
   // FreshnessPeriod
   if (m_freshnessPeriod >= time::milliseconds::zero())
     {
-      total_len += prependNonNegativeIntegerBlock(blk, Tlv::FreshnessPeriod,
-                                                  m_freshnessPeriod.count());
+      totalLength += prependNonNegativeIntegerBlock(blk, Tlv::FreshnessPeriod,
+                                                    m_freshnessPeriod.count());
     }
 
   // ContentType
   if (m_type != TYPE_DEFAULT)
     {
-      total_len += prependNonNegativeIntegerBlock(blk, Tlv::ContentType, m_type);
+      totalLength += prependNonNegativeIntegerBlock(blk, Tlv::ContentType, m_type);
     }
 
-  total_len += blk.prependVarNumber(total_len);
-  total_len += blk.prependVarNumber(Tlv::MetaInfo);
-  return total_len;
+  totalLength += blk.prependVarNumber(totalLength);
+  totalLength += blk.prependVarNumber(Tlv::MetaInfo);
+  return totalLength;
 }
 
 inline const Block&
diff --git a/src/name-component.hpp b/src/name-component.hpp
index 9ea09c5..5e5cb09 100644
--- a/src/name-component.hpp
+++ b/src/name-component.hpp
@@ -24,9 +24,17 @@
 class Component : public Block
 {
 public:
-  /// @brief Error that can be thrown from the block
-  struct Error : public std::runtime_error {
-    Error(const std::string& what) : std::runtime_error(what) {}
+  /**
+   * @brief Error that can be thrown from the block
+   */
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
   };
 
   /**
@@ -37,6 +45,8 @@
   /**
    * @brief Directly create component from wire block
    *
+   * Any block can be implicitly converted to name::Component
+   *
    * @throws Error if wire.type() is not Tlv::Component
    */
   Component(const Block& wire);
@@ -45,12 +55,14 @@
    * Create a new Name::Component, taking another pointer to the Blob value.
    * @param value A blob with a pointer to an immutable array.  The pointer is copied.
    */
+  explicit
   Component(const ConstBufferPtr& buffer);
 
   /**
    * Create a new Name::Component, copying the given value.
    * @param value The value byte array.
    */
+  explicit
   Component(const Buffer& value);
 
   /**
@@ -58,13 +70,13 @@
    * @param value Pointer to the value byte array.
    * @param valueLen Length of value.
    */
-  Component(const uint8_t *value, size_t valueLen);
+  Component(const uint8_t* value, size_t valueLen);
 
   template<class InputIterator>
   Component(InputIterator begin, InputIterator end);
 
   explicit
-  Component(const char *str);
+  Component(const char* str);
 
   explicit
   Component(const std::string& str);
@@ -77,6 +89,18 @@
   wireEncode(EncodingImpl<T>& block) const;
 
   /**
+   * @brief Encode to a wire format
+   */
+  inline const Block&
+  wireEncode() const;
+
+  /**
+   * @brief Decode from the wire format
+   */
+  inline void
+  wireDecode(const Block& wire);
+
+  /**
    * Make a Blob value by decoding the escapedString between beginOffset and endOffset according to the NDN URI Scheme.
    * If the escaped string is "", "." or ".." then return a Blob with a null pointer,
    * which means the component should be skipped in a URI name.
@@ -86,7 +110,7 @@
    * @return The Blob value. If the escapedString is not a valid escaped component, then the Blob is a null pointer.
    */
   static Component
-  fromEscapedString(const char *escapedString, size_t beginOffset, size_t endOffset);
+  fromEscapedString(const char* escapedString, size_t beginOffset, size_t endOffset);
 
   /**
    * Make a Blob value by decoding the escapedString according to the NDN URI Scheme.
@@ -96,7 +120,7 @@
    * @return The Blob value. If the escapedString is not a valid escaped component, then the Blob is a null pointer.
    */
   static Component
-  fromEscapedString(const char *escapedString)
+  fromEscapedString(const char* escapedString)
   {
     return fromEscapedString(escapedString, 0, ::strlen(escapedString));
   }
@@ -309,7 +333,7 @@
 }
 
 inline
-Component::Component(const uint8_t *value, size_t valueLen)
+Component::Component(const uint8_t* value, size_t valueLen)
   : Block (Tlv::NameComponent, ConstBufferPtr(new Buffer(value, valueLen)))
 {
 }
@@ -322,7 +346,7 @@
 }
 
 inline
-Component::Component(const char *str)
+Component::Component(const char* str)
   : Block (Tlv::NameComponent, ConstBufferPtr(new Buffer(str, ::strlen(str))))
 {
 }
@@ -348,17 +372,17 @@
       return Component();
     else
       // Remove 3 periods.
-      return Component((const uint8_t *)&value[3], value.size() - 3);
+      return Component(reinterpret_cast<const uint8_t*>(&value[3]), value.size() - 3);
   }
   else
-    return Component((const uint8_t *)&value[0], value.size());
+    return Component(reinterpret_cast<const uint8_t*>(&value[0]), value.size());
 }
 
 
 inline void
 Component::toEscapedString(std::ostream& result) const
 {
-  const uint8_t *valuePtr = value();
+  const uint8_t* valuePtr = value();
   size_t valueSize = value_size();
 
   bool gotNonDot = false;
@@ -448,14 +472,46 @@
 inline size_t
 Component::wireEncode(EncodingImpl<T>& block) const
 {
-  size_t total_len = 0;
+  size_t totalLength = 0;
   if (value_size() > 0)
-    total_len += block.prependByteArray (value(), value_size());
-  total_len += block.prependVarNumber (value_size());
-  total_len += block.prependVarNumber (Tlv::NameComponent);
-  return total_len;
+    totalLength += block.prependByteArray (value(), value_size());
+  totalLength += block.prependVarNumber (value_size());
+  totalLength += block.prependVarNumber (Tlv::NameComponent);
+  return totalLength;
 }
 
+/**
+ * @brief Encode to a wire format
+ */
+inline const Block&
+Component::wireEncode() const
+{
+  if (this->hasWire())
+    return *this;
+
+  EncodingEstimator estimator;
+  size_t estimatedSize = wireEncode(estimator);
+
+  EncodingBuffer buffer(estimatedSize, 0);
+  wireEncode(buffer);
+
+  const_cast<Component&>(*this) = buffer.block();
+  return *this;
+}
+
+/**
+ * @brief Decode from the wire format
+ */
+inline void
+Component::wireDecode(const Block& wire)
+{
+  if (wire.type() != Tlv::NameComponent)
+    throw Error("wireDecode name component from non name component TLV wire block");
+
+  *this = wire;
+}
+
+
 } // namespace name
 } // namespace ndn
 
diff --git a/src/name.hpp b/src/name.hpp
index 5a8dfcf..03030f0 100644
--- a/src/name.hpp
+++ b/src/name.hpp
@@ -117,7 +117,7 @@
    * @param uri The null-terminated URI string.
    */
   void
-  set(const char *uri);
+  set(const char* uri);
 
   /**
    * Parse the uri according to the NDN URI Scheme and set the name with the components.
@@ -311,14 +311,20 @@
    * @brief Check if name is emtpy
    */
   bool
-  empty() const { return m_nameBlock.elements().empty(); }
+  empty() const
+  {
+    return m_nameBlock.elements().empty();
+  }
 
   /**
    * Get the number of components.
    * @return The number of components.
    */
   size_t
-  size() const { return m_nameBlock.elements_size(); }
+  size() const
+  {
+    return m_nameBlock.elements_size();
+  }
 
   /**
    * Get the component at the given index.
@@ -394,7 +400,10 @@
    * @return true if the names are equal, otherwise false.
    */
   bool
-  operator==(const Name& name) const { return equals(name); }
+  operator==(const Name& name) const
+  {
+    return equals(name);
+  }
 
   /**
    * Check if this name has the same component count and components as the given name.
@@ -402,7 +411,10 @@
    * @return true if the names are not equal, otherwise false.
    */
   bool
-  operator!=(const Name& name) const { return !equals(name); }
+  operator!=(const Name& name) const
+  {
+    return !equals(name);
+  }
 
   /**
    * Return true if this is less than or equal to the other Name in the NDN canonical ordering.
@@ -411,7 +423,10 @@
    * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order
    */
   bool
-  operator<=(const Name& other) const { return compare(other) <= 0; }
+  operator<=(const Name& other) const
+  {
+    return compare(other) <= 0;
+  }
 
   /**
    * Return true if this is less than the other Name in the NDN canonical ordering.
@@ -420,7 +435,10 @@
    * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order
    */
   bool
-  operator<(const Name& other) const { return compare(other) < 0; }
+  operator<(const Name& other) const
+  {
+    return compare(other) < 0;
+  }
 
   /**
    * Return true if this is less than or equal to the other Name in the NDN canonical ordering.
@@ -429,7 +447,10 @@
    * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order
    */
   bool
-  operator>=(const Name& other) const { return compare(other) >= 0; }
+  operator>=(const Name& other) const
+  {
+    return compare(other) >= 0;
+  }
 
   /**
    * Return true if this is greater than the other Name in the NDN canonical ordering.
@@ -438,7 +459,10 @@
    * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order
    */
   bool
-  operator>(const Name& other) const { return compare(other) > 0; }
+  operator>(const Name& other) const
+  {
+    return compare(other) > 0;
+  }
 
   //
   // Iterator interface to name components.
@@ -681,18 +705,18 @@
 inline size_t
 Name::wireEncode(EncodingImpl<T>& blk) const
 {
-  size_t total_len = 0;
+  size_t totalLength = 0;
 
   for (const_reverse_iterator i = rbegin();
        i != rend();
        ++i)
     {
-      total_len += i->wireEncode(blk);
+      totalLength += i->wireEncode(blk);
     }
 
-  total_len += blk.prependVarNumber(total_len);
-  total_len += blk.prependVarNumber(Tlv::Name);
-  return total_len;
+  totalLength += blk.prependVarNumber(totalLength);
+  totalLength += blk.prependVarNumber(Tlv::Name);
+  return totalLength;
 }
 
 inline const Block&
diff --git a/src/security/certificate-cache-ttl.cpp b/src/security/certificate-cache-ttl.cpp
index 8dea438..0a9002e 100644
--- a/src/security/certificate-cache-ttl.cpp
+++ b/src/security/certificate-cache-ttl.cpp
@@ -50,7 +50,7 @@
 }
 
 void
-CertificateCacheTtl::remove(const Name &certificateName)
+CertificateCacheTtl::remove(const Name& certificateName)
 {
   Name name = certificateName.getPrefix(-1);
   Cache::iterator it = m_cache.find(name);
@@ -59,7 +59,7 @@
 }
 
 ptr_lib::shared_ptr<const IdentityCertificate>
-CertificateCacheTtl::getCertificate(const Name & certificateName)
+CertificateCacheTtl::getCertificate(const Name& certificateName)
 {
   Cache::iterator it = m_cache.find(certificateName);
   if(it != m_cache.end())
diff --git a/src/security/certificate-cache-ttl.hpp b/src/security/certificate-cache-ttl.hpp
index 1e31e9c..4f65d17 100644
--- a/src/security/certificate-cache-ttl.hpp
+++ b/src/security/certificate-cache-ttl.hpp
@@ -27,14 +27,14 @@
   insertCertificate(ptr_lib::shared_ptr<const IdentityCertificate> certificate);
 
   virtual ptr_lib::shared_ptr<const IdentityCertificate>
-  getCertificate(const Name & certificateNameWithoutVersion);
+  getCertificate(const Name& certificateNameWithoutVersion);
 
 private:
   void
   insert(ptr_lib::shared_ptr<const IdentityCertificate> certificate);
 
   void
-  remove(const Name &certificateName);
+  remove(const Name& certificateName);
 
 protected:
   typedef std::map<Name, ptr_lib::shared_ptr<const IdentityCertificate> > Cache;
diff --git a/src/security/certificate-extension.cpp b/src/security/certificate-extension.cpp
index 7ee0de9..3a23a80 100644
--- a/src/security/certificate-extension.cpp
+++ b/src/security/certificate-extension.cpp
@@ -17,7 +17,7 @@
 namespace ndn {
 
 void
-CertificateExtension::encode(CryptoPP::BufferedTransformation &out) const
+CertificateExtension::encode(CryptoPP::BufferedTransformation& out) const
 {
   // Extension ::= SEQUENCE {
   //        extnID      OBJECT IDENTIFIER,
@@ -34,7 +34,7 @@
 }
 
 void
-CertificateExtension::decode(CryptoPP::BufferedTransformation &in)
+CertificateExtension::decode(CryptoPP::BufferedTransformation& in)
 {
   // Extension ::= SEQUENCE {
   //        extnID      OBJECT IDENTIFIER,
@@ -54,5 +54,5 @@
   }
   extension.MessageEnd();
 }
- 
+
 } // namespace ndn
diff --git a/src/security/certificate-extension.hpp b/src/security/certificate-extension.hpp
index 4eba4f2..1388107 100644
--- a/src/security/certificate-extension.hpp
+++ b/src/security/certificate-extension.hpp
@@ -23,9 +23,17 @@
 class CertificateExtension
 {
 public:
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
-  CertificateExtension(CryptoPP::BufferedTransformation &in)
+  CertificateExtension(CryptoPP::BufferedTransformation& in)
   {
     decode(in);
   }
@@ -45,7 +53,7 @@
     : extensionId_(oid), isCritical_(isCritical), extensionValue_(value, valueSize)
   {
   }
-  
+
   /**
    * The virtual destructor.
    */
@@ -53,20 +61,20 @@
   ~CertificateExtension() {}
 
   void
-  encode(CryptoPP::BufferedTransformation &out) const;
+  encode(CryptoPP::BufferedTransformation& out) const;
 
   void
-  decode(CryptoPP::BufferedTransformation &in);
-  
-  inline const OID& 
+  decode(CryptoPP::BufferedTransformation& in);
+
+  inline const OID&
   getOid() const { return extensionId_; }
 
-  inline const bool 
+  inline const bool
   getIsCritical() const { return isCritical_; }
 
-  inline const Buffer& 
+  inline const Buffer&
   getValue() const { return extensionValue_; }
-    
+
 protected:
   OID extensionId_;
   bool isCritical_;
diff --git a/src/security/certificate-subject-description.cpp b/src/security/certificate-subject-description.cpp
index fc6478f..44cd8c5 100644
--- a/src/security/certificate-subject-description.cpp
+++ b/src/security/certificate-subject-description.cpp
@@ -18,17 +18,17 @@
 namespace ndn {
 
 void
-CertificateSubjectDescription::encode(CryptoPP::BufferedTransformation &out) const
+CertificateSubjectDescription::encode(CryptoPP::BufferedTransformation& out) const
 {
   // RelativeDistinguishedName ::=
   //     SET OF AttributeTypeAndValue
-  // 
+  //
   // AttributeTypeAndValue ::= SEQUENCE {
   //     type     AttributeType,
   //     value    AttributeValue   }
-  // 
+  //
   // AttributeType ::= OBJECT IDENTIFIER
-  // 
+  //
   // AttributeValue ::= ANY DEFINED BY AttributeType
   DERSequenceEncoder attributeTypeAndValue(out);
   {
@@ -39,17 +39,17 @@
 }
 
 void
-CertificateSubjectDescription::decode(CryptoPP::BufferedTransformation &in)
+CertificateSubjectDescription::decode(CryptoPP::BufferedTransformation& in)
 {
   // RelativeDistinguishedName ::=
   //     SET OF AttributeTypeAndValue
-  // 
+  //
   // AttributeTypeAndValue ::= SEQUENCE {
   //     type     AttributeType,
   //     value    AttributeValue   }
-  // 
+  //
   // AttributeType ::= OBJECT IDENTIFIER
-  // 
+  //
   // AttributeValue ::= ANY DEFINED BY AttributeType
 
   BERSequenceDecoder attributeTypeAndValue(in);
diff --git a/src/security/certificate-subject-description.hpp b/src/security/certificate-subject-description.hpp
index 5510f6e..859aed3 100644
--- a/src/security/certificate-subject-description.hpp
+++ b/src/security/certificate-subject-description.hpp
@@ -21,39 +21,39 @@
  */
 class CertificateSubjectDescription {
 public:
-  CertificateSubjectDescription(CryptoPP::BufferedTransformation &in)
+  CertificateSubjectDescription(CryptoPP::BufferedTransformation& in)
   {
     decode(in);
   }
-  
+
   /**
    * Create a new CertificateSubjectDescription.
    * @param oid The oid of the subject description entry.
    * @param value The value of the subject description entry.
    */
-  CertificateSubjectDescription(const OID &oid, const std::string &value)
+  CertificateSubjectDescription(const OID& oid, const std::string& value)
   : oid_(oid), value_(value)
   {
   }
 
   void
-  encode(CryptoPP::BufferedTransformation &out) const;
+  encode(CryptoPP::BufferedTransformation& out) const;
 
   void
-  decode(CryptoPP::BufferedTransformation &in);
-  
+  decode(CryptoPP::BufferedTransformation& in);
+
   std::string
   getOidString() const
   {
     return oid_.toString();
   }
 
-  const std::string &
+  const std::string&
   getValue() const
   {
     return value_;
   }
-  
+
 private:
   OID oid_;
   std::string value_;
diff --git a/src/security/certificate.cpp b/src/security/certificate.cpp
index eb45d6f..3c4ed2d 100644
--- a/src/security/certificate.cpp
+++ b/src/security/certificate.cpp
@@ -45,7 +45,7 @@
 bool
 Certificate::isTooEarly()
 {
-  if(time::system_clock::now() < notBefore_)
+  if (time::system_clock::now() < notBefore_)
     return true;
   else
     return false;
@@ -54,7 +54,7 @@
 bool
 Certificate::isTooLate()
 {
-  if(time::system_clock::now() > notAfter_)
+  if (time::system_clock::now() > notAfter_)
     return true;
   else
     return false;
@@ -143,7 +143,7 @@
     //        extnID      OBJECT IDENTIFIER,
     //        critical    BOOLEAN DEFAULT FALSE,
     //        extnValue   OCTET STRING  }
-    if(!extensionList_.empty())
+    if (!extensionList_.empty())
       {
         DERSequenceEncoder extensions(idCert);
         {
@@ -215,7 +215,7 @@
     //        critical    BOOLEAN DEFAULT FALSE,
     //        extnValue   OCTET STRING  }
     extensionList_.clear();
-    if(!idCert.EndReached())
+    if (!idCert.EndReached())
       {
         BERSequenceDecoder extensions(idCert);
         {
@@ -232,7 +232,7 @@
 }
 
 void
-Certificate::printCertificate(std::ostream &os) const
+Certificate::printCertificate(std::ostream& os) const
 {
   os << "Certificate name:" << endl;
   os << "  " << getName() << endl;
diff --git a/src/security/certificate.hpp b/src/security/certificate.hpp
index d27f7a4..3470134 100644
--- a/src/security/certificate.hpp
+++ b/src/security/certificate.hpp
@@ -20,7 +20,15 @@
 
 class Certificate : public Data {
 public:
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
   typedef std::vector<CertificateSubjectDescription> SubjectDescriptionList;
   typedef std::vector<CertificateExtension> ExtensionList;
@@ -43,7 +51,7 @@
   ~Certificate();
 
   inline void
-  wireDecode(const Block &wire);
+  wireDecode(const Block& wire);
 
   /**
    * encode certificate info into content
@@ -122,7 +130,7 @@
   isTooLate();
 
   void
-  printCertificate(std::ostream &os) const;
+  printCertificate(std::ostream& os) const;
 
 protected:
   void
@@ -137,7 +145,7 @@
 };
 
 inline void
-Certificate::wireDecode(const Block &wire)
+Certificate::wireDecode(const Block& wire)
 {
   Data::wireDecode(wire);
   decode();
@@ -145,7 +153,7 @@
 
 
 inline std::ostream&
-operator <<(std::ostream &os, const Certificate &cert)
+operator <<(std::ostream& os, const Certificate& cert)
 {
   cert.printCertificate(os);
   return os;
diff --git a/src/security/conf/checker.hpp b/src/security/conf/checker.hpp
index 48664ea..3fa8d94 100644
--- a/src/security/conf/checker.hpp
+++ b/src/security/conf/checker.hpp
@@ -224,7 +224,7 @@
         return -1;
       }
 
-    switch(signature.getType())
+    switch (signature.getType())
       {
       case Signature::Sha256WithRsa:
         {
diff --git a/src/security/identity-certificate.cpp b/src/security/identity-certificate.cpp
index b4d5cb5..75693b0 100644
--- a/src/security/identity-certificate.cpp
+++ b/src/security/identity-certificate.cpp
@@ -20,21 +20,21 @@
   string idString("ID-CERT");
   int i = name.size() - 1;
   for (; i >= 0; i--) {
-    if(name.get(i).toEscapedString() == idString)
+    if (name.get(i).toEscapedString() == idString)
       break;
   }
 
   if (i < 0)
     return false;
-  
-  size_t keyIdx = 0;
+
   string keyString("KEY");
-  for (; keyIdx < name.size(); keyIdx++) {
-    if(name.get(keyIdx).toEscapedString() == keyString)
+  size_t keyIndex = 0;
+  for (; keyIndex < name.size(); keyIndex++) {
+    if (name.get(keyIndex).toEscapedString() == keyString)
       break;
   }
 
-  if (keyIdx >= name.size())
+  if (keyIndex >= name.size())
     return false;
 
   return true;
@@ -45,7 +45,7 @@
 {
   if (!isCorrectName(getName()))
     throw Error("Wrong Identity Certificate Name!");
-  
+
   publicKeyName_ = certificateNameToPublicKeyName(getName());
 }
 
@@ -69,9 +69,9 @@
       }
   }
 
-  if(!foundIdString)
+  if (!foundIdString)
     throw Error("Incorrect identity certificate name " + certificateName.toUri());
-    
+
   Name tmpName = certificateName.getSubName(0, idCertComponentIndex);
   string keyString("KEY");
   bool foundKeyString = false;
@@ -84,7 +84,7 @@
       }
   }
 
-  if(!foundKeyString)
+  if (!foundKeyString)
     throw Error("Incorrect identity certificate name " + certificateName.toUri());
 
   return tmpName
diff --git a/src/security/identity-certificate.hpp b/src/security/identity-certificate.hpp
index 6d6d334..01427d4 100644
--- a/src/security/identity-certificate.hpp
+++ b/src/security/identity-certificate.hpp
@@ -17,7 +17,15 @@
 class IdentityCertificate : public Certificate
 {
 public:
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
   /**
    * The default constructor.
@@ -33,20 +41,20 @@
    */
   inline
   IdentityCertificate(const Data& data);
-  
+
   /**
    * The virtual destructor.
    */
-  inline virtual 
+  inline virtual
   ~IdentityCertificate();
-  
-  inline void
-  wireDecode(const Block &wire);
 
   inline void
-  setName(const Name &name);
-  
-  inline const Name &
+  wireDecode(const Block& wire);
+
+  inline void
+  setName(const Name& name);
+
+  inline const Name&
   getPublicKeyName () const;
 
   static bool
@@ -59,14 +67,14 @@
    */
   static Name
   certificateNameToPublicKeyName(const Name& certificateName);
-  
+
 private:
   static bool
   isCorrectName(const Name& name);
-  
+
   void
   setPublicKeyName();
-    
+
 protected:
   Name publicKeyName_;
 };
@@ -82,27 +90,27 @@
 {
   setPublicKeyName();
 }
-  
+
 inline
 IdentityCertificate::~IdentityCertificate()
 {
 }
 
 inline void
-IdentityCertificate::wireDecode(const Block &wire)
+IdentityCertificate::wireDecode(const Block& wire)
 {
   Certificate::wireDecode(wire);
   setPublicKeyName();
 }
 
 inline void
-IdentityCertificate::setName(const Name &name)
+IdentityCertificate::setName(const Name& name)
 {
   Certificate::setName(name);
   setPublicKeyName();
 }
 
-inline const Name &
+inline const Name&
 IdentityCertificate::getPublicKeyName () const
 {
   return publicKeyName_;
diff --git a/src/security/key-chain.hpp b/src/security/key-chain.hpp
index ac03ce4..70593a9 100644
--- a/src/security/key-chain.hpp
+++ b/src/security/key-chain.hpp
@@ -59,7 +59,7 @@
       {
         keyName = Info::getDefaultKeyNameForIdentity(identityName);
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         keyName = generateRSAKeyPairAsDefault(identityName, true);
       }
@@ -69,7 +69,7 @@
       {
         certName = Info::getDefaultCertificateNameForKey(keyName);
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         shared_ptr<IdentityCertificate> selfCert = selfSign(keyName);
         Info::addCertificateAsIdentityDefault(*selfCert);
@@ -129,17 +129,17 @@
                                      const std::vector<CertificateSubjectDescription>& subjectDescription)
 
   {
-    if(keyName.size() < 1)
+    if (keyName.size() < 1)
       return shared_ptr<IdentityCertificate>();
 
     std::string keyIdPrefix = keyName.get(-1).toEscapedString().substr(0, 4);
-    if(keyIdPrefix != "ksk-" && keyIdPrefix != "dsk-")
+    if (keyIdPrefix != "ksk-" && keyIdPrefix != "dsk-")
       return shared_ptr<IdentityCertificate>();
 
     shared_ptr<IdentityCertificate> certificate = make_shared<IdentityCertificate>();
     Name certName;
 
-    if(signingIdentity.isPrefixOf(keyName))
+    if (signingIdentity.isPrefixOf(keyName))
       {
         certName.append(signingIdentity).append("KEY").append(keyName.getSubName(signingIdentity.size())).append("ID-CERT").appendVersion();
       }
@@ -157,13 +157,13 @@
       {
         publicKey = Info::getPublicKey(keyName);
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         return shared_ptr<IdentityCertificate>();
       }
     certificate->setPublicKeyInfo(*publicKey);
 
-    if(subjectDescription.empty())
+    if (subjectDescription.empty())
       {
         CertificateSubjectDescription subDescryptName("2.5.4.41", keyName.getPrefix(-1).toUri());
         certificate->addSubjectDescription(subDescryptName);
@@ -285,7 +285,7 @@
       {
         signingCertificateName = Info::getDefaultCertificateNameForIdentity(identityName);
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         signingCertificateName = createIdentity(identityName);
         // Ideally, no exception will be thrown out, unless something goes wrong in the TPM, which is a fatal error.
@@ -311,7 +311,7 @@
       {
         signingCertificateName = Info::getDefaultCertificateNameForIdentity(identityName);
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         signingCertificateName = createIdentity(identityName);
         // Ideally, no exception will be thrown out, unless something goes wrong in the TPM, which is a fatal error.
@@ -353,7 +353,7 @@
       {
         pubKey = Info::getPublicKey(keyName); // may throw an exception.
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         return shared_ptr<IdentityCertificate>();
       }
@@ -384,7 +384,7 @@
   selfSign (IdentityCertificate& cert)
   {
     Name keyName = IdentityCertificate::certificateNameToPublicKeyName(cert.getName());
-    if(!Tpm::doesKeyExistInTpm(keyName, KEY_CLASS_PRIVATE))
+    if (!Tpm::doesKeyExistInTpm(keyName, KEY_CLASS_PRIVATE))
       throw TpmError("private key does not exist!");
 
     SignatureSha256WithRsa signature;
@@ -407,10 +407,10 @@
   {
     try
       {
-        if(Info::getDefaultCertificateName() == certificateName)
+        if (Info::getDefaultCertificateName() == certificateName)
           return;
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         // Not a real error, just try to delete the certificate
       }
@@ -431,10 +431,10 @@
   {
     try
       {
-        if(Info::getDefaultKeyNameForIdentity(Info::getDefaultIdentity()) == keyName)
+        if (Info::getDefaultKeyNameForIdentity(Info::getDefaultIdentity()) == keyName)
           return;
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         // Not a real error, just try to delete the key
       }
@@ -456,10 +456,10 @@
   {
     try
       {
-        if(Info::getDefaultIdentity() == identity)
+        if (Info::getDefaultIdentity() == identity)
           return;
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         // Not a real error, just try to delete the identity
       }
@@ -496,7 +496,7 @@
       {
         pkcs8 = Tpm::exportPrivateKeyPkcs8FromTpm(keyName, passwordStr);
       }
-    catch(TpmError& e)
+    catch (TpmError& e)
       {
         throw InfoError("Fail to export PKCS8 of private key");
       }
@@ -506,7 +506,7 @@
       {
         cert = Info::getCertificate(Info::getDefaultCertificateNameForKey(keyName));
       }
-    catch(InfoError& e)
+    catch (InfoError& e)
       {
         cert = selfSign(keyName);
         Info::addCertificateAsIdentityDefault(*cert);
diff --git a/src/security/public-key.cpp b/src/security/public-key.cpp
index f6b2fdf..b9b7cf3 100644
--- a/src/security/public-key.cpp
+++ b/src/security/public-key.cpp
@@ -28,14 +28,14 @@
  * @param algorithm The algorithm of the public key.
  * @param keyDer The blob of the PublicKeyInfo in terms of DER.
  */
-PublicKey::PublicKey(const uint8_t *keyDerBuf, size_t keyDerSize)
+PublicKey::PublicKey(const uint8_t* keyDerBuf, size_t keyDerSize)
 {
   StringSource src(keyDerBuf, keyDerSize, true);
   decode(src);
 }
 
 void
-PublicKey::encode(CryptoPP::BufferedTransformation &out) const
+PublicKey::encode(CryptoPP::BufferedTransformation& out) const
 {
   // SubjectPublicKeyInfo ::= SEQUENCE {
   //     algorithm           AlgorithmIdentifier
@@ -45,7 +45,7 @@
 }
 
 void
-PublicKey::decode(CryptoPP::BufferedTransformation &in)
+PublicKey::decode(CryptoPP::BufferedTransformation& in)
 {
   // SubjectPublicKeyInfo ::= SEQUENCE {
   //     algorithm           AlgorithmIdentifier
@@ -86,7 +86,7 @@
 
     key_.assign(out.begin(), out.end());
   }
-  catch (CryptoPP::BERDecodeErr &err) {
+  catch (CryptoPP::BERDecodeErr& err) {
     throw Error("PublicKey decoding error");
   }
 }
@@ -97,15 +97,15 @@
 //   if (digestAlgorithm == DIGEST_ALGORITHM_SHA256) {
 //     uint8_t digest[SHA256_DIGEST_LENGTH];
 //     ndn_digestSha256(keyDer_.buf(), keyDer_.size(), digest);
-    
+
 //     return Blob(digest, sizeof(digest));
 //   }
 //   else
 //     throw UnrecognizedDigestAlgorithmException("Wrong format!");
 // }
 
-std::ostream &
-operator <<(std::ostream &os, const PublicKey &key)
+std::ostream&
+operator <<(std::ostream& os, const PublicKey& key)
 {
   CryptoPP::StringSource(key.get().buf(), key.get().size(), true,
                          new CryptoPP::Base64Encoder(new CryptoPP::FileSink(os), true, 64));
diff --git a/src/security/public-key.hpp b/src/security/public-key.hpp
index a332f02..8d6b7c5 100644
--- a/src/security/public-key.hpp
+++ b/src/security/public-key.hpp
@@ -18,8 +18,16 @@
 namespace ndn {
 
 class PublicKey {
-public:    
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+public:
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
   /**
    * The default constructor.
@@ -49,36 +57,36 @@
   }
 
   void
-  encode(CryptoPP::BufferedTransformation &out) const;
+  encode(CryptoPP::BufferedTransformation& out) const;
 
   void
-  decode(CryptoPP::BufferedTransformation &in);
+  decode(CryptoPP::BufferedTransformation& in);
 
   // /*
   //  * Get the digest of the public key.
   //  * @param digestAlgorithm The digest algorithm. If omitted, use DIGEST_ALGORITHM_SHA256 by default.
   //  */
-  // Blob 
+  // Blob
   // getDigest(DigestAlgorithm digestAlgorithm = DIGEST_ALGORITHM_SHA256) const;
 
   inline bool
-  operator ==(const PublicKey &key) const
+  operator ==(const PublicKey& key) const
   {
     return key_ == key.key_;
   }
 
   inline bool
-  operator !=(const PublicKey &key) const
+  operator !=(const PublicKey& key) const
   {
     return key_ != key.key_;
   }
-  
+
 private:
   Buffer key_;
 };
 
-std::ostream &
-operator <<(std::ostream &os, const PublicKey &key);
+std::ostream&
+operator <<(std::ostream& os, const PublicKey& key);
 
 } // namespace ndn
 
diff --git a/src/security/sec-public-info-memory.cpp b/src/security/sec-public-info-memory.cpp
index 82affaa..f2a35ee 100644
--- a/src/security/sec-public-info-memory.cpp
+++ b/src/security/sec-public-info-memory.cpp
@@ -18,7 +18,7 @@
 {
 }
 
-bool 
+bool
 SecPublicInfoMemory::doesIdentityExist(const Name& identityName)
 {
   string identityUri = identityName.toUri();
@@ -31,11 +31,11 @@
   string identityUri = identityName.toUri();
   if (find(identityStore_.begin(), identityStore_.end(), identityUri) != identityStore_.end())
     return;
-  
+
   identityStore_.push_back(identityUri);
 }
 
-bool 
+bool
 SecPublicInfoMemory::revokeIdentity()
 {
 #if 1
@@ -43,19 +43,19 @@
 #endif
 }
 
-bool 
+bool
 SecPublicInfoMemory::doesPublicKeyExist(const Name& keyName)
 {
   return keyStore_.find(keyName.toUri()) != keyStore_.end();
 }
 
-void 
+void
 SecPublicInfoMemory::addPublicKey(const Name& keyName, KeyType keyType, const PublicKey& publicKey)
 {
   Name identityName = keyName.getSubName(0, keyName.size() - 1);
 
   addIdentity(identityName);
-  
+
   keyStore_[keyName.toUri()] = make_shared<KeyRecord>(keyType, publicKey);
 }
 
@@ -65,7 +65,7 @@
   KeyStore::iterator record = keyStore_.find(keyName.toUri());
   if (record == keyStore_.end())
     throw Error("SecPublicInfoMemory::getPublicKey  " + keyName.toUri());
-  
+
   return make_shared<PublicKey> (record->second->getKey());
 }
 
@@ -75,7 +75,7 @@
   return certificateStore_.find(certificateName.toUri()) != certificateStore_.end();
 }
 
-void 
+void
 SecPublicInfoMemory::addCertificate(const IdentityCertificate& certificate)
 {
   const Name& certificateName = certificate.getName();
@@ -87,7 +87,7 @@
   certificateStore_[certificateName.toUri()] = make_shared<IdentityCertificate> (certificate);
 }
 
-shared_ptr<IdentityCertificate> 
+shared_ptr<IdentityCertificate>
 SecPublicInfoMemory::getCertificate(const Name& certificateName)
 {
   CertificateStore::iterator record = certificateStore_.find(certificateName.toUri());
@@ -97,13 +97,13 @@
   return record->second;
 }
 
-Name 
+Name
 SecPublicInfoMemory::getDefaultIdentity()
 {
   return Name(defaultIdentity_);
 }
 
-void 
+void
 SecPublicInfoMemory::setDefaultIdentityInternal(const Name& identityName)
 {
   string identityUri = identityName.toUri();
@@ -114,75 +114,75 @@
     defaultIdentity_.clear();
 }
 
-Name 
+Name
 SecPublicInfoMemory::getDefaultKeyNameForIdentity(const Name& identityName)
 {
   return defaultKeyName_;
 }
 
-void 
+void
 SecPublicInfoMemory::setDefaultKeyNameForIdentityInternal(const Name& keyName)
 {
   defaultKeyName_ = keyName;
 }
 
-Name 
+Name
 SecPublicInfoMemory::getDefaultCertificateNameForKey(const Name& keyName)
 {
   return defaultCert_;
 }
 
-void 
-SecPublicInfoMemory::setDefaultCertificateNameForKeyInternal(const Name& certificateName)  
+void
+SecPublicInfoMemory::setDefaultCertificateNameForKeyInternal(const Name& certificateName)
 {
   defaultCert_ = certificateName;
 }
 
 
 void
-SecPublicInfoMemory::getAllIdentities(std::vector<Name> &nameList, bool isDefault)
+SecPublicInfoMemory::getAllIdentities(std::vector<Name>& nameList, bool isDefault)
 {
   throw Error("SecPublicInfoMemory::getAllIdentities not implemented");
 }
 
 void
-SecPublicInfoMemory::getAllKeyNames(std::vector<Name> &nameList, bool isDefault)
+SecPublicInfoMemory::getAllKeyNames(std::vector<Name>& nameList, bool isDefault)
 {
   throw Error("SecPublicInfoMemory::getAllKeyNames not implemented");
 }
 
 void
-SecPublicInfoMemory::getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name> &nameList, bool isDefault)
+SecPublicInfoMemory::getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name>& nameList, bool isDefault)
 {
   throw Error("SecPublicInfoMemory::getAllKeyNamesOfIdentity not implemented");
 }
-    
+
 void
-SecPublicInfoMemory::getAllCertificateNames(std::vector<Name> &nameList, bool isDefault)
+SecPublicInfoMemory::getAllCertificateNames(std::vector<Name>& nameList, bool isDefault)
 {
   throw Error("SecPublicInfoMemory::getAllCertificateNames not implemented");
 }
 
 void
-SecPublicInfoMemory::getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name> &nameList, bool isDefault)
+SecPublicInfoMemory::getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name>& nameList, bool isDefault)
 {
   throw Error("SecPublicInfoMemory::getAllCertificateNamesOfKey not implemented");
 }
 
 void
-SecPublicInfoMemory::deleteCertificateInfo(const Name &certName)
+SecPublicInfoMemory::deleteCertificateInfo(const Name& certName)
 {
   throw Error("SecPublicInfoMemory::deleteCertificateInfo not implemented");
 }
 
 void
-SecPublicInfoMemory::deletePublicKeyInfo(const Name &keyName)
+SecPublicInfoMemory::deletePublicKeyInfo(const Name& keyName)
 {
   throw Error("SecPublicInfoMemory::deletePublicKeyInfo not implemented");
 }
 
 void
-SecPublicInfoMemory::deleteIdentityInfo(const Name &identityName)
+SecPublicInfoMemory::deleteIdentityInfo(const Name& identityName)
 {
   throw Error("SecPublicInfoMemory::deleteIdentityInfo not implemented");
 }
diff --git a/src/security/sec-public-info-memory.hpp b/src/security/sec-public-info-memory.hpp
index 16001c8..58d8529 100644
--- a/src/security/sec-public-info-memory.hpp
+++ b/src/security/sec-public-info-memory.hpp
@@ -18,7 +18,15 @@
  */
 class SecPublicInfoMemory : public SecPublicInfo {
 public:
-  struct Error : public SecPublicInfo::Error { Error(const std::string &what) : SecPublicInfo::Error(what) {} };
+  class Error : public SecPublicInfo::Error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : SecPublicInfo::Error(what)
+    {
+    }
+  };
 
   virtual
   ~SecPublicInfoMemory();
@@ -32,10 +40,10 @@
   virtual bool
   revokeIdentity();
 
-  virtual bool 
+  virtual bool
   doesPublicKeyExist(const Name& keyName);
 
-  virtual void 
+  virtual void
   addPublicKey(const Name& keyName, KeyType keyType, const PublicKey& publicKeyDer);
 
   virtual ptr_lib::shared_ptr<PublicKey>
@@ -44,74 +52,74 @@
   virtual bool
   doesCertificateExist(const Name& certificateName);
 
-  virtual void 
+  virtual void
   addCertificate(const IdentityCertificate& certificate);
 
-  virtual ptr_lib::shared_ptr<IdentityCertificate> 
-  getCertificate(const Name &certificateName);
+  virtual ptr_lib::shared_ptr<IdentityCertificate>
+  getCertificate(const Name& certificateName);
 
 
-  virtual Name 
+  virtual Name
   getDefaultIdentity();
 
-  virtual Name 
+  virtual Name
   getDefaultKeyNameForIdentity(const Name& identityName);
 
-  virtual Name 
+  virtual Name
   getDefaultCertificateNameForKey(const Name& keyName);
 
   virtual void
-  getAllIdentities(std::vector<Name> &nameList, bool isDefault);
+  getAllIdentities(std::vector<Name>& nameList, bool isDefault);
 
   virtual void
-  getAllKeyNames(std::vector<Name> &nameList, bool isDefault);
+  getAllKeyNames(std::vector<Name>& nameList, bool isDefault);
 
   virtual void
-  getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name> &nameList, bool isDefault);
-    
-  virtual void
-  getAllCertificateNames(std::vector<Name> &nameList, bool isDefault);
+  getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name>& nameList, bool isDefault);
 
   virtual void
-  getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name> &nameList, bool isDefault);
+  getAllCertificateNames(std::vector<Name>& nameList, bool isDefault);
+
+  virtual void
+  getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name>& nameList, bool isDefault);
 
 protected:
-  virtual void 
+  virtual void
   setDefaultIdentityInternal(const Name& identityName);
 
-  virtual void 
+  virtual void
   setDefaultKeyNameForIdentityInternal(const Name& keyName);
 
-  virtual void 
-  setDefaultCertificateNameForKeyInternal(const Name& certificateName);  
+  virtual void
+  setDefaultCertificateNameForKeyInternal(const Name& certificateName);
 
   virtual void
-  deleteCertificateInfo(const Name &certificateName);
+  deleteCertificateInfo(const Name& certificateName);
 
   virtual void
-  deletePublicKeyInfo(const Name &keyName);
+  deletePublicKeyInfo(const Name& keyName);
 
   virtual void
-  deleteIdentityInfo(const Name &identity);
+  deleteIdentityInfo(const Name& identity);
 
-  
+
 private:
   class KeyRecord {
   public:
-    KeyRecord(KeyType keyType, const PublicKey &key)
+    KeyRecord(KeyType keyType, const PublicKey& key)
     : keyType_(keyType), key_(key)
     {
     }
-    
+
     const KeyType getKeyType() const { return keyType_; }
-    
+
     const PublicKey& getKey() { return key_; }
-    
+
   private:
     KeyType   keyType_;
     PublicKey key_;
   };
-  
+
   std::vector<std::string> identityStore_; /**< A list of name URI. */
   std::string defaultIdentity_;            /**< The default identity in identityStore_, or "" if not defined. */
   Name defaultKeyName_;
@@ -119,9 +127,9 @@
 
   typedef std::map< std::string, ptr_lib::shared_ptr<KeyRecord> > KeyStore; /**< The map key is the keyName.toUri() */
   typedef std::map< std::string, ptr_lib::shared_ptr<IdentityCertificate> > CertificateStore; /**< The map key is the certificateName.toUri() */
-  
-  KeyStore keyStore_; 
-  CertificateStore certificateStore_;                    
+
+  KeyStore keyStore_;
+  CertificateStore certificateStore_;
 };
 
 } // namespace ndn
diff --git a/src/security/sec-public-info-sqlite3.cpp b/src/security/sec-public-info-sqlite3.cpp
index 712bf7d..b8b5af3 100644
--- a/src/security/sec-public-info-sqlite3.cpp
+++ b/src/security/sec-public-info-sqlite3.cpp
@@ -104,9 +104,9 @@
                             );
   if (res != SQLITE_OK)
     throw Error("identity DB cannot be opened/created");
-  
+
   //Check if Key table exists;
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "SELECT name FROM sqlite_master WHERE type='table' And name='Identity'", -1, &statement, 0);
   res = sqlite3_step(statement);
 
@@ -117,9 +117,9 @@
   sqlite3_finalize(statement);
 
   if (!idTableExists) {
-    char *errorMessage = 0;
+    char* errorMessage = 0;
     res = sqlite3_exec(m_database, INIT_ID_TABLE.c_str(), NULL, NULL, &errorMessage);
-      
+
     if (res != SQLITE_OK && errorMessage != 0) {
       _LOG_TRACE("Init \"error\" in Identity: " << errorMessage);
       sqlite3_free(errorMessage);
@@ -137,9 +137,9 @@
   sqlite3_finalize(statement);
 
   if (!keyTableExists) {
-    char *errorMessage = 0;
+    char* errorMessage = 0;
     res = sqlite3_exec(m_database, INIT_KEY_TABLE.c_str(), NULL, NULL, &errorMessage);
-      
+
     if (res != SQLITE_OK && errorMessage != 0) {
       _LOG_TRACE("Init \"error\" in KEY: " << errorMessage);
       sqlite3_free(errorMessage);
@@ -153,13 +153,13 @@
   bool idCertificateTableExists = false;
   if (res == SQLITE_ROW)
     idCertificateTableExists = true;
-  
+
   sqlite3_finalize(statement);
 
   if (!idCertificateTableExists) {
-    char *errorMessage = 0;
+    char* errorMessage = 0;
     res = sqlite3_exec(m_database, INIT_CERT_TABLE.c_str(), NULL, NULL, &errorMessage);
-      
+
     if (res != SQLITE_OK && errorMessage != 0) {
       _LOG_TRACE("Init \"error\" in ID-CERT: " << errorMessage);
       sqlite3_free(errorMessage);
@@ -171,59 +171,59 @@
 {
 }
 
-bool 
+bool
 SecPublicInfoSqlite3::doesIdentityExist(const Name& identityName)
 {
   bool result = false;
-  
-  sqlite3_stmt *statement;
+
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "SELECT count(*) FROM Identity WHERE identity_name=?", -1, &statement, 0);
 
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
   int res = sqlite3_step(statement);
-  
+
   if (res == SQLITE_ROW) {
     int countAll = sqlite3_column_int(statement, 0);
     if (countAll > 0)
       result = true;
   }
- 
+
   sqlite3_finalize(statement);
 
   return result;
 }
 
-void 
+void
 SecPublicInfoSqlite3::addIdentity(const Name& identityName)
 {
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
 
   sqlite3_prepare_v2(m_database, "INSERT OR REPLACE INTO Identity (identity_name) values (?)", -1, &statement, 0);
-      
+
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
-  
+
   sqlite3_step(statement);
-  
+
   sqlite3_finalize(statement);
 }
 
-bool 
+bool
 SecPublicInfoSqlite3::revokeIdentity()
 {
   //TODO:
   return false;
 }
 
-bool 
+bool
 SecPublicInfoSqlite3::doesPublicKeyExist(const Name& keyName)
 {
-  if(keyName.empty())
+  if (keyName.empty())
     throw Error("Incorrect key name " + keyName.toUri());
 
   string keyId = keyName.get(-1).toEscapedString();
   Name identityName = keyName.getPrefix(-1);
 
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "SELECT count(*) FROM Key WHERE identity_name=? AND key_identifier=?", -1, &statement, 0);
 
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
@@ -237,7 +237,7 @@
     if (countAll > 0)
       keyIdExist = true;
   }
- 
+
   sqlite3_finalize(statement);
 
   return keyIdExist;
@@ -246,7 +246,7 @@
 void
 SecPublicInfoSqlite3::addPublicKey(const Name& keyName, KeyType keyType, const PublicKey& publicKeyDer)
 {
-  if(keyName.empty())
+  if (keyName.empty())
     return;
 
   string keyId = keyName.get(-1).toEscapedString();
@@ -254,7 +254,7 @@
 
   addIdentity(identityName);
 
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "INSERT OR REPLACE INTO Key (identity_name, key_identifier, key_type, public_key) values (?, ?, ?, ?)", -1, &statement, 0);
 
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
@@ -270,7 +270,7 @@
 shared_ptr<PublicKey>
 SecPublicInfoSqlite3::getPublicKey(const Name& keyName)
 {
-  if (keyName.empty()) 
+  if (keyName.empty())
     {
       _LOG_DEBUG("SecPublicInfoSqlite3::getPublicKey  Empty keyName");
       throw Error("SecPublicInfoSqlite3::getPublicKey  Empty keyName");
@@ -278,8 +278,8 @@
 
   string keyId = keyName.get(-1).toEscapedString();
   Name identityName = keyName.getPrefix(-1);
-  
-  sqlite3_stmt *statement;
+
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "SELECT public_key FROM Key WHERE identity_name=? AND key_identifier=?", -1, &statement, 0);
 
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
@@ -304,7 +304,7 @@
 bool
 SecPublicInfoSqlite3::doesCertificateExist(const Name& certificateName)
 {
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "SELECT count(*) FROM Certificate WHERE cert_name=?", -1, &statement, 0);
 
   sqlite3_bind_text(statement, 1, certificateName.toUri(), SQLITE_TRANSIENT);
@@ -317,9 +317,9 @@
     if (countAll > 0)
       certExist = true;
   }
- 
+
   sqlite3_finalize(statement);
-  
+
   return certExist;
 }
 
@@ -329,14 +329,14 @@
 //   std::string certificateName = certificate.getName().toUri();
 //   Name keyName = IdentityCertificate::certificateNameToPublicKeyName(certificate.getName());
 
-//   if(keyName.empty())
+//   if (keyName.empty())
 //     return;
 
 //   std::string keyId = keyName.get(-1).toEscapedString();
 //   std::string identityName = keyName.getPrefix(-1).toUri();
 
-//   sqlite3_stmt *statement;
-//   sqlite3_prepare_v2(m_database, 
+//   sqlite3_stmt* statement;
+//   sqlite3_prepare_v2(m_database,
 //                       "INSERT OR REPLACE INTO Certificate (cert_name, cert_issuer, identity_name, key_identifier, not_before, not_after, certificate_data) "
 //                        "VALUES (?, ?, ?, ?, datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), ?)",
 //                       -1, &statement, 0);
@@ -351,12 +351,12 @@
 
 //       sqlite3_bind_text(statement, 2, signerName, SQLITE_STATIC);
 //     }
-//   catch(KeyLocator::Error& e)
+//   catch (KeyLocator::Error& e)
 //     {
 //       _LOG_DEBUG("SecPublicInfoSqlite3::addAnyCertificate unsupported keylocator type");
 //       return;
 //     }
-//   catch(SignatureSha256WithRsa::Error& e)
+//   catch (SignatureSha256WithRsa::Error& e)
 //     {
 //       _LOG_DEBUG("SecPublicInfoSqlite3::addAnyCertificate unsupported signature type");
 //       return;
@@ -378,11 +378,11 @@
 //   sqlite3_finalize(statement);
 // }
 
-void 
+void
 SecPublicInfoSqlite3::addCertificate(const IdentityCertificate& certificate)
 {
   const Name& certificateName = certificate.getName();
-  Name keyName = 
+  Name keyName =
     IdentityCertificate::certificateNameToPublicKeyName(certificate.getName()); // KeyName is from IdentityCertificate name, so should be qualified.
 
   addPublicKey(keyName, KEY_TYPE_RSA, certificate.getPublicKeyInfo()); //HACK!!! Assume the key type is RSA, we should check more.
@@ -391,8 +391,8 @@
   Name identity = keyName.getPrefix(-1);
 
   // Insert the certificate
-  sqlite3_stmt *statement;
-  sqlite3_prepare_v2(m_database, 
+  sqlite3_stmt* statement;
+  sqlite3_prepare_v2(m_database,
                       "INSERT OR REPLACE INTO Certificate (cert_name, cert_issuer, identity_name, key_identifier, not_before, not_after, certificate_data)\
                        values (?, ?, ?, ?, datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), ?)",
                       -1, &statement, 0);
@@ -408,12 +408,12 @@
 
       sqlite3_bind_text(statement, 2, signerName, SQLITE_STATIC);
     }
-  catch(KeyLocator::Error& e)
+  catch (KeyLocator::Error& e)
     {
       _LOG_DEBUG("SecPublicInfoSqlite3::addAnyCertificate unsupported keylocator type");
       return;
     }
-  catch(SignatureSha256WithRsa::Error& e)
+  catch (SignatureSha256WithRsa::Error& e)
     {
       _LOG_DEBUG("SecPublicInfoSqlite3::addAnyCertificate unsupported signature type");
       return;
@@ -434,19 +434,19 @@
   sqlite3_finalize(statement);
 }
 
-shared_ptr<IdentityCertificate> 
-SecPublicInfoSqlite3::getCertificate(const Name &certificateName)
+shared_ptr<IdentityCertificate>
+SecPublicInfoSqlite3::getCertificate(const Name& certificateName)
 {
-  sqlite3_stmt *statement;
-  
-  sqlite3_prepare_v2(m_database, 
+  sqlite3_stmt* statement;
+
+  sqlite3_prepare_v2(m_database,
                      "SELECT certificate_data FROM Certificate WHERE cert_name=?",
                      -1, &statement, 0);
-  
+
   sqlite3_bind_text(statement, 1, certificateName.toUri(), SQLITE_TRANSIENT);
-  
+
   int res = sqlite3_step(statement);
-  
+
   if (res == SQLITE_ROW)
     {
       shared_ptr<IdentityCertificate> certificate = make_shared<IdentityCertificate>();
@@ -461,16 +461,16 @@
       throw Error("SecPublicInfoSqlite3::getCertificate  certificate does not exist");
     }
 }
- 
 
-Name 
+
+Name
 SecPublicInfoSqlite3::getDefaultIdentity()
 {
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "SELECT identity_name FROM Identity WHERE default_identity=1", -1, &statement, 0);
 
   int res = sqlite3_step(statement);
-      
+
   if (res == SQLITE_ROW)
     {
       Name identity = Name(string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)), sqlite3_column_bytes(statement, 0)));
@@ -484,35 +484,35 @@
     }
 }
 
-void 
+void
 SecPublicInfoSqlite3::setDefaultIdentityInternal(const Name& identityName)
 {
   addIdentity(identityName);
 
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
 
   //Reset previous default identity
   sqlite3_prepare_v2(m_database, "UPDATE Identity SET default_identity=0 WHERE default_identity=1", -1, &statement, 0);
 
   while (sqlite3_step(statement) == SQLITE_ROW)
     {}
-  
+
   sqlite3_finalize(statement);
 
   //Set current default identity
   sqlite3_prepare_v2(m_database, "UPDATE Identity SET default_identity=1 WHERE identity_name=?", -1, &statement, 0);
 
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
-  
+
   sqlite3_step(statement);
 
   sqlite3_finalize(statement);
 }
 
-Name 
+Name
 SecPublicInfoSqlite3::getDefaultKeyNameForIdentity(const Name& identityName)
 {
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "SELECT key_identifier FROM Key WHERE identity_name=? AND default_key=1", -1, &statement, 0);
 
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
@@ -521,7 +521,7 @@
 
   if (res == SQLITE_ROW)
     {
-      Name keyName = Name(identityName).append(string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)), 
+      Name keyName = Name(identityName).append(string(reinterpret_cast<const char *>(sqlite3_column_text(statement, 0)),
                                                       sqlite3_column_bytes(statement, 0)));
       sqlite3_finalize(statement);
       return keyName;
@@ -533,16 +533,16 @@
     }
 }
 
-void 
+void
 SecPublicInfoSqlite3::setDefaultKeyNameForIdentityInternal(const Name& keyName)
 {
-  if(!doesPublicKeyExist(keyName))
+  if (!doesPublicKeyExist(keyName))
     throw Error("SecPublicInfoSqlite3::setDefaultKeyNameForIdentityInternal Key does not exist:" + keyName.toUri());
 
   string keyId = keyName.get(-1).toEscapedString();
   Name identityName = keyName.getPrefix(-1);
 
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
 
   //Reset previous default Key
   sqlite3_prepare_v2(m_database, "UPDATE Key SET default_key=0 WHERE default_key=1 and identity_name=?", -1, &statement, 0);
@@ -551,7 +551,7 @@
 
   while (sqlite3_step(statement) == SQLITE_ROW)
     {}
-  
+
   sqlite3_finalize(statement);
 
   //Set current default Key
@@ -559,22 +559,22 @@
 
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
   sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT);
-  
+
   sqlite3_step(statement);
 
   sqlite3_finalize(statement);
 }
 
-Name 
+Name
 SecPublicInfoSqlite3::getDefaultCertificateNameForKey(const Name& keyName)
 {
-  if(keyName.empty())
+  if (keyName.empty())
     throw Error("SecPublicInfoSqlite3::getDefaultCertificateNameForKey wrong key");
 
   string keyId = keyName.get(-1).toEscapedString();
   Name identityName = keyName.getPrefix(-1);
 
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
   sqlite3_prepare_v2(m_database, "SELECT cert_name FROM Certificate WHERE identity_name=? AND key_identifier=? AND default_cert=1", -1, &statement, 0);
 
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
@@ -595,17 +595,17 @@
     }
 }
 
-void 
+void
 SecPublicInfoSqlite3::setDefaultCertificateNameForKeyInternal(const Name& certificateName)
 {
-  if(!doesCertificateExist(certificateName))
+  if (!doesCertificateExist(certificateName))
     throw Error("SecPublicInfoSqlite3::setDefaultCertificateNameForKeyInternal  certificate does not exist:" + certificateName.toUri());
 
   Name keyName = IdentityCertificate::certificateNameToPublicKeyName(certificateName);
   string keyId = keyName.get(-1).toEscapedString();
   Name identityName = keyName.getPrefix(-1);
 
-  sqlite3_stmt *statement;
+  sqlite3_stmt* statement;
 
   //Reset previous default Key
   sqlite3_prepare_v2(m_database, "UPDATE Certificate SET default_cert=0 WHERE default_cert=1 AND identity_name=? AND key_identifier=?", -1, &statement, 0);
@@ -615,7 +615,7 @@
 
   while (sqlite3_step(statement) == SQLITE_ROW)
     {}
-  
+
   sqlite3_finalize(statement);
 
   //Set current default Key
@@ -624,32 +624,32 @@
   sqlite3_bind_text(statement, 1, identityName.toUri(), SQLITE_TRANSIENT);
   sqlite3_bind_text(statement, 2, keyId, SQLITE_TRANSIENT);
   sqlite3_bind_text(statement, 3, certificateName.toUri(), SQLITE_TRANSIENT);
-  
+
   sqlite3_step(statement);
 
   sqlite3_finalize(statement);
 }
 
 void
-SecPublicInfoSqlite3::getAllIdentities(vector<Name> &nameList, bool isDefault)
+SecPublicInfoSqlite3::getAllIdentities(vector<Name>& nameList, bool isDefault)
 {
-  sqlite3_stmt *stmt;
-  if(isDefault)
+  sqlite3_stmt* stmt;
+  if (isDefault)
     sqlite3_prepare_v2 (m_database, "SELECT identity_name FROM Identity WHERE default_identity=1", -1, &stmt, 0);
   else
     sqlite3_prepare_v2 (m_database, "SELECT identity_name FROM Identity WHERE default_identity=0", -1, &stmt, 0);
 
   while(sqlite3_step (stmt) == SQLITE_ROW)
     nameList.push_back(Name(string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)), sqlite3_column_bytes (stmt, 0))));
-        
-  sqlite3_finalize (stmt);        
+
+  sqlite3_finalize (stmt);
 }
 
 void
-SecPublicInfoSqlite3::getAllKeyNames(vector<Name> &nameList, bool isDefault)
+SecPublicInfoSqlite3::getAllKeyNames(vector<Name>& nameList, bool isDefault)
 {
-  sqlite3_stmt *stmt;
-  if(isDefault)
+  sqlite3_stmt* stmt;
+  if (isDefault)
     sqlite3_prepare_v2 (m_database, "SELECT identity_name, key_identifier FROM Key WHERE default_key=1", -1, &stmt, 0);
   else
     sqlite3_prepare_v2 (m_database, "SELECT identity_name, key_identifier FROM Key WHERE default_key=0", -1, &stmt, 0);
@@ -659,19 +659,19 @@
       Name keyName(string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)), sqlite3_column_bytes (stmt, 0)));
       keyName.append(string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1)), sqlite3_column_bytes (stmt, 1)));
       nameList.push_back(keyName);
-    } 
-  sqlite3_finalize (stmt);        
+    }
+  sqlite3_finalize (stmt);
 }
 
 void
-SecPublicInfoSqlite3::getAllKeyNamesOfIdentity(const Name& identity, vector<Name> &nameList, bool isDefault)
+SecPublicInfoSqlite3::getAllKeyNamesOfIdentity(const Name& identity, vector<Name>& nameList, bool isDefault)
 {
-  sqlite3_stmt *stmt;
-  if(isDefault)
+  sqlite3_stmt* stmt;
+  if (isDefault)
     sqlite3_prepare_v2 (m_database, "SELECT key_identifier FROM Key WHERE default_key=1 and identity_name=?", -1, &stmt, 0);
   else
     sqlite3_prepare_v2 (m_database, "SELECT key_identifier FROM Key WHERE default_key=0 and identity_name=?", -1, &stmt, 0);
-    
+
   sqlite3_bind_text(stmt, 1, identity.toUri().c_str(),  identity.toUri().size (),  SQLITE_TRANSIENT);
 
   while(sqlite3_step (stmt) == SQLITE_ROW)
@@ -679,15 +679,15 @@
       Name keyName(identity);
       keyName.append(string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)), sqlite3_column_bytes (stmt, 0)));
       nameList.push_back(keyName);
-    } 
-  sqlite3_finalize (stmt);        
+    }
+  sqlite3_finalize (stmt);
 }
-    
+
 void
-SecPublicInfoSqlite3::getAllCertificateNames(vector<Name> &nameList, bool isDefault)
+SecPublicInfoSqlite3::getAllCertificateNames(vector<Name>& nameList, bool isDefault)
 {
-  sqlite3_stmt *stmt;
-  if(isDefault)
+  sqlite3_stmt* stmt;
+  if (isDefault)
     sqlite3_prepare_v2 (m_database, "SELECT cert_name FROM Certificate WHERE default_cert=1", -1, &stmt, 0);
   else
     sqlite3_prepare_v2 (m_database, "SELECT cert_name FROM Certificate WHERE default_cert=0", -1, &stmt, 0);
@@ -695,17 +695,17 @@
   while(sqlite3_step (stmt) == SQLITE_ROW)
     nameList.push_back(string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)), sqlite3_column_bytes (stmt, 0)));
 
-  sqlite3_finalize (stmt);        
+  sqlite3_finalize (stmt);
 }
 
 void
-SecPublicInfoSqlite3::getAllCertificateNamesOfKey(const Name& keyName, vector<Name> &nameList, bool isDefault)
+SecPublicInfoSqlite3::getAllCertificateNamesOfKey(const Name& keyName, vector<Name>& nameList, bool isDefault)
 {
-  if(keyName.empty())
+  if (keyName.empty())
     return;
 
-  sqlite3_stmt *stmt;
-  if(isDefault)
+  sqlite3_stmt* stmt;
+  if (isDefault)
     sqlite3_prepare_v2 (m_database, "SELECT cert_name FROM Certificate WHERE default_cert=1 and identity_name=? and key_identifier=?", -1, &stmt, 0);
   else
     sqlite3_prepare_v2 (m_database, "SELECT cert_name FROM Certificate WHERE default_cert=0 and identity_name=? and key_identifier=?", -1, &stmt, 0);
@@ -718,16 +718,16 @@
   while(sqlite3_step (stmt) == SQLITE_ROW)
     nameList.push_back(string(reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0)), sqlite3_column_bytes (stmt, 0)));
 
-  sqlite3_finalize (stmt);        
+  sqlite3_finalize (stmt);
 }
 
 void
-SecPublicInfoSqlite3::deleteCertificateInfo(const Name &certName)
+SecPublicInfoSqlite3::deleteCertificateInfo(const Name& certName)
 {
-  if(certName.empty())
+  if (certName.empty())
     return;
-  
-  sqlite3_stmt *stmt;
+
+  sqlite3_stmt* stmt;
   sqlite3_prepare_v2(m_database, "DELETE FROM Certificate WHERE cert_name=?", -1, &stmt, 0);
   sqlite3_bind_text(stmt, 1, certName.toUri().c_str(),  certName.toUri().size (),  SQLITE_TRANSIENT);
   sqlite3_step(stmt);
@@ -735,15 +735,15 @@
 }
 
 void
-SecPublicInfoSqlite3::deletePublicKeyInfo(const Name &keyName)
+SecPublicInfoSqlite3::deletePublicKeyInfo(const Name& keyName)
 {
-  if(keyName.empty())
+  if (keyName.empty())
     return;
 
   string identity = keyName.getPrefix(-1).toUri();
   string keyId = keyName.get(-1).toEscapedString();
 
-  sqlite3_stmt *stmt;
+  sqlite3_stmt* stmt;
   sqlite3_prepare_v2(m_database, "DELETE FROM Certificate WHERE identity_name=? and key_identifier=?", -1, &stmt, 0);
   sqlite3_bind_text(stmt, 1, identity.c_str(), identity.size (), SQLITE_TRANSIENT);
   sqlite3_bind_text(stmt, 2, keyId.c_str(), keyId.size(), SQLITE_TRANSIENT);
@@ -758,11 +758,11 @@
 }
 
 void
-SecPublicInfoSqlite3::deleteIdentityInfo(const Name &identityName)
+SecPublicInfoSqlite3::deleteIdentityInfo(const Name& identityName)
 {
   string identity = identityName.toUri();
 
-  sqlite3_stmt *stmt;
+  sqlite3_stmt* stmt;
   sqlite3_prepare_v2(m_database, "DELETE FROM Certificate WHERE identity_name=?", -1, &stmt, 0);
   sqlite3_bind_text(stmt, 1, identity.c_str(), identity.size (), SQLITE_TRANSIENT);
   sqlite3_step(stmt);
@@ -780,4 +780,3 @@
 }
 
 } // namespace ndn
-
diff --git a/src/security/sec-public-info-sqlite3.hpp b/src/security/sec-public-info-sqlite3.hpp
index feb07a5..b89859a 100644
--- a/src/security/sec-public-info-sqlite3.hpp
+++ b/src/security/sec-public-info-sqlite3.hpp
@@ -15,32 +15,40 @@
 struct sqlite3;
 
 namespace ndn {
-  
+
 class SecPublicInfoSqlite3 : public SecPublicInfo {
 public:
-  struct Error : public SecPublicInfo::Error { Error(const std::string &what) : SecPublicInfo::Error(what) {} };
+  class Error : public SecPublicInfo::Error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : SecPublicInfo::Error(what)
+    {
+    }
+  };
 
   SecPublicInfoSqlite3();
-  
-  virtual 
+
+  virtual
   ~SecPublicInfoSqlite3();
 
   /**********************
    * from SecPublicInfo *
    **********************/
-  virtual bool 
+  virtual bool
   doesIdentityExist(const Name& identityName);
 
   virtual void
   addIdentity(const Name& identityName);
 
-  virtual bool 
+  virtual bool
   revokeIdentity();
 
-  virtual bool 
+  virtual bool
   doesPublicKeyExist(const Name& keyName);
 
-  virtual void 
+  virtual void
   addPublicKey(const Name& keyName, KeyType keyType, const PublicKey& publicKeyDer);
 
   virtual ptr_lib::shared_ptr<PublicKey>
@@ -49,57 +57,57 @@
   virtual bool
   doesCertificateExist(const Name& certificateName);
 
-  virtual void 
+  virtual void
   addCertificate(const IdentityCertificate& certificate);
 
-  virtual ptr_lib::shared_ptr<IdentityCertificate> 
-  getCertificate(const Name &certificateName);
+  virtual ptr_lib::shared_ptr<IdentityCertificate>
+  getCertificate(const Name& certificateName);
 
 
 
-  virtual Name 
+  virtual Name
   getDefaultIdentity();
 
-  virtual Name 
+  virtual Name
   getDefaultKeyNameForIdentity(const Name& identityName);
 
-  virtual Name 
+  virtual Name
   getDefaultCertificateNameForKey(const Name& keyName);
 
   virtual void
-  getAllIdentities(std::vector<Name> &nameList, bool isDefault);
+  getAllIdentities(std::vector<Name>& nameList, bool isDefault);
 
   virtual void
-  getAllKeyNames(std::vector<Name> &nameList, bool isDefault);
+  getAllKeyNames(std::vector<Name>& nameList, bool isDefault);
 
   virtual void
-  getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name> &nameList, bool isDefault);
-    
-  virtual void
-  getAllCertificateNames(std::vector<Name> &nameList, bool isDefault);
+  getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name>& nameList, bool isDefault);
 
   virtual void
-  getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name> &nameList, bool isDefault);
-  
+  getAllCertificateNames(std::vector<Name>& nameList, bool isDefault);
+
+  virtual void
+  getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name>& nameList, bool isDefault);
+
 protected:
-  virtual void 
+  virtual void
   setDefaultIdentityInternal(const Name& identityName);
 
   virtual void
   setDefaultKeyNameForIdentityInternal(const Name& keyName);
 
-  virtual void 
-  setDefaultCertificateNameForKeyInternal(const Name& certificateName);  
+  virtual void
+  setDefaultCertificateNameForKeyInternal(const Name& certificateName);
 
   virtual void
-  deleteCertificateInfo(const Name &certificateName);
+  deleteCertificateInfo(const Name& certificateName);
 
   virtual void
-  deletePublicKeyInfo(const Name &keyName);
+  deletePublicKeyInfo(const Name& keyName);
 
   virtual void
-  deleteIdentityInfo(const Name &identity);
-  
+  deleteIdentityInfo(const Name& identity);
+
 private:
   sqlite3 * m_database;
 };
diff --git a/src/security/sec-public-info.hpp b/src/security/sec-public-info.hpp
index 0861b67..5fe7b3c 100644
--- a/src/security/sec-public-info.hpp
+++ b/src/security/sec-public-info.hpp
@@ -24,12 +24,20 @@
  */
 class SecPublicInfo {
 public:
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
   /**
    * @brief The virtual Destructor.
    */
-  virtual 
+  virtual
   ~SecPublicInfo() {}
 
   /**
@@ -38,7 +46,7 @@
    * @param identityName The identity name.
    * @return true if the identity exists, otherwise false.
    */
-  virtual bool 
+  virtual bool
   doesIdentityExist(const Name& identityName) = 0;
 
   /**
@@ -56,7 +64,7 @@
    *
    * @return true if the identity was revoked, otherwise false.
    */
-  virtual bool 
+  virtual bool
   revokeIdentity() = 0;
 
   /**
@@ -65,7 +73,7 @@
    * @param keyName The name of the key.
    * @return true if the key exists, otherwise false.
    */
-  virtual bool 
+  virtual bool
   doesPublicKeyExist(const Name& keyName) = 0;
 
   /**
@@ -75,7 +83,7 @@
    * @param keyType Type of the public key to be added.
    * @param publicKeyDer A blob of the public key DER to be added.
    */
-  virtual void 
+  virtual void
   addPublicKey(const Name& keyName, KeyType keyType, const PublicKey& publicKeyDer) = 0;
 
   /**
@@ -104,18 +112,18 @@
    *
    * @param certificate The certificate to be added.
    */
-  virtual void 
+  virtual void
   addCertificate(const IdentityCertificate& certificate) = 0;
 
   /**
    * @brief Get a certificate from the identity storage.
    *
    * @param certificateName The name of the requested certificate.
-   * @return The requested certificate.  
+   * @return The requested certificate.
    * @throws SecPublicInfo::Error if the certificate does not exist.
    */
-  virtual shared_ptr<IdentityCertificate> 
-  getCertificate(const Name &certificateName) = 0;
+  virtual shared_ptr<IdentityCertificate>
+  getCertificate(const Name& certificateName) = 0;
 
 
   /*****************************************
@@ -123,12 +131,12 @@
    *****************************************/
 
   /**
-   * @brief Get the default identity. 
+   * @brief Get the default identity.
    *
-   * @param return The name of default identity, 
+   * @param return The name of default identity,
    * @throws SecPublicInfo::Error if there is no default.
    */
-  virtual Name 
+  virtual Name
   getDefaultIdentity() = 0;
 
   /**
@@ -138,7 +146,7 @@
    * @return The default key name.
    * @throws SecPublicInfo::Error if there is no default.
    */
-  virtual Name 
+  virtual Name
   getDefaultKeyNameForIdentity(const Name& identityName) = 0;
 
   /**
@@ -148,7 +156,7 @@
    * @return The default certificate name.
    * @throws SecPublicInfo::Error if there is no default.
    */
-  virtual Name 
+  virtual Name
   getDefaultCertificateNameForKey(const Name& keyName) = 0;
 
   /**
@@ -158,7 +166,7 @@
    * @param isDefault If specified, only the default identity is returned.
    */
   virtual void
-  getAllIdentities(std::vector<Name> &nameList, bool isDefault) = 0;
+  getAllIdentities(std::vector<Name>& nameList, bool isDefault) = 0;
 
   /**
    * @brief Get all the key name in public info.
@@ -167,7 +175,7 @@
    * @param isDefault If specified, only the default keys are returned.
    */
   virtual void
-  getAllKeyNames(std::vector<Name> &nameList, bool isDefault) = 0;
+  getAllKeyNames(std::vector<Name>& nameList, bool isDefault) = 0;
 
   /**
    * @brief Get all the key name of a particular identity.
@@ -177,7 +185,7 @@
    * @param isDefault If specified, only the default key is returned.
    */
   virtual void
-  getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name> &nameList, bool isDefault) = 0;
+  getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name>& nameList, bool isDefault) = 0;
 
   /**
    * @brief Get all the certificate name in public info.
@@ -186,8 +194,8 @@
    * @param isDefault If specified, only the default certificates are returned.
    */
   virtual void
-  getAllCertificateNames(std::vector<Name> &nameList, bool isDefault) = 0;
-    
+  getAllCertificateNames(std::vector<Name>& nameList, bool isDefault) = 0;
+
   /**
    * @brief Get all the certificate name of a particular key.
    *
@@ -196,25 +204,25 @@
    * @param isDefault If specified, only the default certificate is returned.
    */
   virtual void
-  getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name> &nameList, bool isDefault) = 0;
+  getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name>& nameList, bool isDefault) = 0;
 
 protected:
 
   /*****************************************
    *            Default Setter             *
    *****************************************/
-  
+
   /**
    * @brief Set the default identity.
    *
    * @param identityName The default identity name.
    */
-  virtual void 
+  virtual void
   setDefaultIdentityInternal(const Name& identityName) = 0;
-  
+
   /**
    * @brief Set the default key name for the corresponding identity.
-   * 
+   *
    * @param keyName The key name.
    * @throws SecPublicInfo::Error if the key does not exist.
    */
@@ -227,8 +235,8 @@
    * @param certificateName The certificate name.
    * @throws SecPublicInfo::Error if the certificatedoes not exist.
    */
-  virtual void 
-  setDefaultCertificateNameForKeyInternal(const Name& certificateName) = 0; 
+  virtual void
+  setDefaultCertificateNameForKeyInternal(const Name& certificateName) = 0;
 
   /*****************************************
    *            Delete Methods             *
@@ -240,7 +248,7 @@
    * @param certificateName The certificate name.
    */
   virtual void
-  deleteCertificateInfo(const Name &certificateName) = 0;
+  deleteCertificateInfo(const Name& certificateName) = 0;
 
   /**
    * @brief Delete a public key and related certificates.
@@ -248,7 +256,7 @@
    * @param keyName The key name.
    */
   virtual void
-  deletePublicKeyInfo(const Name &keyName) = 0;
+  deletePublicKeyInfo(const Name& keyName) = 0;
 
   /**
    * @brief Delete an identity and related public keys and certificates.
@@ -256,30 +264,30 @@
    * @param identity The identity name.
    */
   virtual void
-  deleteIdentityInfo(const Name &identity) = 0;
+  deleteIdentityInfo(const Name& identity) = 0;
 
 public:
-  
+
   /*****************************************
    *            Helper Methods             *
    *****************************************/
 
   /**
-   * @brief Set the default identity.  
+   * @brief Set the default identity.
    *
    * @param identityName The default identity name.
    * @throws SecPublicInfo::Error if the identity does not exist.
    */
-  inline void 
+  inline void
   setDefaultIdentity(const Name& identityName);
 
   /**
    * @brief Set the default key name for the corresponding identity.
-   * 
+   *
    * @param keyName The key name.
    * @throws SecPublicInfo::Error if either the identity or key does not exist.
    */
-  inline void 
+  inline void
   setDefaultKeyNameForIdentity(const Name& keyName);
 
   /**
@@ -288,8 +296,8 @@
    * @param certificateName The certificate name.
    * @throws SecPublicInfo::Error if either the certificate or key does not exist.
    */
-  inline void 
-  setDefaultCertificateNameForKey(const Name& certificateName); 
+  inline void
+  setDefaultCertificateNameForKey(const Name& certificateName);
 
   /**
    * @brief Generate a key name for the identity.
@@ -298,7 +306,7 @@
    * @param useKsk If true, generate a KSK name, otherwise a DSK name.
    * @return The generated key name.
    */
-  inline Name 
+  inline Name
   getNewKeyName(const Name& identityName, bool useKsk);
 
   /**
@@ -308,7 +316,7 @@
    * @return The default certificate name.
    * @throws SecPublicInfo::Error if no certificate is found.
    */
-  inline Name 
+  inline Name
   getDefaultCertificateNameForIdentity(const Name& identityName);
 
   /**
@@ -354,7 +362,7 @@
    */
   inline shared_ptr<IdentityCertificate>
   defaultCertificate();
-  
+
   /**
    * @brief try to get the default certificate of the default identity from the public info.
    */
@@ -379,14 +387,14 @@
   refreshDefaultCertificate();
 }
 
-inline void 
+inline void
 SecPublicInfo::setDefaultCertificateNameForKey(const Name& certificateName)
 {
   setDefaultCertificateNameForKeyInternal(certificateName);
   refreshDefaultCertificate();
 }
 
-inline Name 
+inline Name
 SecPublicInfo::getDefaultCertificateNameForIdentity(const Name& identityName)
 {
   return getDefaultCertificateNameForKey(getDefaultKeyNameForIdentity(identityName));
@@ -403,7 +411,7 @@
     oss << "dsk-";
 
   oss << time::toUnixTimestamp(time::system_clock::now()).count();
-  
+
   Name keyName = Name(identityName).append(oss.str());
 
   if (doesPublicKeyExist(keyName))
@@ -415,10 +423,10 @@
 inline Name
 SecPublicInfo::getDefaultCertificateName()
 {
-  if(!static_cast<bool>(m_defaultCertificate))
+  if (!static_cast<bool>(m_defaultCertificate))
     refreshDefaultCertificate();
 
-  if(!static_cast<bool>(m_defaultCertificate))
+  if (!static_cast<bool>(m_defaultCertificate))
     throw Error("No default certificate is set");
 
   return m_defaultCertificate->getName();
@@ -437,7 +445,7 @@
 {
   addCertificate(certificate);
   Name certName = certificate.getName();
-  setDefaultKeyNameForIdentityInternal(IdentityCertificate::certificateNameToPublicKeyName(certName)); 
+  setDefaultKeyNameForIdentityInternal(IdentityCertificate::certificateNameToPublicKeyName(certName));
   setDefaultCertificateNameForKeyInternal(certName);
   refreshDefaultCertificate();
 }
@@ -468,7 +476,7 @@
       Name certName = getDefaultCertificateNameForIdentity(getDefaultIdentity());
       m_defaultCertificate = getCertificate(certName);
     }
-  catch(SecPublicInfo::Error& e)
+  catch (SecPublicInfo::Error& e)
     {
       m_defaultCertificate.reset();
     }
diff --git a/src/security/sec-rule-relative.cpp b/src/security/sec-rule-relative.cpp
index 1fdfa7d..6133aac 100644
--- a/src/security/sec-rule-relative.cpp
+++ b/src/security/sec-rule-relative.cpp
@@ -20,7 +20,7 @@
 
 namespace ndn {
 
-SecRuleRelative::SecRuleRelative (const string& dataRegex, const string& signerRegex, const string& op, 
+SecRuleRelative::SecRuleRelative (const string& dataRegex, const string& signerRegex, const string& op,
                                   const string& dataExpand, const string& signerExpand, bool isPositive)
   : SecRule(isPositive),
     m_dataRegex(dataRegex),
@@ -31,68 +31,73 @@
     m_dataNameRegex(dataRegex, dataExpand),
     m_signerNameRegex(signerRegex, signerExpand)
 {
-  if(op != ">" && op != ">=" && op != "==")
+  if (op != ">" && op != ">=" && op != "==")
     throw Error("op is wrong!");
 }
 
 SecRuleRelative::~SecRuleRelative()
-{ }
+{
+}
 
-bool 
+bool
 SecRuleRelative::satisfy (const Data& data)
 {
   Name dataName = data.getName();
-  try{
+  try {
     SignatureSha256WithRsa sig(data.getSignature());
     Name signerName = sig.getKeyLocator().getName ();
-    return satisfy (dataName, signerName); 
-  }catch(SignatureSha256WithRsa::Error &e){
+    return satisfy (dataName, signerName);
+  }
+  catch (SignatureSha256WithRsa::Error& e){
     return false;
-  }catch(KeyLocator::Error &e){
+  }
+  catch (KeyLocator::Error& e){
     return false;
   }
 }
-  
-bool 
+
+bool
 SecRuleRelative::satisfy (const Name& dataName, const Name& signerName)
 {
-  if(!m_dataNameRegex.match(dataName))
+  if (!m_dataNameRegex.match(dataName))
     return false;
   Name expandDataName = m_dataNameRegex.expand();
 
-  if(!m_signerNameRegex.match(signerName))
+  if (!m_signerNameRegex.match(signerName))
     return false;
   Name expandSignerName =  m_signerNameRegex.expand();
-  
+
   bool matched = compare(expandDataName, expandSignerName);
-  
+
   return matched;
 }
 
-bool 
+bool
 SecRuleRelative::matchDataName (const Data& data)
 { return m_dataNameRegex.match(data.getName()); }
 
 bool
 SecRuleRelative::matchSignerName (const Data& data)
-{    
-  try{
+{
+  try {
     SignatureSha256WithRsa sig(data.getSignature());
     Name signerName = sig.getKeyLocator().getName ();
-    return m_signerNameRegex.match(signerName); 
-  }catch(SignatureSha256WithRsa::Error &e){
+    return m_signerNameRegex.match(signerName);
+  }
+  catch (SignatureSha256WithRsa::Error& e){
     return false;
-  }catch(KeyLocator::Error &e){
+  }
+  catch (KeyLocator::Error& e){
     return false;
   }
 }
 
-bool 
-SecRuleRelative::compare(const Name & dataName, const Name & signerName)
-{  
-  if((dataName == signerName) && ("==" == m_op || ">=" == m_op))
+bool
+SecRuleRelative::compare(const Name& dataName, const Name& signerName)
+{
+  if ((dataName == signerName) && ("==" == m_op || ">=" == m_op))
     return true;
-    
+
   Name::const_iterator i = dataName.begin ();
   Name::const_iterator j = signerName.begin ();
 
@@ -103,10 +108,10 @@
       else
         return false;
     }
-    
-  if(i == dataName.end())
+
+  if (i == dataName.end())
     return false;
-  else 
+  else
     return true;
 }
 
diff --git a/src/security/sec-rule-relative.hpp b/src/security/sec-rule-relative.hpp
index 59c8f09..7ea4c51 100644
--- a/src/security/sec-rule-relative.hpp
+++ b/src/security/sec-rule-relative.hpp
@@ -13,41 +13,49 @@
 #include "../util/regex.hpp"
 
 namespace ndn {
-  
+
 class SecRuleRelative : public SecRule
 {
 public:
-  struct Error : public SecRule::Error { Error(const std::string &what) : SecRule::Error(what) {} };
-  
-  SecRuleRelative(const std::string& dataRegex, const std::string& signerRegex, const std::string& op, 
+  class Error : public SecRule::Error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : SecRule::Error(what)
+    {
+    }
+  };
+
+  SecRuleRelative(const std::string& dataRegex, const std::string& signerRegex, const std::string& op,
                   const std::string& dataExpand, const std::string& signerExpand, bool isPositive);
-  
+
   virtual
   ~SecRuleRelative();
-  
-  virtual bool 
+
+  virtual bool
   matchDataName(const Data& data);
-  
-  virtual bool 
+
+  virtual bool
   matchSignerName(const Data& data);
-  
+
   virtual bool
   satisfy(const Data& data);
-  
+
   virtual bool
   satisfy(const Name& dataName, const Name& signerName);
-  
+
 private:
-  bool 
+  bool
   compare(const Name& dataName, const Name& signerName);
-  
+
 private:
   const std::string m_dataRegex;
   const std::string m_signerRegex;
   const std::string m_op;
   const std::string m_dataExpand;
   const std::string m_signerExpand;
-  
+
   Regex m_dataNameRegex;
   Regex m_signerNameRegex;
 };
diff --git a/src/security/sec-rule-specific.cpp b/src/security/sec-rule-specific.cpp
index 484a08e..a9fee4e 100644
--- a/src/security/sec-rule-specific.cpp
+++ b/src/security/sec-rule-specific.cpp
@@ -27,34 +27,36 @@
   , m_signerRegex(rule.m_signerRegex)
 {}
 
-bool 
+bool
 SecRuleSpecific::matchDataName(const Data& data)
 { return m_dataRegex->match(data.getName()); }
 
-bool 
+bool
 SecRuleSpecific::matchSignerName(const Data& data)
-{ 
-  try{
+{
+  try {
     SignatureSha256WithRsa sig(data.getSignature());
     Name signerName = sig.getKeyLocator().getName ();
-    return m_signerRegex->match(signerName); 
-  }catch(SignatureSha256WithRsa::Error &e){
+    return m_signerRegex->match(signerName);
+  }
+  catch (SignatureSha256WithRsa::Error& e) {
     return false;
-  }catch(KeyLocator::Error &e){
+  }
+  catch (KeyLocator::Error& e) {
     return false;
   }
 }
 
 bool
-SecRuleSpecific::satisfy(const Data & data)
-{ 
-  return (matchDataName(data) && matchSignerName(data)) ? true : false ; 
+SecRuleSpecific::satisfy(const Data& data)
+{
+  return (matchDataName(data) && matchSignerName(data)) ? true : false;
 }
 
 bool
-SecRuleSpecific::satisfy(const Name & dataName, const Name & signerName)
-{ 
-  return (m_dataRegex->match(dataName) && m_signerRegex->match(signerName)); 
+SecRuleSpecific::satisfy(const Name& dataName, const Name& signerName)
+{
+  return (m_dataRegex->match(dataName) && m_signerRegex->match(signerName));
 }
 
 } // namespace ndn
diff --git a/src/security/sec-rule.hpp b/src/security/sec-rule.hpp
index 496b33d..ecb9686 100644
--- a/src/security/sec-rule.hpp
+++ b/src/security/sec-rule.hpp
@@ -16,31 +16,39 @@
 class SecRule
 {
 public:
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
-  
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
+
   SecRule(bool isPositive)
   : m_isPositive(isPositive)
   {}
-  
-  virtual 
-  ~SecRule() 
+
+  virtual
+  ~SecRule()
   {}
-  
-  virtual bool 
+
+  virtual bool
   matchDataName(const Data& data) = 0;
-  
-  virtual bool 
+
+  virtual bool
   matchSignerName(const Data& data) = 0;
-  
+
   virtual bool
   satisfy(const Data& data) = 0;
-  
+
   virtual bool
   satisfy(const Name& dataName, const Name& signerName) = 0;
-  
+
   inline bool
   isPositive();
-  
+
 protected:
   bool m_isPositive;
 };
@@ -50,7 +58,7 @@
 {
   return m_isPositive;
 }
-    
+
 } // namespace ndn
 
 #endif //NDN_SECURITY_SEC_RULE_HPP
diff --git a/src/security/sec-tpm-file.cpp b/src/security/sec-tpm-file.cpp
index 98e117f..3a05282 100644
--- a/src/security/sec-tpm-file.cpp
+++ b/src/security/sec-tpm-file.cpp
@@ -29,11 +29,11 @@
 public:
   Impl(const string& dir)
   {
-    if(dir.empty())
+    if (dir.empty())
       m_keystorePath = boost::filesystem::path(getenv("HOME")) / ".ndn" / "ndnsec-tpm-file";
     else
       m_keystorePath = dir;
-    
+
     boost::filesystem::create_directories (m_keystorePath);
   }
 
@@ -47,22 +47,22 @@
 
     boost::algorithm::trim(digest);
     std::replace(digest.begin(), digest.end(), '/', '%');
-    
+
     return m_keystorePath / (digest + extension);
   }
 
-  string 
+  string
   maintainMapping(const string& keyName)
   {
     string keyFileName = nameTransform(keyName, "").string();
-    
+
     ofstream outfile;
     string dirFile = (m_keystorePath / "mapping.txt").string();
-    
+
     outfile.open(dirFile.c_str(), std::ios_base::app);
     outfile << keyName << ' ' << keyFileName << '\n';
     outfile.close();
-    
+
     return keyFileName;
   }
 
@@ -77,19 +77,19 @@
 {}
 
 void
-SecTpmFile::generateKeyPairInTpm(const Name & keyName, KeyType keyType, int keySize)
+SecTpmFile::generateKeyPairInTpm(const Name& keyName, KeyType keyType, int keySize)
 {
   string keyURI = keyName.toUri();
 
-  if(doesKeyExistInTpm(keyName, KEY_CLASS_PUBLIC))
+  if (doesKeyExistInTpm(keyName, KEY_CLASS_PUBLIC))
     throw Error("public key exists");
-  if(doesKeyExistInTpm(keyName, KEY_CLASS_PRIVATE))
+  if (doesKeyExistInTpm(keyName, KEY_CLASS_PRIVATE))
     throw Error("private key exists");
 
   string keyFileName = m_impl->maintainMapping(keyURI);
 
   try{
-    switch(keyType){
+    switch (keyType){
     case KEY_TYPE_RSA:
       {
         using namespace CryptoPP;
@@ -97,18 +97,18 @@
 
 	InvertibleRSAFunction privateKey;
 	privateKey.Initialize(rng, keySize);
-	
+
 	string privateKeyFileName = keyFileName + ".pri";
 	Base64Encoder privateKeySink(new FileSink(privateKeyFileName.c_str()));
 	privateKey.DEREncode(privateKeySink);
 	privateKeySink.MessageEnd();
-	
+
 	RSAFunction publicKey(privateKey);
 	string publicKeyFileName = keyFileName + ".pub";
 	Base64Encoder publicKeySink(new FileSink(publicKeyFileName.c_str()));
 	publicKey.DEREncode(publicKeySink);
 	publicKeySink.MessageEnd();
-	
+
 	/*set file permission*/
 	chmod(privateKeyFileName.c_str(), 0000400);
 	chmod(publicKeyFileName.c_str(), 0000444);
@@ -117,37 +117,37 @@
     default:
       throw Error("Unsupported key type!");
     }
-  }catch(const CryptoPP::Exception& e){
+  }catch (const CryptoPP::Exception& e){
     throw Error(e.what());
   }
 }
 
 void
-SecTpmFile::deleteKeyPairInTpm(const Name &keyName)
+SecTpmFile::deleteKeyPairInTpm(const Name& keyName)
 {
   boost::filesystem::path publicKeyPath(m_impl->nameTransform(keyName.toUri(), ".pub"));
   boost::filesystem::path privateKeyPath(m_impl->nameTransform(keyName.toUri(), ".pri"));
 
-  if(boost::filesystem::exists(publicKeyPath))
+  if (boost::filesystem::exists(publicKeyPath))
     boost::filesystem::remove(publicKeyPath);
 
-  if(boost::filesystem::exists(privateKeyPath))
+  if (boost::filesystem::exists(privateKeyPath))
     boost::filesystem::remove(privateKeyPath);
 }
 
 shared_ptr<PublicKey>
-SecTpmFile::getPublicKeyFromTpm(const Name & keyName)
+SecTpmFile::getPublicKeyFromTpm(const Name&  keyName)
 {
   string keyURI = keyName.toUri();
 
-  if(!doesKeyExistInTpm(keyName, KEY_CLASS_PUBLIC))
+  if (!doesKeyExistInTpm(keyName, KEY_CLASS_PUBLIC))
     throw Error("Public Key already exist");
 
   ostringstream os;
   try{
     using namespace CryptoPP;
     FileSource(m_impl->nameTransform(keyURI, ".pub").string().c_str(), true, new Base64Decoder(new FileSink(os)));
-  }catch(const CryptoPP::Exception& e){
+  }catch (const CryptoPP::Exception& e){
     throw Error(e.what());
   }
 
@@ -158,9 +158,9 @@
 SecTpmFile::exportPrivateKeyPkcs1FromTpm(const Name& keyName)
 {
   OBufferStream privateKeyOs;
-  CryptoPP::FileSource(m_impl->nameTransform(keyName.toUri(), ".pri").string().c_str(), true, 
+  CryptoPP::FileSource(m_impl->nameTransform(keyName.toUri(), ".pri").string().c_str(), true,
                        new CryptoPP::Base64Decoder(new CryptoPP::FileSink(privateKeyOs)));
-  
+
   return privateKeyOs.buf();
 }
 
@@ -173,7 +173,7 @@
     CryptoPP::StringSource(buf, size, true,
                            new CryptoPP::Base64Encoder(new CryptoPP::FileSink(keyFileName.c_str())));
     return true;
-  }catch(...){
+  }catch (...){
     return false;
   }
 }
@@ -187,19 +187,19 @@
     CryptoPP::StringSource(buf, size, true,
                            new CryptoPP::Base64Encoder(new CryptoPP::FileSink(keyFileName.c_str())));
     return true;
-  }catch(...){
+  }catch (...){
     return false;
   }
 }
 
 Block
-SecTpmFile::signInTpm(const uint8_t *data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm)
+SecTpmFile::signInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm)
 {
   string keyURI = keyName.toUri();
 
-  if(!doesKeyExistInTpm(keyName, KEY_CLASS_PRIVATE))
+  if (!doesKeyExistInTpm(keyName, KEY_CLASS_PRIVATE))
     throw Error("private key doesn't exists");
- 
+
   try{
     using namespace CryptoPP;
     AutoSeededRandomPool rng;
@@ -211,22 +211,22 @@
     bytes.MessageEnd();
     RSA::PrivateKey privateKey;
     privateKey.Load(bytes);
-  
+
     //Sign message
-    switch(digestAlgorithm){
+    switch (digestAlgorithm){
     case DIGEST_ALGORITHM_SHA256:
       {
 	RSASS<PKCS1v15, SHA256>::Signer signer(privateKey);
-	
+
 	OBufferStream os;
 	StringSource(data, dataLength, true, new SignerFilter(rng, signer, new FileSink(os)));
-	
+
 	return Block(Tlv::SignatureValue, os.buf());
       }
     default:
       throw Error("Unsupported digest algorithm!");
     }
-  }catch(const CryptoPP::Exception& e){
+  }catch (const CryptoPP::Exception& e){
     throw Error(e.what());
   }
 }
@@ -239,7 +239,7 @@
   // string keyURI = keyName.toUri();
   // if (!isSymmetric)
   //   {
-  //     if(!doesKeyExistInTpm(keyName, KEY_CLASS_PRIVATE))
+  //     if (!doesKeyExistInTpm(keyName, KEY_CLASS_PRIVATE))
   //       throw Error("private key doesn't exist");
 
   //     try{
@@ -254,27 +254,27 @@
   //       RSA::PrivateKey privateKey;
   //       privateKey.Load(bytes);
   //       RSAES_PKCS1v15_Decryptor decryptor(privateKey);
-	
+
   //       OBufferStream os;
   //       StringSource(data, dataLength, true, new PK_DecryptorFilter(rng, decryptor, new FileSink(os)));
-	
+
   //       return os.buf();
   //     }
-  //     catch(const CryptoPP::Exception& e){
+  //     catch (const CryptoPP::Exception& e){
   //       throw Error(e.what());
   //     }
   //   }
   // else
   //   {
   //     throw Error("Symmetric encryption is not implemented!");
-  //     // if(!doesKeyExistInTpm(keyName, KEY_CLASS_SYMMETRIC))
+  //     // if (!doesKeyExistInTpm(keyName, KEY_CLASS_SYMMETRIC))
   //     // 	throw Error("symmetric key doesn't exist");
 
   //     // try{
   //     // 	string keyBits;
   //     // 	string symKeyFileName = m_impl->nameTransform(keyURI, ".key");
   //     // 	FileSource(symKeyFileName, true, new HexDecoder(new StringSink(keyBits)));
-	
+
   //     // 	using CryptoPP::AES;
   //     // 	AutoSeededRandomPool rnd;
   //     // 	byte iv[AES::BLOCKSIZE];
@@ -282,12 +282,12 @@
 
   //     // 	CFB_Mode<AES>::Decryption decryptor;
   //     // 	decryptor.SetKeyWithIV(reinterpret_cast<const uint8_t*>(keyBits.c_str()), keyBits.size(), iv);
-	
+
   //     // 	OBufferStream os;
   //     // 	StringSource(data, dataLength, true, new StreamTransformationFilter(decryptor,new FileSink(os)));
   //     // 	return os.buf();
 
-  //     // }catch(const CryptoPP::Exception& e){
+  //     // }catch (const CryptoPP::Exception& e){
   //     // 	throw Error(e.what());
   //     // }
   //   }
@@ -301,7 +301,7 @@
 
   // if (!isSymmetric)
   //   {
-  //     if(!doesKeyExistInTpm(keyName, KEY_CLASS_PUBLIC))
+  //     if (!doesKeyExistInTpm(keyName, KEY_CLASS_PUBLIC))
   //       throw Error("public key doesn't exist");
   //     try
   //       {
@@ -322,14 +322,14 @@
   //         StringSource(data, dataLength, true, new PK_EncryptorFilter(rng, encryptor, new FileSink(os)));
   //         return os.buf();
   //       }
-  //     catch(const CryptoPP::Exception& e){
+  //     catch (const CryptoPP::Exception& e){
   //       throw Error(e.what());
   //     }
   //   }
   // else
   //   {
   //     throw Error("Symmetric encryption is not implemented!");
-  //     // if(!doesKeyExistInTpm(keyName, KEY_CLASS_SYMMETRIC))
+  //     // if (!doesKeyExistInTpm(keyName, KEY_CLASS_SYMMETRIC))
   //     // 	throw Error("symmetric key doesn't exist");
 
   //     // try{
@@ -348,7 +348,7 @@
   //     // 	OBufferStream os;
   //     // 	StringSource(data, dataLength, true, new StreamTransformationFilter(encryptor, new FileSink(os)));
   //     // 	return os.buf();
-  //     // }catch(const CryptoPP::Exception& e){
+  //     // }catch (const CryptoPP::Exception& e){
   //     // 	throw Error(e.what());
   //     // }
   //   }
@@ -356,19 +356,19 @@
 
 
 void
-SecTpmFile::generateSymmetricKeyInTpm(const Name & keyName, KeyType keyType, int keySize)
+SecTpmFile::generateSymmetricKeyInTpm(const Name& keyName, KeyType keyType, int keySize)
 {
   throw Error("SecTpmFile::generateSymmetricKeyInTpm is not supported!");
   // string keyURI = keyName.toUri();
 
-  // if(doesKeyExistInTpm(keyName, KEY_CLASS_SYMMETRIC))
+  // if (doesKeyExistInTpm(keyName, KEY_CLASS_SYMMETRIC))
   //   throw Error("symmetric key exists");
 
   // string keyFileName = m_impl->maintainMapping(keyURI);
   // string symKeyFileName = keyFileName + ".key";
 
   // try{
-  //   switch(keyType){
+  //   switch (keyType){
   //   case KEY_TYPE_AES:
   //     {
   //       using namespace CryptoPP;
@@ -376,41 +376,41 @@
 
   //       SecByteBlock key(0x00, keySize);
   //       rng.GenerateBlock(key, keySize);
-	
+
   //       StringSource(key, key.size(), true, new HexEncoder(new FileSink(symKeyFileName.c_str())));
-	
+
   //       chmod(symKeyFileName.c_str(), 0000400);
   //       return;
   //     }
   //   default:
   //     throw Error("Unsupported symmetric key type!");
   //   }
-  // }catch(const CryptoPP::Exception& e){
+  // }catch (const CryptoPP::Exception& e){
   //   throw Error(e.what());
   // }
 }
 
 bool
-SecTpmFile::doesKeyExistInTpm(const Name & keyName, KeyClass keyClass)
+SecTpmFile::doesKeyExistInTpm(const Name& keyName, KeyClass keyClass)
 {
   string keyURI = keyName.toUri();
   if (keyClass == KEY_CLASS_PUBLIC)
     {
-      if(boost::filesystem::exists(m_impl->nameTransform(keyURI, ".pub")))
+      if (boost::filesystem::exists(m_impl->nameTransform(keyURI, ".pub")))
         return true;
       else
         return false;
     }
   if (keyClass == KEY_CLASS_PRIVATE)
     {
-      if(boost::filesystem::exists(m_impl->nameTransform(keyURI, ".pri")))
+      if (boost::filesystem::exists(m_impl->nameTransform(keyURI, ".pri")))
         return true;
       else
         return false;
     }
   if (keyClass == KEY_CLASS_SYMMETRIC)
     {
-      if(boost::filesystem::exists(m_impl->nameTransform(keyURI, ".key")))
+      if (boost::filesystem::exists(m_impl->nameTransform(keyURI, ".key")))
         return true;
       else
         return false;
@@ -421,11 +421,12 @@
 bool
 SecTpmFile::generateRandomBlock(uint8_t* res, size_t size)
 {
-  try{
+  try {
     CryptoPP::AutoSeededRandomPool rng;
     rng.GenerateBlock(res, size);
     return true;
-  }catch(const CryptoPP::Exception& e){
+  }
+  catch (const CryptoPP::Exception& e) {
     return false;
   }
 }
diff --git a/src/security/sec-tpm-file.hpp b/src/security/sec-tpm-file.hpp
index 8a108c5..fc1e410 100644
--- a/src/security/sec-tpm-file.hpp
+++ b/src/security/sec-tpm-file.hpp
@@ -18,9 +18,17 @@
 class SecTpmFile : public SecTpm
 {
 public:
-  struct Error : public SecTpm::Error { Error(const std::string &what) : SecTpm::Error(what) {} };
+  class Error : public SecTpm::Error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : SecTpm::Error(what)
+    {
+    }
+  };
 
-  SecTpmFile(const std::string & dir = "");
+  SecTpmFile(const std::string& dir = "");
 
   virtual
   ~SecTpmFile() {};
@@ -58,24 +66,24 @@
   }
 
   virtual void
-  generateKeyPairInTpm(const Name & keyName, KeyType keyType, int keySize);
+  generateKeyPairInTpm(const Name& keyName, KeyType keyType, int keySize);
 
   virtual void
-  deleteKeyPairInTpm(const Name &keyName);
+  deleteKeyPairInTpm(const Name& keyName);
 
   virtual shared_ptr<PublicKey>
-  getPublicKeyFromTpm(const Name & keyName);
+  getPublicKeyFromTpm(const Name&  keyName);
 
   virtual Block
-  signInTpm(const uint8_t *data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm);
+  signInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm);
 
-  virtual ConstBufferPtr 
+  virtual ConstBufferPtr
   decryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool isSymmetric);
 
   virtual ConstBufferPtr
   encryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool isSymmetric);
 
-  virtual void 
+  virtual void
   generateSymmetricKeyInTpm(const Name& keyName, KeyType keyType, int keySize);
 
   virtual bool
@@ -84,7 +92,7 @@
   virtual bool
   generateRandomBlock(uint8_t* res, size_t size);
 
-  virtual void 
+  virtual void
   addAppToACL(const Name& keyName, KeyClass keyClass, const std::string& appPath, AclType acl)
   {}
 
@@ -97,7 +105,7 @@
 
   virtual bool
   importPrivateKeyPkcs1IntoTpm(const Name& keyName, const uint8_t* buf, size_t size);
-  
+
   virtual bool
   importPublicKeyPkcs1IntoTpm(const Name& keyName, const uint8_t* buf, size_t size);
 
diff --git a/src/security/sec-tpm-memory.cpp b/src/security/sec-tpm-memory.cpp
index 3c77c15..e196f88 100644
--- a/src/security/sec-tpm-memory.cpp
+++ b/src/security/sec-tpm-memory.cpp
@@ -174,11 +174,12 @@
 bool
 SecTpmMemory::generateRandomBlock(uint8_t* res, size_t size)
 {
-  try{
+  try {
     CryptoPP::AutoSeededRandomPool rng;
     rng.GenerateBlock(res, size);
     return true;
-  }catch(const CryptoPP::Exception& e){
+  }
+  catch (const CryptoPP::Exception& e) {
     return false;
   }
 }
diff --git a/src/security/sec-tpm-memory.hpp b/src/security/sec-tpm-memory.hpp
index 2c8cc2b..605d7c8 100644
--- a/src/security/sec-tpm-memory.hpp
+++ b/src/security/sec-tpm-memory.hpp
@@ -21,7 +21,15 @@
  */
 class SecTpmMemory : public SecTpm {
 public:
-  struct Error : public SecTpm::Error { Error(const std::string &what) : SecTpm::Error(what) {} };
+  class Error : public SecTpm::Error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : SecTpm::Error(what)
+    {
+    }
+  };
 
   virtual
   ~SecTpmMemory();
@@ -69,7 +77,7 @@
   getPublicKeyFromTpm(const Name& keyName);
 
   virtual void
-  deleteKeyPairInTpm(const Name &keyName);
+  deleteKeyPairInTpm(const Name& keyName);
 
   virtual Block
   signInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm);
diff --git a/src/security/sec-tpm-osx.cpp b/src/security/sec-tpm-osx.cpp
index 96c9034..6a5250c 100644
--- a/src/security/sec-tpm-osx.cpp
+++ b/src/security/sec-tpm-osx.cpp
@@ -46,7 +46,7 @@
    * @return the internal key name
    */
   std::string
-  toInternalKeyName(const Name & keyName, KeyClass keyClass);
+  toInternalKeyName(const Name& keyName, KeyClass keyClass);
 
   /**
    * @brief Get key.
@@ -56,7 +56,7 @@
    * @returns pointer to the key
    */
   SecKeychainItemRef
-  getKey(const Name & keyName, KeyClass keyClass);
+  getKey(const Name& keyName, KeyClass keyClass);
 
   /**
    * @brief Convert keyType to MAC OS symmetric key key type
@@ -117,7 +117,7 @@
 SecTpmOsx::SecTpmOsx()
   : m_impl(new Impl)
 {
-  if(m_impl->m_inTerminal)
+  if (m_impl->m_inTerminal)
     SecKeychainSetUserInteractionAllowed (false);
   else
     SecKeychainSetUserInteractionAllowed (true);
@@ -153,7 +153,7 @@
 SecTpmOsx::setInTerminal(bool inTerminal)
 {
   m_impl->m_inTerminal = inTerminal;
-  if(inTerminal)
+  if (inTerminal)
     SecKeychainSetUserInteractionAllowed (false);
   else
     SecKeychainSetUserInteractionAllowed (true);
@@ -171,7 +171,7 @@
   SecKeychainStatus keychainStatus;
 
   OSStatus res = SecKeychainGetStatus(m_impl->m_keyChainRef, &keychainStatus);
-  if(res != errSecSuccess)
+  if (res != errSecSuccess)
     return true;
   else
     return ((kSecUnlockStateStatus & keychainStatus) == 0);
@@ -183,11 +183,11 @@
   OSStatus res;
 
   // If the default key chain is already unlocked, return immediately.
-  if(!locked())
+  if (!locked())
     return true;
 
   // If the default key chain is locked, unlock the key chain.
-  if(usePassword)
+  if (usePassword)
     {
       // Use the supplied password.
       res = SecKeychainUnlock(m_impl->m_keyChainRef,
@@ -195,7 +195,7 @@
                               password,
                               true);
     }
-  else if(m_impl->m_passwordSet)
+  else if (m_impl->m_passwordSet)
     {
       // If no password supplied, then use the configured password if exists.
       SecKeychainUnlock(m_impl->m_keyChainRef,
@@ -203,7 +203,7 @@
                         m_impl->m_password.c_str(),
                         true);
     }
-  else if(m_impl->m_inTerminal)
+  else if (m_impl->m_inTerminal)
     {
       // If no configured password, get password from terminal if inTerminal set.
       bool locked = true;
@@ -212,7 +212,7 @@
 
       while(locked)
         {
-          if(count > 2)
+          if (count > 2)
             break;
 
           char* getPassword = NULL;
@@ -229,7 +229,7 @@
 
           memset(getPassword, 0, strlen(getPassword));
 
-          if(res == errSecSuccess)
+          if (res == errSecSuccess)
             break;
         }
     }
@@ -243,10 +243,10 @@
 }
 
 void
-SecTpmOsx::generateKeyPairInTpmInternal(const Name & keyName, KeyType keyType, int keySize, bool retry)
+SecTpmOsx::generateKeyPairInTpmInternal(const Name& keyName, KeyType keyType, int keySize, bool retry)
 {
 
-  if(doesKeyExistInTpm(keyName, KEY_CLASS_PUBLIC)){
+  if (doesKeyExistInTpm(keyName, KEY_CLASS_PUBLIC)){
     _LOG_DEBUG("keyName has existed");
     throw Error("keyName has existed");
   }
@@ -279,7 +279,7 @@
 
   if (res == errSecAuthFailed && !retry)
     {
-      if(unlockTpm(0, 0, false))
+      if (unlockTpm(0, 0, false))
         generateKeyPairInTpmInternal(keyName, keyType, keySize, true);
       else
         throw Error("Fail to unlock the keychain");
@@ -292,7 +292,7 @@
 }
 
 void
-SecTpmOsx::deleteKeyPairInTpmInternal(const Name &keyName, bool retry)
+SecTpmOsx::deleteKeyPairInTpmInternal(const Name& keyName, bool retry)
 {
   CFStringRef keyLabel = CFStringCreateWithCString(NULL,
                                                    keyName.toUri().c_str(),
@@ -311,16 +311,16 @@
 
   if (res == errSecAuthFailed && !retry)
     {
-      if(unlockTpm(0, 0, false))
+      if (unlockTpm(0, 0, false))
         deleteKeyPairInTpmInternal(keyName, true);
     }
 }
 
 void
-SecTpmOsx::generateSymmetricKeyInTpm(const Name & keyName, KeyType keyType, int keySize)
+SecTpmOsx::generateSymmetricKeyInTpm(const Name& keyName, KeyType keyType, int keySize)
 {
   throw Error("SecTpmOsx::generateSymmetricKeyInTpm is not supported");
-  // if(doesKeyExistInTpm(keyName, KEY_CLASS_SYMMETRIC))
+  // if (doesKeyExistInTpm(keyName, KEY_CLASS_SYMMETRIC))
   //   throw Error("keyName has existed!");
 
   // string keyNameUri =  m_impl->toInternalKeyName(keyName, KEY_CLASS_SYMMETRIC);
@@ -348,7 +348,7 @@
 }
 
 shared_ptr<PublicKey>
-SecTpmOsx::getPublicKeyFromTpm(const Name & keyName)
+SecTpmOsx::getPublicKeyFromTpm(const Name& keyName)
 {
   _LOG_TRACE("OSXPrivateKeyStorage::getPublickey");
 
@@ -384,11 +384,11 @@
                                NULL,
                                &exportedKey);
 
-  if(res != errSecSuccess)
+  if (res != errSecSuccess)
     {
-      if(res == errSecAuthFailed && !retry)
+      if (res == errSecAuthFailed && !retry)
         {
-          if(unlockTpm(0, 0, false))
+          if (unlockTpm(0, 0, false))
             return exportPrivateKeyPkcs1FromTpmInternal(keyName, true);
           else
             return shared_ptr<Buffer>();
@@ -493,11 +493,11 @@
 #pragma clang diagnostic pop
 #endif // __clang__
 
-  if(res != errSecSuccess)
+  if (res != errSecSuccess)
     {
-      if(res == errSecAuthFailed && !retry)
+      if (res == errSecAuthFailed && !retry)
         {
-          if(unlockTpm(0, 0, false))
+          if (unlockTpm(0, 0, false))
             return importPrivateKeyPkcs1IntoTpmInternal(keyName, buf, size, true);
           else
             return false;
@@ -522,7 +522,7 @@
                                                0,
                                                NULL);
 
-  if(res != errSecSuccess)
+  if (res != errSecSuccess)
     {
       return false;
     }
@@ -556,7 +556,7 @@
                                 m_impl->m_keyChainRef,
                                 &outItems);
 
-  if(res != errSecSuccess)
+  if (res != errSecSuccess)
     return false;
 
   SecKeychainItemRef publicKey = (SecKeychainItemRef)CFArrayGetValueAtIndex(outItems, 0);
@@ -575,7 +575,7 @@
                                                0,
                                                NULL);
 
-  if(res != errSecSuccess)
+  if (res != errSecSuccess)
     return false;
 
   CFRelease(importedKey);
@@ -583,7 +583,7 @@
 }
 
 Block
-SecTpmOsx::signInTpmInternal(const uint8_t *data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm, bool retry)
+SecTpmOsx::signInTpmInternal(const uint8_t* data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm, bool retry)
 {
   _LOG_TRACE("OSXPrivateKeyStorage::Sign");
 
@@ -631,9 +631,9 @@
   CFDataRef signature = (CFDataRef) SecTransformExecute(signer, &error);
   if (error)
     {
-      if(!retry)
+      if (!retry)
         {
-          if(unlockTpm(0, 0, false))
+          if (unlockTpm(0, 0, false))
             return signInTpmInternal(data, dataLength, keyName, digestAlgorithm, true);
           else
             throw Error("Fail to unlock the keychain");
@@ -652,13 +652,13 @@
 }
 
 ConstBufferPtr
-SecTpmOsx::decryptInTpm(const uint8_t* data, size_t dataLength, const Name & keyName, bool sym)
+SecTpmOsx::decryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool sym)
 {
   throw Error("SecTpmOsx::decryptInTpm is not supported");
   // _LOG_TRACE("OSXPrivateKeyStorage::Decrypt");
 
   // KeyClass keyClass;
-  // if(sym)
+  // if (sym)
   //   keyClass = KEY_CLASS_SYMMETRIC;
   // else
   //   keyClass = KEY_CLASS_PRIVATE;
@@ -696,9 +696,9 @@
 }
 
 void
-SecTpmOsx::addAppToACL(const Name & keyName, KeyClass keyClass, const string & appPath, AclType acl)
+SecTpmOsx::addAppToACL(const Name& keyName, KeyClass keyClass, const string& appPath, AclType acl)
 {
-  if(keyClass == KEY_CLASS_PRIVATE && acl == ACL_TYPE_PRIVATE)
+  if (keyClass == KEY_CLASS_PRIVATE && acl == ACL_TYPE_PRIVATE)
     {
       SecKeychainItemRef privateKey = m_impl->getKey(keyName, keyClass);
 
@@ -738,13 +738,13 @@
 }
 
 ConstBufferPtr
-SecTpmOsx::encryptInTpm(const uint8_t* data, size_t dataLength, const Name & keyName, bool sym)
+SecTpmOsx::encryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool sym)
 {
   throw Error("SecTpmOsx::encryptInTpm is not supported");
   // _LOG_TRACE("OSXPrivateKeyStorage::Encrypt");
 
   // KeyClass keyClass;
-  // if(sym)
+  // if (sym)
   //   keyClass = KEY_CLASS_SYMMETRIC;
   // else
   //   keyClass = KEY_CLASS_PUBLIC;
@@ -775,7 +775,7 @@
 }
 
 bool
-SecTpmOsx::doesKeyExistInTpm(const Name & keyName, KeyClass keyClass)
+SecTpmOsx::doesKeyExistInTpm(const Name& keyName, KeyClass keyClass)
 {
   _LOG_TRACE("OSXPrivateKeyStorage::doesKeyExist");
 
@@ -798,7 +798,7 @@
   SecKeychainItemRef itemRef;
   OSStatus res = SecItemCopyMatching((CFDictionaryRef)attrDict, (CFTypeRef*)&itemRef);
 
-  if(res == errSecSuccess)
+  if (res == errSecSuccess)
     return true;
   else
     return false;
@@ -816,7 +816,7 @@
 ////////////////////////////////
 
 SecKeychainItemRef
-SecTpmOsx::Impl::getKey(const Name & keyName, KeyClass keyClass)
+SecTpmOsx::Impl::getKey(const Name& keyName, KeyClass keyClass)
 {
   string keyNameUri = toInternalKeyName(keyName, keyClass);
 
@@ -838,7 +838,7 @@
 
   OSStatus res = SecItemCopyMatching((CFDictionaryRef) attrDict, (CFTypeRef*)&keyItem);
 
-  if(res != errSecSuccess){
+  if (res != errSecSuccess){
     _LOG_DEBUG("Fail to find the key!");
     return NULL;
   }
@@ -847,11 +847,11 @@
 }
 
 string
-SecTpmOsx::Impl::toInternalKeyName(const Name & keyName, KeyClass keyClass)
+SecTpmOsx::Impl::toInternalKeyName(const Name& keyName, KeyClass keyClass)
 {
   string keyUri = keyName.toUri();
 
-  if(KEY_CLASS_SYMMETRIC == keyClass)
+  if (KEY_CLASS_SYMMETRIC == keyClass)
     return keyUri + "/symmetric";
   else
     return keyUri;
@@ -860,7 +860,7 @@
 const CFTypeRef
 SecTpmOsx::Impl::getAsymKeyType(KeyType keyType)
 {
-  switch(keyType){
+  switch (keyType){
   case KEY_TYPE_RSA:
     return kSecAttrKeyTypeRSA;
   default:
@@ -872,7 +872,7 @@
 const CFTypeRef
 SecTpmOsx::Impl::getSymKeyType(KeyType keyType)
 {
-  switch(keyType){
+  switch (keyType){
   case KEY_TYPE_AES:
     return kSecAttrKeyTypeAES;
   default:
@@ -884,7 +884,7 @@
 const CFTypeRef
 SecTpmOsx::Impl::getKeyClass(KeyClass keyClass)
 {
-  switch(keyClass){
+  switch (keyClass){
   case KEY_CLASS_PRIVATE:
     return kSecAttrKeyClassPrivate;
   case KEY_CLASS_PUBLIC:
@@ -900,7 +900,7 @@
 const CFStringRef
 SecTpmOsx::Impl::getDigestAlgorithm(DigestAlgorithm digestAlgo)
 {
-  switch(digestAlgo){
+  switch (digestAlgo){
     // case DIGEST_MD2:
     //   return kSecDigestMD2;
     // case DIGEST_MD5:
@@ -918,7 +918,7 @@
 long
 SecTpmOsx::Impl::getDigestSize(DigestAlgorithm digestAlgo)
 {
-  switch(digestAlgo){
+  switch (digestAlgo){
   case DIGEST_ALGORITHM_SHA256:
     return 256;
     // case DIGEST_SHA1:
diff --git a/src/security/sec-tpm-osx.hpp b/src/security/sec-tpm-osx.hpp
index f9cfc57..3dc6877 100644
--- a/src/security/sec-tpm-osx.hpp
+++ b/src/security/sec-tpm-osx.hpp
@@ -12,14 +12,22 @@
 #include "sec-tpm.hpp"
 
 namespace ndn {
-  
+
 class SecTpmOsx : public SecTpm {
 public:
-  struct Error : public SecTpm::Error { Error(const std::string& what) : SecTpm::Error(what) {} };
+  class Error : public SecTpm::Error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : SecTpm::Error(what)
+    {
+    }
+  };
 
   SecTpmOsx();
 
-  virtual 
+  virtual
   ~SecTpmOsx();
 
 
@@ -45,7 +53,7 @@
   virtual bool
   unlockTpm(const char* password, size_t passwordLength, bool usePassword);
 
-  virtual void 
+  virtual void
   generateKeyPairInTpm(const Name& keyName, KeyType keyType, int keySize)
   {
     generateKeyPairInTpmInternal(keyName, keyType, keySize, false);
@@ -57,31 +65,31 @@
     deleteKeyPairInTpmInternal(keyName, false);
   }
 
-  virtual shared_ptr<PublicKey> 
+  virtual shared_ptr<PublicKey>
   getPublicKeyFromTpm(const Name& keyName);
-  
+
   virtual Block
   signInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm)
   {
     return signInTpmInternal(data, dataLength, keyName, digestAlgorithm, false);
   }
 
-  virtual ConstBufferPtr 
+  virtual ConstBufferPtr
   decryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool isSymmetric);
 
   virtual ConstBufferPtr
   encryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool isSymmetric);
 
-  virtual void 
+  virtual void
   generateSymmetricKeyInTpm(const Name& keyName, KeyType keyType, int keySize);
 
   virtual bool
-  doesKeyExistInTpm(const Name& keyName, KeyClass keyClass); 
+  doesKeyExistInTpm(const Name& keyName, KeyClass keyClass);
 
   virtual bool
-  generateRandomBlock(uint8_t* res, size_t size); 
+  generateRandomBlock(uint8_t* res, size_t size);
 
-  virtual void 
+  virtual void
   addAppToACL(const Name& keyName, KeyClass keyClass, const std::string& appPath, AclType acl);
 
 protected:
@@ -107,10 +115,10 @@
    *       OSX-specifics        *
    ******************************/
   void
-  generateKeyPairInTpmInternal(const Name & keyName, KeyType keyType, int keySize, bool retry);
-  
+  generateKeyPairInTpmInternal(const Name& keyName, KeyType keyType, int keySize, bool retry);
+
   void
-  deleteKeyPairInTpmInternal(const Name &keyName, bool retry);
+  deleteKeyPairInTpmInternal(const Name& keyName, bool retry);
 
   ConstBufferPtr
   exportPrivateKeyPkcs1FromTpmInternal(const Name& keyName, bool retry);
@@ -119,13 +127,13 @@
   importPrivateKeyPkcs1IntoTpmInternal(const Name& keyName, const uint8_t* buf, size_t size, bool retry);
 
   Block
-  signInTpmInternal(const uint8_t *data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm, bool retry);
-  
+  signInTpmInternal(const uint8_t* data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm, bool retry);
+
 private:
   class Impl;
   shared_ptr<Impl> m_impl;
 };
-  
+
 } // namespace ndn
 
 #endif // NDN_SECURITY_SEC_TPM_OSX_HPP
diff --git a/src/security/sec-tpm.cpp b/src/security/sec-tpm.cpp
index e19196c..3638ca1 100644
--- a/src/security/sec-tpm.cpp
+++ b/src/security/sec-tpm.cpp
@@ -17,28 +17,28 @@
 SecTpm::exportPrivateKeyPkcs8FromTpm(const Name& keyName, const string& passwordStr)
 {
   using namespace CryptoPP;
-    
+
   uint8_t salt[8] = {0};
   uint8_t iv[8] = {0};
-    
+
   // derive key
-  if(!generateRandomBlock(salt, 8) || !generateRandomBlock(iv, 8))
+  if (!generateRandomBlock(salt, 8) || !generateRandomBlock(iv, 8))
     throw Error("Cannot generate salt or iv");
 
   uint32_t iterationCount = 2048;
-  
+
   PKCS5_PBKDF2_HMAC<SHA1> keyGenerator;
   size_t derivedLen = 24; //For DES-EDE3-CBC-PAD
   byte derived[24] = {0};
   byte purpose = 0;
-  
+
   try
     {
-      keyGenerator.DeriveKey(derived, derivedLen, purpose, 
-                             reinterpret_cast<const byte*>(passwordStr.c_str()), passwordStr.size(), 
+      keyGenerator.DeriveKey(derived, derivedLen, purpose,
+                             reinterpret_cast<const byte*>(passwordStr.c_str()), passwordStr.size(),
                              salt, 8, iterationCount);
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       throw Error("Cannot derived the encryption key");
     }
@@ -46,18 +46,18 @@
   //encrypt
   CBC_Mode< DES_EDE3 >::Encryption e;
   e.SetKeyWithIV(derived, derivedLen, iv);
-  
+
   ConstBufferPtr pkcs1PrivateKey = exportPrivateKeyPkcs1FromTpm(keyName);
-  if(!static_cast<bool>(pkcs1PrivateKey))
+  if (!static_cast<bool>(pkcs1PrivateKey))
     throw Error("Cannot export the private key, #1");
 
   OBufferStream encryptedOs;
   try
     {
-      StringSource stringSource(pkcs1PrivateKey->buf(), pkcs1PrivateKey->size(), true, 
+      StringSource stringSource(pkcs1PrivateKey->buf(), pkcs1PrivateKey->size(), true,
                                 new StreamTransformationFilter(e, new FileSink(encryptedOs)));
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       throw Error("Cannot export the private key, #2");
     }
@@ -71,7 +71,7 @@
   try
     {
       FileSink sink(pkcs8Os);
-      
+
       // EncryptedPrivateKeyInfo ::= SEQUENCE {
       //   encryptionAlgorithm  EncryptionAlgorithmIdentifier,
       //   encryptedData        OCTET STRING }
@@ -107,7 +107,7 @@
               pbkdf2Params.MessageEnd();
             }
             pbes2KDFs.MessageEnd();
-            
+
             // AlgorithmIdentifier ::= SEQUENCE {
             //   algorithm   OBJECT IDENTIFIER {{DES-EDE3-CBC-PAD}},
             //   parameters  OCTET STRING} {{iv}} }
@@ -121,14 +121,14 @@
           pbes2Params.MessageEnd();
         }
         encryptionAlgorithm.MessageEnd();
-        
+
         DEREncodeOctetString(encryptedPrivateKeyInfo, encryptedOs.buf()->buf(), encryptedOs.buf()->size());
       }
       encryptedPrivateKeyInfo.MessageEnd();
-      
+
       return pkcs8Os.buf();
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       throw Error("Cannot export the private key, #3");
     }
@@ -138,7 +138,7 @@
 SecTpm::importPrivateKeyPkcs8IntoTpm(const Name& keyName, const uint8_t* buf, size_t size, const string& passwordStr)
 {
   using namespace CryptoPP;
-  
+
   OID pbes2Id;
   OID pbkdf2Id;
   SecByteBlock saltBlock;
@@ -146,12 +146,12 @@
   OID pbes2encsId;
   SecByteBlock ivBlock;
   SecByteBlock encryptedDataBlock;
-  
+
   try
     {
       //decode some decoding processes are not necessary for now, because we assume only one encryption scheme.
       StringSource source(buf, size, true);
-      
+
       // EncryptedPrivateKeyInfo ::= SEQUENCE {
       //   encryptionAlgorithm  EncryptionAlgorithmIdentifier,
       //   encryptedData        OCTET STRING }
@@ -187,7 +187,7 @@
               pbkdf2Params.MessageEnd();
             }
             pbes2KDFs.MessageEnd();
-            
+
             // AlgorithmIdentifier ::= SEQUENCE {
             //   algorithm   OBJECT IDENTIFIER {{DES-EDE3-CBC-PAD}},
             //   parameters  OCTET STRING} {{iv}} }
@@ -206,48 +206,48 @@
       }
       encryptedPrivateKeyInfo.MessageEnd();
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       return false;
     }
 
-  
+
   PKCS5_PBKDF2_HMAC<SHA1> keyGenerator;
   size_t derivedLen = 24; //For DES-EDE3-CBC-PAD
   byte derived[24] = {0};
   byte purpose = 0;
-  
+
   try
     {
-      keyGenerator.DeriveKey(derived, derivedLen, 
-                             purpose, 
-                             reinterpret_cast<const byte*>(passwordStr.c_str()), passwordStr.size(), 
-                             saltBlock.BytePtr(), saltBlock.size(), 
+      keyGenerator.DeriveKey(derived, derivedLen,
+                             purpose,
+                             reinterpret_cast<const byte*>(passwordStr.c_str()), passwordStr.size(),
+                             saltBlock.BytePtr(), saltBlock.size(),
                              iterationCount);
     }
-  catch(CryptoPP::Exception& e)
-    {
-      return false;
-    }
-        
-  //decrypt
-  CBC_Mode< DES_EDE3 >::Decryption d;
-  d.SetKeyWithIV(derived, derivedLen, ivBlock.BytePtr());
-  
-  OBufferStream privateKeyOs;
-  try
-    {
-      StringSource encryptedSource(encryptedDataBlock.BytePtr(), encryptedDataBlock.size(), true, 
-                                   new StreamTransformationFilter(d,  new FileSink(privateKeyOs)));
-    }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       return false;
     }
 
-  if(!importPrivateKeyPkcs1IntoTpm(keyName, privateKeyOs.buf()->buf(), privateKeyOs.buf()->size()))
+  //decrypt
+  CBC_Mode< DES_EDE3 >::Decryption d;
+  d.SetKeyWithIV(derived, derivedLen, ivBlock.BytePtr());
+
+  OBufferStream privateKeyOs;
+  try
+    {
+      StringSource encryptedSource(encryptedDataBlock.BytePtr(), encryptedDataBlock.size(), true,
+                                   new StreamTransformationFilter(d,  new FileSink(privateKeyOs)));
+    }
+  catch (CryptoPP::Exception& e)
+    {
+      return false;
+    }
+
+  if (!importPrivateKeyPkcs1IntoTpm(keyName, privateKeyOs.buf()->buf(), privateKeyOs.buf()->size()))
     return false;
-    
+
   //derive public key
   OBufferStream publicKeyOs;
 
@@ -256,19 +256,19 @@
       RSA::PrivateKey privateKey;
       privateKey.Load(StringStore(privateKeyOs.buf()->buf(), privateKeyOs.buf()->size()).Ref());
       RSAFunction publicKey(privateKey);
-  
+
       FileSink publicKeySink(publicKeyOs);
       publicKey.DEREncode(publicKeySink);
       publicKeySink.MessageEnd();
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       return false;
     }
 
-  if(!importPublicKeyPkcs1IntoTpm(keyName, publicKeyOs.buf()->buf(), publicKeyOs.buf()->size()))
+  if (!importPublicKeyPkcs1IntoTpm(keyName, publicKeyOs.buf()->buf(), publicKeyOs.buf()->size()))
     return false;
-  
+
   return true;
 }
 
diff --git a/src/security/sec-tpm.hpp b/src/security/sec-tpm.hpp
index 97547a4..bb7e44b 100644
--- a/src/security/sec-tpm.hpp
+++ b/src/security/sec-tpm.hpp
@@ -24,14 +24,22 @@
  */
 class SecTpm {
 public:
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
-  virtual 
+  virtual
   ~SecTpm() {}
 
   /**
    * @brief set password of TPM
-   * 
+   *
    * Password is used to unlock TPM when it is locked.
    * You should be cautious when using this method, because remembering password is kind of dangerous.
    *
@@ -49,7 +57,7 @@
 
   /**
    * @brief set inTerminal flag
-   * 
+   *
    * If the inTerminal flag is set, and password is not set, TPM may ask for password via terminal.
    * inTerminal flag is set by default.
    *
@@ -60,7 +68,7 @@
 
   /**
    * @brief get inTerminal flag
-   * 
+   *
    * @return inTerminal flag.
    */
   virtual bool
@@ -68,7 +76,7 @@
 
   /**
    * @brief check if TPM is locked.
-   * 
+   *
    * @return true if locked, false otherwise
    */
   virtual bool
@@ -93,16 +101,16 @@
    * @param keySize The size of the key pair.
    * @throws SecTpm::Error if fails.
    */
-  virtual void 
+  virtual void
   generateKeyPairInTpm(const Name& keyName, KeyType keyType, int keySize) = 0;
-  
+
   /**
    * @brief Delete a key pair of asymmetric keys.
    *
    * @param keyName The name of the key pair.
    */
   virtual void
-  deleteKeyPairInTpm(const Name &keyName) = 0;
+  deleteKeyPairInTpm(const Name& keyName) = 0;
 
   /**
    * @brief Get a public key.
@@ -111,9 +119,9 @@
    * @return The public key.
    * @throws SecTpm::Error if public key does not exist in TPM.
    */
-  virtual shared_ptr<PublicKey> 
+  virtual shared_ptr<PublicKey>
   getPublicKeyFromTpm(const Name& keyName) = 0;
-  
+
   /**
    * @brief Sign data.
    *
@@ -123,10 +131,10 @@
    * @param digestAlgorithm the digest algorithm.
    * @return The signature block.
    * @throws SecTpm::Error if signing fails.
-   */  
+   */
   virtual Block
-  signInTpm(const uint8_t *data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm) = 0;
-  
+  signInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm) = 0;
+
   /**
    * @brief Decrypt data.
    *
@@ -137,7 +145,7 @@
    * @return The decrypted data.
    * @throws SecTpm::Error if decryption fails.
    */
-  virtual ConstBufferPtr 
+  virtual ConstBufferPtr
   decryptInTpm(const uint8_t* data, size_t dataLength, const Name& keyName, bool isSymmetric) = 0;
 
   /**
@@ -161,7 +169,7 @@
    * @param keySize The size of the key.
    * @throws SecTpm::Error if key generating fails.
    */
-  virtual void 
+  virtual void
   generateSymmetricKeyInTpm(const Name& keyName, KeyType keyType, int keySize) = 0;
 
   /**
@@ -172,11 +180,11 @@
    * @return True if the key exists, otherwise false.
    */
   virtual bool
-  doesKeyExistInTpm(const Name& keyName, KeyClass keyClass) = 0;  
+  doesKeyExistInTpm(const Name& keyName, KeyClass keyClass) = 0;
 
   /**
    * @brief Generate a random block.
-   * 
+   *
    * @param res The pointer to the generated block.
    * @param size The random block size.
    * @return true for success, otherwise false.
@@ -192,12 +200,12 @@
    * @param appPath the absolute path to the application
    * @param acl the new acl of the key
    */
-  virtual void 
+  virtual void
   addAppToACL(const Name& keyName, KeyClass keyClass, const std::string& appPath, AclType acl) = 0;
 
   /**
    * @brief Export a private key in PKCS#8 format.
-   * 
+   *
    * @param keyName The private key name.
    * @param password The password to encrypt the private key.
    * @return The private key info (in PKCS8 format) if exist.
@@ -208,9 +216,9 @@
 
   /**
    * @brief Import a private key in PKCS#8 format.
-   * 
+   *
    * Also recover the public key and installed it in TPM.
-   * 
+   *
    * @param keyName The private key name.
    * @param key The encoded private key info.
    * @param password The password to encrypt the private key.
@@ -222,7 +230,7 @@
 protected:
   /**
    * @brief Export a private key in PKCS#1 format.
-   * 
+   *
    * @param keyName The private key name.
    * @return The private key info (in PKCS#1 format) if exist, otherwise a NULL pointer.
    */
@@ -231,7 +239,7 @@
 
   /**
    * @brief Import a private key in PKCS#1 format.
-   * 
+   *
    * @param keyName The private key name.
    * @param key The encoded private key info.
    * @return False if import fails.
@@ -241,7 +249,7 @@
 
   /**
    * @brief Import a public key in PKCS#1 format.
-   * 
+   *
    * @param keyName The public key name.
    * @param key The encoded public key info.
    * @return False if import fails.
@@ -267,22 +275,22 @@
   int result = false;
 
   char* pw0 = NULL;
-  
+
   pw0 = getpass(prompt.c_str());
-  if(!pw0) 
+  if (!pw0)
     return false;
   std::string password1 = pw0;
   memset(pw0, 0, strlen(pw0));
 
   pw0 = getpass("Confirm:");
-  if(!pw0)
+  if (!pw0)
     {
       char* pw1 = const_cast<char*>(password1.c_str());
       memset(pw1, 0, password1.size());
       return false;
     }
 
-  if(!password1.compare(pw0))
+  if (!password1.compare(pw0))
     {
       result = true;
       password.swap(password1);
@@ -292,7 +300,7 @@
   memset(pw1, 0, password1.size());
   memset(pw0, 0, strlen(pw0));
 
-  if(password.empty())
+  if (password.empty())
     return false;
 
   return result;
diff --git a/src/security/secured-bag.hpp b/src/security/secured-bag.hpp
index 3a8cd29..5848981 100644
--- a/src/security/secured-bag.hpp
+++ b/src/security/secured-bag.hpp
@@ -16,9 +16,17 @@
 class SecuredBag
 {
 public:
-  struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
-  SecuredBag() 
+  SecuredBag()
     : m_wire(tlv::security::IdentityPackage)
   {}
 
@@ -34,12 +42,12 @@
     m_wire.push_back(wireKey);
   }
 
-  virtual 
+  virtual
   ~SecuredBag()
   {}
-  
+
   void
-  wireDecode(const Block &wire)
+  wireDecode(const Block& wire)
   {
     m_wire = wire;
     m_wire.parse();
@@ -63,13 +71,13 @@
   {
     return m_cert;
   }
-  
+
   ConstBufferPtr
   getKey() const
   {
     return m_key;
   }
-  
+
 private:
   IdentityCertificate m_cert;
   ConstBufferPtr m_key;
diff --git a/src/security/signature-sha256.hpp b/src/security/signature-sha256.hpp
index 11b7cdf..8ef37a8 100644
--- a/src/security/signature-sha256.hpp
+++ b/src/security/signature-sha256.hpp
@@ -25,7 +25,7 @@
     m_info.push_back(nonNegativeIntegerBlock(Tlv::SignatureType, Tlv::DigestSha256));
   }
 
-  SignatureSha256(const Signature &signature)
+  SignatureSha256(const Signature& signature)
     : Signature(signature)
   {
     if (getType() != Signature::Sha256)
diff --git a/src/security/validation-request.hpp b/src/security/validation-request.hpp
index f64082b..0bc0d59 100644
--- a/src/security/validation-request.hpp
+++ b/src/security/validation-request.hpp
@@ -16,7 +16,7 @@
  * An OnVerified function object is used to pass a callback to report a successful Interest validation.
  */
 typedef function< void (const shared_ptr<const Interest>&) > OnInterestValidated;
-  
+
 /**
  * An OnVerifyFailed function object is used to pass a callback to report a failed Interest validation.
  */
@@ -26,7 +26,7 @@
  * An OnVerified function object is used to pass a callback to report a successful Data validation.
  */
 typedef function< void (const shared_ptr<const Data>&) > OnDataValidated;
-  
+
 /**
  * An OnVerifyFailed function object is used to pass a callback to report a failed Data validation.
  */
@@ -35,9 +35,9 @@
 
 class ValidationRequest {
 public:
-  ValidationRequest(const Interest &interest, 
-                    const OnDataValidated &onValidated, 
-                    const OnDataValidationFailed &onDataValidated, 
+  ValidationRequest(const Interest& interest,
+                    const OnDataValidated& onValidated,
+                    const OnDataValidationFailed& onDataValidated,
                     int retry, int stepCount)
   : m_interest(interest)
   , m_onValidated(onValidated)
@@ -45,7 +45,7 @@
   , m_retry(retry)
   , m_stepCount(stepCount)
   {}
-    
+
   virtual
   ~ValidationRequest() {}
 
diff --git a/src/security/validator-null.hpp b/src/security/validator-null.hpp
index eb186c6..4d7b56b 100644
--- a/src/security/validator-null.hpp
+++ b/src/security/validator-null.hpp
@@ -18,22 +18,22 @@
   virtual
   ~ValidatorNull()
   {}
-  
+
 protected:
   virtual void
-  checkPolicy (const Data& data, 
-               int stepCount, 
-               const OnDataValidated &onValidated, 
-               const OnDataValidationFailed &onValidationFailed,
-               std::vector<shared_ptr<ValidationRequest> > &nextSteps)
+  checkPolicy (const Data& data,
+               int stepCount,
+               const OnDataValidated& onValidated,
+               const OnDataValidationFailed& onValidationFailed,
+               std::vector<shared_ptr<ValidationRequest> >& nextSteps)
   { onValidated(data.shared_from_this()); }
-  
+
   virtual void
-  checkPolicy (const Interest& interest, 
-               int stepCount, 
-               const OnInterestValidated &onValidated, 
-               const OnInterestValidationFailed &onValidationFailed,
-               std::vector<shared_ptr<ValidationRequest> > &nextSteps)
+  checkPolicy (const Interest& interest,
+               int stepCount,
+               const OnInterestValidated& onValidated,
+               const OnInterestValidationFailed& onValidationFailed,
+               std::vector<shared_ptr<ValidationRequest> >& nextSteps)
   { onValidated(interest.shared_from_this()); }
 };
 
diff --git a/src/selectors.hpp b/src/selectors.hpp
index dd37e56..361ad6a 100644
--- a/src/selectors.hpp
+++ b/src/selectors.hpp
@@ -42,6 +42,9 @@
   {
   }
 
+  /**
+   * @brief Create from wire encoding
+   */
   Selectors(const Block& wire)
   {
     wireDecode(wire);
@@ -207,7 +210,7 @@
 inline size_t
 Selectors::wireEncode(EncodingImpl<T>& block) const
 {
-  size_t total_len = 0;
+  size_t totalLength = 0;
 
   // Selectors ::= SELECTORS-TYPE TLV-LENGTH
   //                 MinSuffixComponents?
@@ -222,44 +225,44 @@
   // MustBeFresh
   if (getMustBeFresh())
     {
-      total_len += prependBooleanBlock(block, Tlv::MustBeFresh);
+      totalLength += prependBooleanBlock(block, Tlv::MustBeFresh);
     }
 
   // ChildSelector
   if (getChildSelector() >= 0)
     {
-      total_len += prependNonNegativeIntegerBlock(block, Tlv::ChildSelector, getChildSelector());
+      totalLength += prependNonNegativeIntegerBlock(block, Tlv::ChildSelector, getChildSelector());
     }
 
   // Exclude
   if (!getExclude().empty())
     {
-      total_len += getExclude().wireEncode(block);
+      totalLength += getExclude().wireEncode(block);
     }
 
   // PublisherPublicKeyLocator
   if (!getPublisherPublicKeyLocator().empty())
     {
-      total_len += getPublisherPublicKeyLocator().wireEncode(block);
+      totalLength += getPublisherPublicKeyLocator().wireEncode(block);
     }
 
   // MaxSuffixComponents
   if (getMaxSuffixComponents() >= 0)
     {
-      total_len += prependNonNegativeIntegerBlock(block, Tlv::MaxSuffixComponents,
-                                                  getMaxSuffixComponents());
+      totalLength += prependNonNegativeIntegerBlock(block, Tlv::MaxSuffixComponents,
+                                                    getMaxSuffixComponents());
     }
 
   // MinSuffixComponents
   if (getMinSuffixComponents() >= 0)
     {
-      total_len += prependNonNegativeIntegerBlock(block, Tlv::MinSuffixComponents,
-                                                  getMinSuffixComponents());
+      totalLength += prependNonNegativeIntegerBlock(block, Tlv::MinSuffixComponents,
+                                                    getMinSuffixComponents());
     }
 
-  total_len += block.prependVarNumber(total_len);
-  total_len += block.prependVarNumber(Tlv::Selectors);
-  return total_len;
+  totalLength += block.prependVarNumber(totalLength);
+  totalLength += block.prependVarNumber(Tlv::Selectors);
+  return totalLength;
 }
 
 inline const Block&
diff --git a/src/transport/transport.hpp b/src/transport/transport.hpp
index e678491..08740fb 100644
--- a/src/transport/transport.hpp
+++ b/src/transport/transport.hpp
@@ -17,16 +17,16 @@
   class Error : public std::runtime_error
   {
   public:
-    inline Error(const boost::system::error_code &code, const std::string &msg);
+    inline Error(const boost::system::error_code& code, const std::string& msg);
     inline Error(const std::string& msg);
   };
-  
-  typedef ptr_lib::function<void (const Block &wire)> ReceiveCallback;
+
+  typedef ptr_lib::function<void (const Block& wire)> ReceiveCallback;
   typedef ptr_lib::function<void ()> ErrorCallback;
-  
+
   inline
   Transport();
-  
+
   inline virtual
   ~Transport();
 
@@ -35,14 +35,14 @@
    *
    * @throws If connection cannot be established
    */
-  inline virtual void 
+  inline virtual void
   connect(boost::asio::io_service& io_service,
           const ReceiveCallback& receiveCallback);
-  
+
   /**
    * Close the connection.
    */
-  virtual void 
+  virtual void
   close() = 0;
 
   /**
@@ -51,7 +51,7 @@
    * @param data A pointer to the buffer of data to send.
    * @param dataLength The number of bytes in data.
    */
-  virtual void 
+  virtual void
   send(const Block& wire) = 0;
 
   /**
@@ -60,7 +60,7 @@
    * Two non-consecutive memory blocks will be send out together, e.g., as part of the
    * same message in datagram-oriented transports.
    */
-  virtual void 
+  virtual void
   send(const Block& header, const Block& payload) = 0;
 
   virtual void
@@ -68,8 +68,8 @@
 
   virtual void
   resume() = 0;
-  
-  inline bool 
+
+  inline bool
   isConnected();
 
   inline bool
@@ -78,7 +78,7 @@
 protected:
   inline void
   receive(const Block& wire);
-  
+
 protected:
   boost::asio::io_service* m_ioService;
   bool m_isConnected;
@@ -111,7 +111,7 @@
 {
 }
 
-inline void 
+inline void
 Transport::connect(boost::asio::io_service& ioService,
                    const ReceiveCallback& receiveCallback)
 {
@@ -119,7 +119,7 @@
   m_receiveCallback = receiveCallback;
 }
 
-inline bool 
+inline bool
 Transport::isConnected()
 {
   return m_isConnected;
diff --git a/src/util/command-interest-generator.hpp b/src/util/command-interest-generator.hpp
index 18bc960..8b51cd9 100644
--- a/src/util/command-interest-generator.hpp
+++ b/src/util/command-interest-generator.hpp
@@ -62,7 +62,7 @@
     .append(name::Component::fromNumber(random::generateWord64()));
   interest.setName(commandInterestName);
 
-  if(certificateName.empty())
+  if (certificateName.empty())
     m_keyChain.sign(interest);
   else
     m_keyChain.sign(interest, certificateName);
diff --git a/src/util/crypto.cpp b/src/util/crypto.cpp
index 1621005..d8e803a 100644
--- a/src/util/crypto.cpp
+++ b/src/util/crypto.cpp
@@ -10,17 +10,17 @@
 
 namespace ndn {
 
-void ndn_digestSha256(const uint8_t *data, size_t dataLength, uint8_t *digest)
+void ndn_digestSha256(const uint8_t* data, size_t dataLength, uint8_t* digest)
 {
   try
     {
       using namespace CryptoPP;
-      
+
       CryptoPP::SHA256 hash;
       OBufferStream os;
       StringSource(data, dataLength, true, new HashFilter(hash, new ArraySink(digest, crypto::SHA256_DIGEST_SIZE)));
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       return;
     }
@@ -30,18 +30,18 @@
 namespace crypto {
 
 ConstBufferPtr
-sha256(const uint8_t *data, size_t dataLength)
+sha256(const uint8_t* data, size_t dataLength)
 {
   try
     {
       using namespace CryptoPP;
-      
+
       SHA256 hash;
       OBufferStream os;
       StringSource(data, dataLength, true, new HashFilter(hash, new FileSink(os)));
       return os.buf();
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       return ConstBufferPtr();
     }
diff --git a/src/util/crypto.hpp b/src/util/crypto.hpp
index 58555a2..82e769f 100644
--- a/src/util/crypto.hpp
+++ b/src/util/crypto.hpp
@@ -18,7 +18,7 @@
  * @param dataLength The length of data.
  * @param digest A pointer to a buffer of size crypto::SHA256_DIGEST_SIZE to receive the data.
  */
-void ndn_digestSha256(const uint8_t *data, size_t dataLength, uint8_t *digest);
+void ndn_digestSha256(const uint8_t* data, size_t dataLength, uint8_t* digest);
 
 namespace crypto {
 
@@ -33,7 +33,7 @@
  * @return A pointer to a buffer of SHA256_DIGEST.
  */
 ConstBufferPtr
-sha256(const uint8_t *data, size_t dataLength);
+sha256(const uint8_t* data, size_t dataLength);
 
 } // namespace crypto
 
diff --git a/src/util/io.hpp b/src/util/io.hpp
index 6026f06..ff6852b 100644
--- a/src/util/io.hpp
+++ b/src/util/io.hpp
@@ -19,7 +19,15 @@
 namespace ndn {
 namespace io {
 
-struct Error : public std::runtime_error { Error(const std::string &what) : std::runtime_error(what) {} };
+class Error : public std::runtime_error
+{
+public:
+  explicit
+  Error(const std::string& what)
+    : std::runtime_error(what)
+  {
+  }
+};
 
 enum IoEncoding {
   NO_ENCODING,
@@ -27,8 +35,8 @@
   HEX
 };
 
-template<typename T> 
-shared_ptr<T> 
+template<typename T>
+shared_ptr<T>
 load(std::istream& is, IoEncoding encoding = BASE_64)
 {
   typedef typename T::Error TypeError;
@@ -39,54 +47,54 @@
       shared_ptr<T> object = make_shared<T>();
 
       OBufferStream os;
-      
-      switch(encoding)
-	{
-	case NO_ENCODING:
-	  {
-	    FileSource ss(is, true, new FileSink(os));
-	    break;
-	  }
-	case BASE_64:
-	  {
-	    FileSource ss(is, true, new Base64Decoder(new FileSink(os)));
-	    break;
-	  }
-	case HEX:
-	  {
-	    FileSource ss(is, true, new HexDecoder(new FileSink(os)));
-	    break;
-	  }
-	default:
-	  return shared_ptr<T>(); 
-	}
+
+      switch (encoding)
+        {
+        case NO_ENCODING:
+          {
+            FileSource ss(is, true, new FileSink(os));
+            break;
+          }
+        case BASE_64:
+          {
+            FileSource ss(is, true, new Base64Decoder(new FileSink(os)));
+            break;
+          }
+        case HEX:
+          {
+            FileSource ss(is, true, new HexDecoder(new FileSink(os)));
+            break;
+          }
+        default:
+          return shared_ptr<T>();
+        }
 
       object->wireDecode(Block(os.buf()));
       return object;
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       return shared_ptr<T>();
     }
-  catch(Block::Error& e)
+  catch (Block::Error& e)
     {
       return shared_ptr<T>();
     }
-  catch(TypeError& e)
+  catch (TypeError& e)
     {
       return shared_ptr<T>();
     }
 }
 
-template<typename T> 
-shared_ptr<T> 
+template<typename T>
+shared_ptr<T>
 load(const std::string& file, IoEncoding encoding = BASE_64)
 {
   std::ifstream is(file.c_str());
   return load<T>(is, encoding);
 }
 
-template<typename T> 
+template<typename T>
 void
 save(const T& object, std::ostream& os, IoEncoding encoding = BASE_64)
 {
@@ -96,38 +104,41 @@
       using namespace CryptoPP;
 
       Block block = object.wireEncode();
-      
-      switch(encoding)
-	{
-	case NO_ENCODING:
-	  {
-	    StringSource ss(block.wire(), block.size(), true, new FileSink(os));
-	    break;
-	  }
-	case BASE_64:
-	  {
-	    StringSource ss(block.wire(), block.size(), true, new Base64Encoder(new FileSink(os), true, 64));
-	    break;
-	  }
-	case HEX:
-	  {
-	    StringSource ss(block.wire(), block.size(), true, new HexEncoder(new FileSink(os)));
-	    break;
-	  }
-	default:
-	  return; 
-	}
+
+      switch (encoding)
+        {
+        case NO_ENCODING:
+          {
+            StringSource ss(block.wire(), block.size(), true,
+                            new FileSink(os));
+            break;
+          }
+        case BASE_64:
+          {
+            StringSource ss(block.wire(), block.size(), true,
+                            new Base64Encoder(new FileSink(os), true, 64));
+            break;
+          }
+        case HEX:
+          {
+            StringSource ss(block.wire(), block.size(), true,
+                            new HexEncoder(new FileSink(os)));
+            break;
+          }
+        default:
+          return;
+        }
       return;
     }
-  catch(CryptoPP::Exception& e)
+  catch (CryptoPP::Exception& e)
     {
       throw Error(e.what());
     }
-  catch(Block::Error& e)
+  catch (Block::Error& e)
     {
       throw Error(e.what());
     }
-  catch(TypeError& e)
+  catch (TypeError& e)
     {
       throw Error(e.what());
     }
@@ -145,4 +156,3 @@
 } // namespace ndn
 
 #endif // NDN_UTIL_IO_HPP
-
diff --git a/src/util/regex/regex-backref-matcher.hpp b/src/util/regex/regex-backref-matcher.hpp
index e2eabe8..aa00605 100644
--- a/src/util/regex/regex-backref-matcher.hpp
+++ b/src/util/regex/regex-backref-matcher.hpp
@@ -18,17 +18,17 @@
 {
 public:
   RegexBackrefMatcher(const std::string& expr, shared_ptr<RegexBackrefManager> backRefManager);
-    
+
   virtual ~RegexBackrefMatcher(){}
 
-  void 
+  void
   lateCompile()
   {
     compile();
   }
 
 protected:
-  virtual void 
+  virtual void
   compile();
 };
 
@@ -44,11 +44,11 @@
   // compile();
 }
 
-inline void 
+inline void
 RegexBackrefMatcher::compile()
 {
   int lastIndex = m_expr.size() - 1;
-  if('(' == m_expr[0] && ')' == m_expr[lastIndex]){
+  if ('(' == m_expr[0] && ')' == m_expr[lastIndex]){
     // m_backRefManager->pushRef(this);
 
     shared_ptr<RegexMatcher> matcher(new RegexPatternListMatcher(m_expr.substr(1, lastIndex - 1), m_backrefManager));
@@ -63,5 +63,3 @@
 } // namespace ndn
 
 #endif // NDN_UTIL_REGEX_REGEX_BACKREF_MATCHER_HPP
-
-
diff --git a/src/util/regex/regex-component-matcher.hpp b/src/util/regex/regex-component-matcher.hpp
index 50cb8de..34bcba7 100644
--- a/src/util/regex/regex-component-matcher.hpp
+++ b/src/util/regex/regex-component-matcher.hpp
@@ -25,13 +25,13 @@
    * @param backRefManager The back reference manager
    * @param exact The flag to provide exact match
    */
-  RegexComponentMatcher(const std::string& expr, 
-                        ptr_lib::shared_ptr<RegexBackrefManager> backRefManager, 
+  RegexComponentMatcher(const std::string& expr,
+                        ptr_lib::shared_ptr<RegexBackrefManager> backRefManager,
                         bool exact = true);
-    
+
   virtual ~RegexComponentMatcher() {};
 
-  virtual bool 
+  virtual bool
   match(const Name & name, const int & offset, const int &len = 1);
 
 protected:
@@ -39,20 +39,20 @@
    * @brief Compile the regular expression to generate the more matchers when necessary
    * @returns true if compiling succeeds
    */
-  virtual void 
+  virtual void
   compile();
-    
+
 private:
   bool m_exact;
   boost::regex m_componentRegex;
   std::vector<ptr_lib::shared_ptr<RegexPseudoMatcher> > m_pseudoMatcher;
-    
+
 };
 
 
 inline
-RegexComponentMatcher::RegexComponentMatcher (const std::string& expr, 
-                                              ptr_lib::shared_ptr<RegexBackrefManager> backRefManager, 
+RegexComponentMatcher::RegexComponentMatcher (const std::string& expr,
+                                              ptr_lib::shared_ptr<RegexBackrefManager> backRefManager,
                                               bool exact)
   : RegexMatcher (expr, EXPR_COMPONENT, backRefManager),
     m_exact(exact)
@@ -62,7 +62,7 @@
   // _LOG_TRACE ("Exit RegexComponentMatcher Constructor: ");
 }
 
-inline void 
+inline void
 RegexComponentMatcher::compile ()
 {
   // _LOG_TRACE ("Enter RegexComponentMatcher::compile");
@@ -78,7 +78,7 @@
       m_pseudoMatcher.push_back(pMatcher);
       m_backrefManager->pushRef(ptr_lib::static_pointer_cast<RegexMatcher>(pMatcher));
     }
-    
+
 
   // _LOG_TRACE ("Exit RegexComponentMatcher::compile");
 }
@@ -90,17 +90,17 @@
 
   m_matchResult.clear();
 
-  if("" == m_expr)
+  if ("" == m_expr)
     {
       m_matchResult.push_back(name.get(offset));
       return true;
     }
 
-  if(true == m_exact)
+  if (true == m_exact)
     {
       boost::smatch subResult;
       std::string targetStr = name.get(offset).toEscapedString();
-      if(boost::regex_match(targetStr, subResult, m_componentRegex))
+      if (boost::regex_match(targetStr, subResult, m_componentRegex))
         {
           for (size_t i = 1; i < m_componentRegex.mark_count(); i++)
             {
diff --git a/src/util/regex/regex-component-set-matcher.hpp b/src/util/regex/regex-component-set-matcher.hpp
index 4039388..5aed58f 100644
--- a/src/util/regex/regex-component-set-matcher.hpp
+++ b/src/util/regex/regex-component-set-matcher.hpp
@@ -24,19 +24,19 @@
    * @param exact The flag to provide exact match
    * @param backRefNum The starting back reference number
    */
-  RegexComponentSetMatcher(const std::string& expr, shared_ptr<RegexBackrefManager> backRefManager);    
+  RegexComponentSetMatcher(const std::string& expr, shared_ptr<RegexBackrefManager> backRefManager);
 
   virtual ~RegexComponentSetMatcher();
 
-  virtual bool 
+  virtual bool
   match(const Name& name, const int& offset, const int& len = 1);
 
-protected:    
+protected:
   /**
    * @brief Compile the regular expression to generate the more matchers when necessary
    * @returns true if compiling succeeds
    */
-  virtual void 
+  virtual void
   compile();
 
 private:
@@ -45,7 +45,7 @@
 
   void
   compileSingleComponent();
-    
+
   void
   compileMultipleComponents(const int start, const int lastIndex);
 
@@ -57,7 +57,8 @@
 
 
 inline
-RegexComponentSetMatcher::RegexComponentSetMatcher(const std::string& expr, shared_ptr<RegexBackrefManager> backRefManager)
+RegexComponentSetMatcher::RegexComponentSetMatcher(const std::string& expr,
+                                                   shared_ptr<RegexBackrefManager> backRefManager)
   : RegexMatcher(expr, EXPR_COMPONENT_SET, backRefManager),
     m_include(true)
 {
@@ -75,20 +76,20 @@
   //   delete *it;
 }
 
-inline void 
+inline void
 RegexComponentSetMatcher::compile()
 {
-  switch(m_expr[0]){
+  switch (m_expr[0]){
   case '<':
     return compileSingleComponent();
   case '[':
     {
       int lastIndex = m_expr.size() - 1;
-      if(']' != m_expr[lastIndex])
+      if (']' != m_expr[lastIndex])
         throw RegexMatcher::Error(std::string("Error: RegexComponentSetMatcher.compile(): ")
                                   + " No matched ']' " + m_expr);
-      
-      if('^' == m_expr[1]){
+
+      if ('^' == m_expr[1]){
         m_include = false;
         compileMultipleComponents(2, lastIndex);
       }
@@ -102,52 +103,55 @@
   }
 }
 
-inline void 
+inline void
 RegexComponentSetMatcher::compileSingleComponent()
 {
   size_t end = extractComponent(1);
 
   if (m_expr.size() != end)
     {
-      throw RegexMatcher::Error(std::string("Error: RegexComponentSetMatcher.compileSingleComponent: ")
-                                + m_expr);
+      throw RegexMatcher::Error(
+        std::string("Error: RegexComponentSetMatcher.compileSingleComponent: ") + m_expr);
     }
   else
     {
       shared_ptr<RegexComponentMatcher> component =
         make_shared<RegexComponentMatcher>(m_expr.substr(1, end - 2), m_backrefManager);
-      
-      m_components.insert(component);      
+
+      m_components.insert(component);
     }
 }
 
-inline void 
+inline void
 RegexComponentSetMatcher::compileMultipleComponents(const int start, const int lastIndex)
 {
   int index = start;
   int tmp_index = start;
-    
+
   while(index < lastIndex){
-    if('<' != m_expr[index])
-      throw RegexMatcher::Error(std::string("Error: RegexComponentSetMatcher.compileMultipleComponents: ")
-                                + "Component expr error " + m_expr);
-      
+    if ('<' != m_expr[index])
+      throw RegexMatcher::Error(
+        std::string("Error: RegexComponentSetMatcher.compileMultipleComponents: ") +
+        "Component expr error " + m_expr);
+
     tmp_index = index + 1;
     index = extractComponent(tmp_index);
 
     shared_ptr<RegexComponentMatcher> component =
-      make_shared<RegexComponentMatcher>(m_expr.substr(tmp_index, index - tmp_index - 1), m_backrefManager);
-    
+      make_shared<RegexComponentMatcher>(m_expr.substr(tmp_index, index - tmp_index - 1),
+                                         m_backrefManager);
+
     m_components.insert(component);
   }
-    
-  if(index != lastIndex)
-    throw RegexMatcher::Error(std::string("Error: RegexComponentSetMatcher.compileMultipleComponents: ")
-                              + "Not sufficient expr to parse " + m_expr);        
+
+  if (index != lastIndex)
+    throw RegexMatcher::Error(
+      std::string("Error: RegexComponentSetMatcher.compileMultipleComponents: ") +
+      "Not sufficient expr to parse " + m_expr);
 }
 
-inline bool 
-RegexComponentSetMatcher::match(const Name & name, const int & offset, const int & len)
+inline bool
+RegexComponentSetMatcher::match(const Name& name, const int& offset, const int& len)
 {
   bool matched = false;
 
@@ -161,13 +165,13 @@
        it != m_components.end();
        ++it)
     {
-      if((*it)->match(name, offset, len))
+      if ((*it)->match(name, offset, len))
         {
           matched = true;
           break;
         }
     }
-    
+
   m_matchResult.clear();
 
   if (m_include ? matched : !matched)
@@ -175,18 +179,18 @@
       m_matchResult.push_back(name.get(offset));
       return true;
     }
-  else 
+  else
     return false;
 }
 
-inline int 
+inline int
 RegexComponentSetMatcher::extractComponent(int index)
 {
   int lcount = 1;
   int rcount = 0;
 
   while(lcount > rcount){
-    switch(m_expr[index]){
+    switch (m_expr[index]){
     case '<':
       lcount++;
       break;
diff --git a/src/util/regex/regex-matcher.hpp b/src/util/regex/regex-matcher.hpp
index 0d34311..d62ab41 100644
--- a/src/util/regex/regex-matcher.hpp
+++ b/src/util/regex/regex-matcher.hpp
@@ -18,7 +18,15 @@
 class RegexMatcher
 {
 public:
-  struct Error : public std::runtime_error { Error(const std::string& what) : std::runtime_error(what) {} };
+  class Error : public std::runtime_error
+  {
+  public:
+    explicit
+    Error(const std::string& what)
+      : std::runtime_error(what)
+    {
+    }
+  };
 
   enum RegexExprType{
     EXPR_TOP,
@@ -26,52 +34,52 @@
     EXPR_PATTERNLIST,
 
     EXPR_REPEAT_PATTERN,
-      
+
     EXPR_BACKREF,
     EXPR_COMPONENT_SET,
     EXPR_COMPONENT,
 
     EXPR_PSEUDO
-  };    
+  };
 
-  RegexMatcher(const std::string& expr, 
-               const RegexExprType& type,  
+  RegexMatcher(const std::string& expr,
+               const RegexExprType& type,
                shared_ptr<RegexBackrefManager> backrefManager = shared_ptr<RegexBackrefManager>());
 
-  virtual 
+  virtual
   ~RegexMatcher();
 
-  virtual bool 
+  virtual bool
   match(const Name& name, const int& offset, const int& len);
 
   /**
    * @brief get the matched name components
    * @returns the matched name components
    */
-  const std::vector<name::Component>& 
+  const std::vector<name::Component>&
   getMatchResult() const
   { return m_matchResult; }
 
   const std::string&
   getExpr() const
-  { return m_expr; } 
+  { return m_expr; }
 
 protected:
   /**
    * @brief Compile the regular expression to generate the more matchers when necessary
    * @returns true if compiling succeeds
    */
-  virtual void 
+  virtual void
   compile() = 0;
 
 private:
-  bool 
+  bool
   recursiveMatch(size_t mId, const Name& name, size_t offset, size_t len);
 
 
 protected:
   const std::string m_expr;
-  const RegexExprType m_type; 
+  const RegexExprType m_type;
   shared_ptr<RegexBackrefManager> m_backrefManager;
   std::vector<shared_ptr<RegexMatcher> > m_matcherList;
   std::vector<name::Component> m_matchResult;
@@ -84,14 +92,14 @@
 namespace ndn {
 
 inline
-RegexMatcher::RegexMatcher(const std::string& expr, 
-                           const RegexExprType& type,  
-                           shared_ptr<RegexBackrefManager> backrefManager) 
-  : m_expr(expr), 
+RegexMatcher::RegexMatcher(const std::string& expr,
+                           const RegexExprType& type,
+                           shared_ptr<RegexBackrefManager> backrefManager)
+  : m_expr(expr),
     m_type(type),
     m_backrefManager(backrefManager)
 {
-  if(NULL == m_backrefManager)
+  if (NULL == m_backrefManager)
     m_backrefManager = make_shared<RegexBackrefManager>();
 }
 
@@ -100,7 +108,7 @@
 {
 }
 
-inline bool 
+inline bool
 RegexMatcher::match (const Name& name, const int& offset, const int& len)
 {
   // _LOG_TRACE ("Enter RegexMatcher::match");
@@ -108,7 +116,7 @@
 
   m_matchResult.clear();
 
-  if(recursiveMatch(0, name, offset, len))
+  if (recursiveMatch(0, name, offset, len))
     {
       for(int i = offset; i < offset + len ; i++)
         m_matchResult.push_back(name.get(i));
@@ -122,23 +130,23 @@
   // _LOG_TRACE ("Exit RegexMatcher::match");
   return result;
 }
-  
-inline bool 
+
+inline bool
 RegexMatcher::recursiveMatch(size_t mId, const Name& name, size_t offset, size_t len)
 {
   // _LOG_TRACE ("Enter RegexMatcher::recursiveMatch");
 
   int tried = len;
 
-  if(mId >= m_matcherList.size())
+  if (mId >= m_matcherList.size())
     return (len != 0 ? false : true);
-    
+
   shared_ptr<RegexMatcher> matcher = m_matcherList[mId];
 
   while(tried >= 0)
     {
-      if(matcher->match(name, offset, tried) && recursiveMatch(mId + 1, name, offset + tried, len - tried))
-        return true;      
+      if (matcher->match(name, offset, tried) && recursiveMatch(mId + 1, name, offset + tried, len - tried))
+        return true;
       tried--;
     }
 
diff --git a/src/util/regex/regex-pattern-list-matcher.hpp b/src/util/regex/regex-pattern-list-matcher.hpp
index 3ae74f1..12e3c68 100644
--- a/src/util/regex/regex-pattern-list-matcher.hpp
+++ b/src/util/regex/regex-pattern-list-matcher.hpp
@@ -20,21 +20,21 @@
 {
 public:
   RegexPatternListMatcher(const std::string& expr, shared_ptr<RegexBackrefManager> backRefManager);
-    
+
   virtual ~RegexPatternListMatcher(){};
 
-protected:    
-  virtual void 
+protected:
+  virtual void
   compile();
 
 private:
-  bool 
+  bool
   extractPattern(int index, int* next);
-    
-  int 
+
+  int
   extractSubPattern(const char left, const char right, size_t index);
-    
-  int 
+
+  int
   extractRepetition(size_t index);
 
 private:
@@ -53,38 +53,38 @@
 {
   compile();
 }
-  
-inline void 
+
+inline void
 RegexPatternListMatcher::compile()
 {
   const int len = m_expr.size();
   int index = 0;
   int subHead = index;
-    
+
   while(index < len){
     subHead = index;
 
-    if(!extractPattern(subHead, &index))
+    if (!extractPattern(subHead, &index))
       throw RegexMatcher::Error("RegexPatternListMatcher compile: cannot compile");
   }
 }
 
-inline bool 
+inline bool
 RegexPatternListMatcher::extractPattern(int index, int* next)
 {
   // std::string errMsg = "Error: RegexPatternListMatcher.ExtractSubPattern(): ";
-    
+
   const int start = index;
   int end = index;
   int indicator = index;
 
-  switch(m_expr[index]){
+  switch (m_expr[index]){
   case '(':
     index++;
     index = extractSubPattern('(', ')', index);
     indicator = index;
     end = extractRepetition(index);
-    if(indicator == end){
+    if (indicator == end){
       shared_ptr<RegexMatcher> matcher = make_shared<RegexBackrefMatcher>(m_expr.substr(start, end - start), m_backrefManager);
       m_backrefManager->pushRef(matcher);
       boost::dynamic_pointer_cast<RegexBackrefMatcher>(matcher)->lateCompile();
@@ -94,7 +94,7 @@
     else
       m_matcherList.push_back(make_shared<RegexRepeatMatcher>(m_expr.substr(start, end - start), m_backrefManager, indicator - start));
     break;
-      
+
   case '<':
     index++;
     index = extractSubPattern ('<', '>', index);
@@ -119,8 +119,8 @@
 
   return true;
 }
-  
-inline int 
+
+inline int
 RegexPatternListMatcher::extractSubPattern(const char left, const char right, size_t index)
 {
   size_t lcount = 1;
@@ -128,13 +128,13 @@
 
   while(lcount > rcount){
 
-    if(index >= m_expr.size())
+    if (index >= m_expr.size())
       throw RegexMatcher::Error("Error: parenthesis mismatch");
 
-    if(left == m_expr[index])
+    if (left == m_expr[index])
       lcount++;
 
-    if(right == m_expr[index])
+    if (right == m_expr[index])
       rcount++;
 
     index++;
@@ -142,25 +142,25 @@
   return index;
 }
 
-inline int 
+inline int
 RegexPatternListMatcher::extractRepetition(size_t index)
 {
   size_t exprSize = m_expr.size();
 
-  if(index == exprSize)
+  if (index == exprSize)
     return index;
-    
-  if(('+' == m_expr[index] || '?' == m_expr[index] || '*' == m_expr[index])){
+
+  if (('+' == m_expr[index] || '?' == m_expr[index] || '*' == m_expr[index])){
     return ++index;
   }
-    
-  if('{' == m_expr[index]){
+
+  if ('{' == m_expr[index]){
     while('}' != m_expr[index]){
       index++;
-      if(index == exprSize)
+      if (index == exprSize)
         break;
     }
-    if(index == exprSize)
+    if (index == exprSize)
       throw RegexMatcher::Error(std::string("Error: RegexPatternListMatcher.ExtractRepetition(): ")
                                 + "Missing right brace bracket");
     else
diff --git a/src/util/regex/regex-repeat-matcher.hpp b/src/util/regex/regex-repeat-matcher.hpp
index fb42042..5eefbd1 100644
--- a/src/util/regex/regex-repeat-matcher.hpp
+++ b/src/util/regex/regex-repeat-matcher.hpp
@@ -20,10 +20,10 @@
 {
 public:
   RegexRepeatMatcher(const std::string& expr, shared_ptr<RegexBackrefManager> backRefManager, int indicator);
-    
+
   virtual ~RegexRepeatMatcher(){}
 
-  virtual bool 
+  virtual bool
   match(const Name& name, const int& offset, const int& len);
 
 protected:
@@ -31,19 +31,19 @@
    * @brief Compile the regular expression to generate the more matchers when necessary
    * @returns true if compiling succeeds
    */
-  virtual void 
+  virtual void
   compile();
 
 private:
-  bool 
+  bool
   parseRepetition();
 
-  bool 
+  bool
   recursiveMatch (int repeat,
-                  const Name & name,
-                  const int & offset,
-                  const int &len);
-  
+                  const Name& name,
+                  const int& offset,
+                  const int&len);
+
 private:
   int m_indicator;
   int m_repeatMin;
@@ -67,14 +67,14 @@
   // _LOG_TRACE ("Exit RegexRepeatMatcher Constructor");
 }
 
-inline void 
+inline void
 RegexRepeatMatcher::compile()
 {
   // _LOG_TRACE ("Enter RegexRepeatMatcher::compile");
-    
+
   shared_ptr<RegexMatcher> matcher;
 
-  if('(' == m_expr[0]){
+  if ('(' == m_expr[0]){
     matcher = make_shared<RegexBackrefMatcher>(m_expr.substr(0, m_indicator), m_backrefManager);
     m_backrefManager->pushRef(matcher);
     boost::dynamic_pointer_cast<RegexBackrefMatcher>(matcher)->lateCompile();
@@ -83,40 +83,40 @@
     matcher = make_shared<RegexComponentSetMatcher>(m_expr.substr(0, m_indicator), m_backrefManager);
   }
   m_matcherList.push_back(matcher);
-      
+
   parseRepetition();
 
   // _LOG_TRACE ("Exit RegexRepeatMatcher::compile");
 
 }
 
-inline bool 
+inline bool
 RegexRepeatMatcher::parseRepetition()
 {
   // _LOG_DEBUG ("Enter RegexRepeatMatcher::ParseRepetition()" << m_expr << " indicator: " << m_indicator);
-    
+
   int exprSize = m_expr.size();
   int intMax = std::numeric_limits<int>::max();
-    
-  if(exprSize == m_indicator){
+
+  if (exprSize == m_indicator){
     m_repeatMin = 1;
     m_repeatMax = 1;
 
     return true;
   }
   else{
-    if(exprSize == (m_indicator + 1)){
-      if('?' == m_expr[m_indicator]){
+    if (exprSize == (m_indicator + 1)){
+      if ('?' == m_expr[m_indicator]){
         m_repeatMin = 0;
         m_repeatMax = 1;
         return true;
       }
-      if('+' == m_expr[m_indicator]){
+      if ('+' == m_expr[m_indicator]){
         m_repeatMin = 1;
         m_repeatMax = intMax;
         return true;
       }
-      if('*' == m_expr[m_indicator]){
+      if ('*' == m_expr[m_indicator]){
         m_repeatMin = 0;
         m_repeatMax = intMax;
         return true;
@@ -128,36 +128,36 @@
       int min = 0;
       int max = 0;
 
-      if(boost::regex_match(repeatStruct, boost::regex("\\{[0-9]+,[0-9]+\\}"))){
+      if (boost::regex_match(repeatStruct, boost::regex("\\{[0-9]+,[0-9]+\\}"))){
         int separator = repeatStruct.find_first_of(',', 0);
         min = atoi(repeatStruct.substr(1, separator - 1).c_str());
         max = atoi(repeatStruct.substr(separator + 1, rsSize - separator - 2).c_str());
       }
-      else if(boost::regex_match(repeatStruct, boost::regex("\\{,[0-9]+\\}"))){
+      else if (boost::regex_match(repeatStruct, boost::regex("\\{,[0-9]+\\}"))){
         int separator = repeatStruct.find_first_of(',', 0);
         min = 0;
         max = atoi(repeatStruct.substr(separator + 1, rsSize - separator - 2).c_str());
       }
-      else if(boost::regex_match(repeatStruct, boost::regex("\\{[0-9]+,\\}"))){
+      else if (boost::regex_match(repeatStruct, boost::regex("\\{[0-9]+,\\}"))){
         int separator = repeatStruct.find_first_of(',', 0);
         min = atoi(repeatStruct.substr(1, separator).c_str());
         max = intMax;
       }
-      else if(boost::regex_match(repeatStruct, boost::regex("\\{[0-9]+\\}"))){
+      else if (boost::regex_match(repeatStruct, boost::regex("\\{[0-9]+\\}"))){
         min = atoi(repeatStruct.substr(1, rsSize - 1).c_str());
         max = min;
       }
       else
         throw RegexMatcher::Error(std::string("Error: RegexRepeatMatcher.ParseRepetition(): ")
                                   + "Unrecognized format "+ m_expr);
-        
-      if(min > intMax || max > intMax || min > max)
+
+      if (min > intMax || max > intMax || min > max)
         throw RegexMatcher::Error(std::string("Error: RegexRepeatMatcher.ParseRepetition(): ")
                                   + "Wrong number " + m_expr);
-          
+
       m_repeatMin = min;
       m_repeatMax = max;
-        
+
       return true;
     }
   }
@@ -165,7 +165,7 @@
 }
 
 inline bool
-RegexRepeatMatcher::match(const Name & name, const int & offset, const int & len)
+RegexRepeatMatcher::match(const Name& name, const int& offset, const int& len)
 {
   // _LOG_TRACE ("Enter RegexRepeatMatcher::match");
 
@@ -185,8 +185,8 @@
     return false;
 }
 
-inline bool 
-RegexRepeatMatcher::recursiveMatch(int repeat, const Name & name, const int & offset, const int & len)
+inline bool
+RegexRepeatMatcher::recursiveMatch(int repeat, const Name& name, const int& offset, const int& len)
 {
   // _LOG_TRACE ("Enter RegexRepeatMatcher::recursiveMatch");
 
@@ -213,7 +213,7 @@
       // _LOG_DEBUG("Match Succeed: No more components && reach m_repeatMin");
       return true;
     }
-    
+
   while(tried >= 0)
     {
       // _LOG_DEBUG("Attempt tried: " << tried);
diff --git a/src/util/regex/regex-top-matcher.cpp b/src/util/regex/regex-top-matcher.cpp
index d3b8271..78cb389 100644
--- a/src/util/regex/regex-top-matcher.cpp
+++ b/src/util/regex/regex-top-matcher.cpp
@@ -27,19 +27,19 @@
   // delete m_backRefManager;
 }
 
-void 
+void
 RegexTopMatcher::compile()
 {
   std::string errMsg = "Error: RegexTopMatcher.Compile(): ";
 
   std::string expr = m_expr;
 
-  if('$' != expr[expr.size() - 1])
+  if ('$' != expr[expr.size() - 1])
     expr = expr + "<.*>*";
   else
     expr = expr.substr(0, expr.size()-1);
 
-  if('^' != expr[0])
+  if ('^' != expr[0])
     m_secondaryMatcher = make_shared<RegexPatternListMatcher>(boost::cref("<.*>*" + expr),
                                                               boost::cref(m_secondaryBackRefManager));
   else
@@ -49,14 +49,14 @@
                                                           boost::cref(m_primaryBackRefManager));
 }
 
-bool 
-RegexTopMatcher::match(const Name & name)
+bool
+RegexTopMatcher::match(const Name& name)
 {
   m_secondaryUsed = false;
 
   m_matchResult.clear();
 
-  if(m_primaryMatcher->match(name, 0, name.size()))
+  if (m_primaryMatcher->match(name, 0, name.size()))
     {
       m_matchResult = m_primaryMatcher->getMatchResult();
       return true;
@@ -72,25 +72,25 @@
       return false;
     }
 }
-  
-bool 
-RegexTopMatcher::match (const Name & name, const int & offset, const int & len)
+
+bool
+RegexTopMatcher::match (const Name& name, const int& offset, const int& len)
 {
   return match(name);
 }
 
-Name 
+Name
 RegexTopMatcher::expand (const std::string& expandStr)
 {
   Name result;
-    
+
   shared_ptr<RegexBackrefManager> backRefManager = (m_secondaryUsed ? m_secondaryBackRefManager : m_primaryBackRefManager);
-    
+
   int backRefNum = backRefManager->size();
 
   std::string expand;
-    
-  if(expandStr != "")
+
+  if (expandStr != "")
     expand = expandStr;
   else
     expand = m_expand;
@@ -99,22 +99,22 @@
   while (offset < expand.size())
     {
       std::string item = getItemFromExpand(expand, offset);
-      if(item[0] == '<')
+      if (item[0] == '<')
         {
           result.append(item.substr(1, item.size() - 2));
         }
-      if(item[0] == '\\')
+      if (item[0] == '\\')
         {
 
           int index = atoi(item.substr(1, item.size() - 1).c_str());
 
-          if(0 == index){
+          if (0 == index){
             std::vector<name::Component>::iterator it = m_matchResult.begin();
             std::vector<name::Component>::iterator end = m_matchResult.end();
             for(; it != end; it++)
               result.append (*it);
           }
-          else if(index <= backRefNum)
+          else if (index <= backRefNum)
             {
               std::vector<name::Component>::const_iterator it = backRefManager->getBackRef (index - 1)->getMatchResult ().begin();
               std::vector<name::Component>::const_iterator end = backRefManager->getBackRef (index - 1)->getMatchResult ().end();
@@ -123,7 +123,7 @@
             }
           else
             throw RegexMatcher::Error("Exceed the range of back reference!");
-        }   
+        }
     }
   return result;
 }
@@ -133,38 +133,38 @@
 {
   size_t begin = offset;
 
-  if(expand[offset] == '\\')
+  if (expand[offset] == '\\')
     {
       offset++;
-      if(offset >= expand.size())
+      if (offset >= expand.size())
         throw RegexMatcher::Error("wrong format of expand string!");
 
       while(expand[offset] <= '9' and expand[offset] >= '0'){
         offset++;
-        if(offset > expand.size())
+        if (offset > expand.size())
           throw RegexMatcher::Error("wrong format of expand string!");
       }
-      if(offset > begin + 1)
+      if (offset > begin + 1)
         return expand.substr(begin, offset - begin);
       else
         throw RegexMatcher::Error("wrong format of expand string!");
     }
-  else if(expand[offset] == '<')
+  else if (expand[offset] == '<')
     {
       offset++;
-      if(offset >= expand.size())
+      if (offset >= expand.size())
         throw RegexMatcher::Error("wrong format of expand string!");
-        
+
       size_t left = 1;
       size_t right = 0;
       while(right < left)
         {
-          if(expand[offset] == '<')
+          if (expand[offset] == '<')
             left++;
-          if(expand[offset] == '>')
-            right++;            
+          if (expand[offset] == '>')
+            right++;
           offset++;
-          if(offset >= expand.size())
+          if (offset >= expand.size())
             throw RegexMatcher::Error("wrong format of expand string!");
         }
       return expand.substr(begin, offset - begin);
@@ -178,7 +178,7 @@
 {
   Name::const_iterator it = name.begin();
   std::string regexStr("^");
-    
+
   for(; it != name.end(); it++)
     {
       regexStr.append("<");
@@ -186,7 +186,7 @@
       regexStr.append(">");
     }
 
-  if(hasAnchor)
+  if (hasAnchor)
     regexStr.append("$");
 
   return make_shared<RegexTopMatcher>(boost::cref(regexStr));
@@ -199,7 +199,7 @@
   for(size_t i = 0; i < str.size(); i++)
     {
       char c = str[i];
-      switch(c)
+      switch (c)
         {
         case '.':
         case '[':
diff --git a/src/util/string-helper.hpp b/src/util/string-helper.hpp
index 9e2329c..7059f0a 100644
--- a/src/util/string-helper.hpp
+++ b/src/util/string-helper.hpp
@@ -13,19 +13,19 @@
 
 namespace ndn {
 
-static const char *WHITESPACE_CHARS = " \n\r\t";
+static const char* WHITESPACE_CHARS = " \n\r\t";
 
 /**
  * Return the hex representation of the bytes in array.
  * @param array The array of bytes.
  * @return Hex string.
  */
-inline std::string 
+inline std::string
 toHex(const uint8_t* array, size_t arraySize)
 {
   if (array == 0 || arraySize == 0)
     return "";
-  
+
   std::ostringstream result;
   result.flags(std::ios::hex | std::ios::uppercase);
   for (size_t i = 0; i < arraySize; ++i) {
@@ -42,7 +42,7 @@
  * Modify str in place to erase whitespace on the left.
  * @param str
  */
-inline void 
+inline void
 trimLeft(std::string& str)
 {
   size_t found = str.find_first_not_of(WHITESPACE_CHARS);
@@ -52,14 +52,14 @@
   }
   else
     // All whitespace
-    str.clear();    
+    str.clear();
 }
 
 /**
  * Modify str in place to erase whitespace on the right.
  * @param str
  */
-inline void 
+inline void
 trimRight(std::string& str)
 {
   size_t found = str.find_last_not_of(WHITESPACE_CHARS);
@@ -76,7 +76,7 @@
  * Modify str in place to erase whitespace on the left and right.
  * @param str
  */
-inline void 
+inline void
 trim(std::string& str)
 {
   trimLeft(str);
@@ -86,9 +86,9 @@
 /**
  * Convert the hex character to an integer from 0 to 15, or -1 if not a hex character.
  * @param c
- * @return 
+ * @return
  */
-inline int 
+inline int
 fromHexChar(uint8_t c)
 {
   if (c >= '0' && c <= '9')
@@ -105,22 +105,22 @@
  * Return a copy of str, converting each escaped "%XX" to the char value.
  * @param str
  */
-inline std::string 
+inline std::string
 unescape(const std::string& str)
 {
   std::ostringstream result;
-  
+
   for (size_t i = 0; i < str.size(); ++i) {
     if (str[i] == '%' && i + 2 < str.size()) {
       int hi = fromHexChar(str[i + 1]);
       int lo = fromHexChar(str[i + 2]);
-      
+
       if (hi < 0 || lo < 0)
         // Invalid hex characters, so just keep the escaped string.
         result << str[i] << str[i + 1] << str[i + 2];
       else
         result << (uint8_t)(16 * hi + lo);
-      
+
       // Skip ahead past the escaped value.
       i += 2;
     }
@@ -128,7 +128,7 @@
       // Just copy through.
       result << str[i];
   }
-  
+
   return result.str();
 }
 
diff --git a/tools/ndncatchunks3.cpp b/tools/ndncatchunks3.cpp
index 59a75ad..460ed52 100644
--- a/tools/ndncatchunks3.cpp
+++ b/tools/ndncatchunks3.cpp
@@ -20,27 +20,29 @@
 
 #include "face.hpp"
 
+namespace ndn {
+
 class Consumer
 {
 public:
-  Consumer(const std::string& data_name,
-           size_t pipe_size, size_t total_seg,
+  Consumer(const std::string& dataName,
+           size_t pipeSize, size_t nTotalSegments,
            int scope = -1, bool mustBeFresh = true)
-    : m_data_name(data_name)
-    , m_pipe_size(pipe_size)
-    , m_total_seg(total_seg)
-    , m_next_seg(0)
-    , m_total_size(0)
-    , m_output(false)
+    : m_dataName(dataName)
+    , m_pipeSize(pipeSize)
+    , m_nTotalSegments(nTotalSegments)
+    , m_nextSegment(0)
+    , m_totalSize(0)
+    , m_isOutputEnabled(false)
     , m_scope(scope)
     , m_mustBeFresh(mustBeFresh)
   {
   }
 
   inline void
-  enable_output()
+  enableOutput()
   {
-    m_output = true;
+    m_isOutputEnabled = true;
   }
 
   void
@@ -48,18 +50,18 @@
 
 private:
   void
-  on_data(const ndn::Interest& interest, ndn::Data& data);
+  onData(const Interest& interest, Data& data);
 
   void
-  on_timeout(const ndn::Interest& interest);
+  onTimeout(const Interest& interest);
 
-  ndn::Face m_face;
-  ndn::Name m_data_name;
-  size_t m_pipe_size;
-  size_t m_total_seg;
-  size_t m_next_seg;
-  size_t m_total_size;
-  bool m_output;  // set to false by default
+  Face m_face;
+  Name m_dataName;
+  size_t m_pipeSize;
+  size_t m_nTotalSegments;
+  size_t m_nextSegment;
+  size_t m_totalSize;
+  bool m_isOutputEnabled;  // set to false by default
 
   int m_scope;
   bool m_mustBeFresh;
@@ -70,18 +72,18 @@
 {
   try
     {
-      for (size_t i = 0; i < m_pipe_size; i++)
-	{
-          ndn::Interest interest(ndn::Name(m_data_name).appendSegment(m_next_seg++));
-	  interest.setInterestLifetime(ndn::time::milliseconds(4000));
-	  if (m_scope >= 0)
+      for (size_t i = 0; i < m_pipeSize; i++)
+        {
+          Interest interest(Name(m_dataName).appendSegment(m_nextSegment++));
+          interest.setInterestLifetime(time::milliseconds(4000));
+          if (m_scope >= 0)
             interest.setScope(m_scope);
-	  interest.setMustBeFresh(m_mustBeFresh);
+          interest.setMustBeFresh(m_mustBeFresh);
 
-	  m_face.expressInterest(interest,
-                                 ndn::bind(&Consumer::on_data, this, _1, _2),
-                                 ndn::bind(&Consumer::on_timeout, this, _1));
-	}
+          m_face.expressInterest(interest,
+                                 bind(&Consumer::onData, this, _1, _2),
+                                 bind(&Consumer::onTimeout, this, _1));
+        }
 
       // processEvents will block until the requested data received or timeout occurs
       m_face.processEvents();
@@ -93,85 +95,86 @@
 }
 
 void
-Consumer::on_data(const ndn::Interest& interest, ndn::Data& data)
+Consumer::onData(const Interest& interest, Data& data)
 {
-  const ndn::Block& content = data.getContent();
-  const ndn::Name& name = data.getName();
+  const Block& content = data.getContent();
+  const Name& name = data.getName();
 
-  if (m_output)
+  if (m_isOutputEnabled)
     {
       std::cout.write(reinterpret_cast<const char*>(content.value()), content.value_size());
     }
 
-  m_total_size += content.value_size();
+  m_totalSize += content.value_size();
 
-  if (name[-1].toSegment() + 1 == m_total_seg)
+  if (name[-1].toSegment() + 1 == m_nTotalSegments)
     {
       std::cerr << "Last segment received." << std::endl;
-      std::cerr << "Total # bytes of content received: " << m_total_size << std::endl;
+      std::cerr << "Total # bytes of content received: " << m_totalSize << std::endl;
     }
   else
     {
       // Send interest for next segment
-      ndn::Interest interest(ndn::Name(m_data_name).appendSegment(m_next_seg++));
+      Interest interest(Name(m_dataName).appendSegment(m_nextSegment++));
       if (m_scope >= 0)
         interest.setScope(m_scope);
-      interest.setInterestLifetime(ndn::time::milliseconds(4000));
+      interest.setInterestLifetime(time::milliseconds(4000));
       interest.setMustBeFresh(m_mustBeFresh);
 
       m_face.expressInterest(interest,
-                             ndn::bind(&Consumer::on_data, this, _1, _2),
-                             ndn::bind(&Consumer::on_timeout, this, _1));
+                             bind(&Consumer::onData, this, _1, _2),
+                             bind(&Consumer::onTimeout, this, _1));
     }
 }
 
 
 void
-Consumer::on_timeout(const ndn::Interest& interest)
+Consumer::onTimeout(const Interest& interest)
 {
   //XXX: currently no retrans
-  std::cerr << "TIMEOUT: last interest sent for segment #" << (m_next_seg - 1) << std::endl;
+  std::cerr << "TIMEOUT: last interest sent for segment #" << (m_nextSegment - 1) << std::endl;
 }
 
 
 int
 usage(const std::string &filename)
 {
-  std::cerr << "Usage: \n    " << filename << " [-p pipe_size] [-c total_segment] [-o] /ndn/name\n";
+  std::cerr << "Usage: \n    "
+            << filename << " [-p pipeSize] [-c nTotalSegmentsment] [-o] /ndn/name\n";
   return 1;
 }
 
 
 int
-main(int argc, char **argv)
+main(int argc, char** argv)
 {
   std::string name;
-  int pipe_size = 1;
-  int total_seg = std::numeric_limits<int>::max();
+  int pipeSize = 1;
+  int nTotalSegments = std::numeric_limits<int>::max();
   bool output = false;
 
   int opt;
   while ((opt = getopt(argc, argv, "op:c:")) != -1)
     {
-      switch(opt)
-	{
+      switch (opt)
+        {
         case 'p':
-	  pipe_size = atoi(optarg);
-	  if (pipe_size <= 0)
-	    pipe_size = 1;
-	  std::cerr << "main(): set pipe size = " << pipe_size << std::endl;
-	  break;
-	case 'c':
-	  total_seg = atoi(optarg);
-	  if (total_seg <= 0)
-	    total_seg = 1;
-	  std::cerr << "main(): set total seg = " << total_seg << std::endl;
-	  break;
-	case 'o':
-	  output = true;
-	  break;
+          pipeSize = atoi(optarg);
+          if (pipeSize <= 0)
+            pipeSize = 1;
+          std::cerr << "main(): set pipe size = " << pipeSize << std::endl;
+          break;
+        case 'c':
+          nTotalSegments = atoi(optarg);
+          if (nTotalSegments <= 0)
+            nTotalSegments = 1;
+          std::cerr << "main(): set total seg = " << nTotalSegments << std::endl;
+          break;
+        case 'o':
+          output = true;
+          break;
         default:
-	  return usage(argv[0]);
+          return usage(argv[0]);
         }
     }
 
@@ -185,12 +188,20 @@
       return usage(argv[0]);
     }
 
-  Consumer consumer(name, pipe_size, total_seg);
+  Consumer consumer(name, pipeSize, nTotalSegments);
 
   if (output)
-    consumer.enable_output();
+    consumer.enableOutput();
 
   consumer.run();
 
   return 0;
 }
+
+} // namespace ndn
+
+int
+main(int argc, char** argv)
+{
+  return ndn::main(argc, argv);
+}
diff --git a/tools/ndnputchunks3.cpp b/tools/ndnputchunks3.cpp
index bb6435b..e03e6cf 100644
--- a/tools/ndnputchunks3.cpp
+++ b/tools/ndnputchunks3.cpp
@@ -21,28 +21,30 @@
 #include "face.hpp"
 #include "security/key-chain.hpp"
 
-#define MAX_SEG_SIZE 4096
+namespace ndn {
+
+const size_t MAX_SEG_SIZE = 4096;
 
 class Producer
 {
 public:
   Producer(const char* name)
     : m_name(name)
-    , m_verbose(false)
+    , m_isVerbose(false)
   {
     int segnum = 0;
     char* buf = new char[MAX_SEG_SIZE];
     do
       {
         std::cin.read(buf, MAX_SEG_SIZE);
-        int got = std::cin.gcount ();
+        int got = std::cin.gcount();
 
         if (got > 0)
           {
-            ndn::shared_ptr<ndn::Data> data =
-              ndn::make_shared<ndn::Data>(ndn::Name(m_name).appendSegment(segnum));
+            shared_ptr<Data> data =
+              make_shared<Data>(Name(m_name).appendSegment(segnum));
 
-            data->setFreshnessPeriod(ndn::time::milliseconds(10000)); // 10 sec
+            data->setFreshnessPeriod(time::milliseconds(10000)); // 10 sec
             data->setContent(reinterpret_cast<const uint8_t*>(buf), got);
 
             m_keychain.sign(*data);
@@ -52,14 +54,14 @@
       }
     while (static_cast<bool>(std::cin));
 
-    if (m_verbose)
+    if (m_isVerbose)
       std::cerr << "Created " << segnum << " chunks for prefix [" << m_name << "]" << std::endl;
   }
 
   void
-  onInterest(const ndn::Name& name, const ndn::Interest& interest)
+  onInterest(const Name& name, const Interest& interest)
   {
-    if (m_verbose)
+    if (m_isVerbose)
       std::cerr << "<< I: " << interest << std::endl;
 
     size_t segnum = static_cast<size_t>(interest.getName().rbegin()->toSegment());
@@ -71,7 +73,7 @@
   }
 
   void
-  onRegisterFailed(const ndn::Name& prefix, const std::string& reason)
+  onRegisterFailed(const Name& prefix, const std::string& reason)
   {
     std::cerr << "ERROR: Failed to register prefix in local hub's daemon (" << reason << ")" << std::endl;
     m_face.shutdown();
@@ -87,23 +89,23 @@
       }
 
     m_face.setInterestFilter(m_name,
-                             ndn::bind(&Producer::onInterest, this, _1, _2),
-                             ndn::bind(&Producer::onRegisterFailed, this, _1, _2));
+                             bind(&Producer::onInterest, this, _1, _2),
+                             bind(&Producer::onRegisterFailed, this, _1, _2));
     m_face.processEvents();
   }
 
 private:
-  ndn::Name m_name;
-  ndn::Face m_face;
-  ndn::KeyChain m_keychain;
+  Name m_name;
+  Face m_face;
+  KeyChain m_keychain;
 
-  std::vector< ndn::shared_ptr<ndn::Data> > m_store;
+  std::vector< shared_ptr<Data> > m_store;
 
-  bool m_verbose;
+  bool m_isVerbose;
 };
 
 int
-main(int argc, char *argv[])
+main(int argc, char** argv)
 {
   if (argc < 2)
     {
@@ -113,17 +115,18 @@
 
   try
     {
-      ndn::time::steady_clock::TimePoint startTime = ndn::time::steady_clock::now();
+      time::steady_clock::TimePoint startTime = time::steady_clock::now();
 
       std::cerr << "Preparing the input..." << std::endl;
       Producer producer(argv[1]);
-      std::cerr << "Ready... (took " << (ndn::time::steady_clock::now() - startTime) << std::endl;
+      std::cerr << "Ready... (took " << (time::steady_clock::now() - startTime) << std::endl;
 
       while (true)
         {
           try
             {
-              producer.run(); // this will exit when daemon dies... so try to connect again if possible
+              // this will exit when daemon dies... so try to connect again if possible
+              producer.run();
             }
           catch (std::exception& e)
             {
@@ -139,3 +142,11 @@
     }
   return 0;
 }
+
+} // namespace ndn
+
+int
+main(int argc, char** argv)
+{
+  return ndn::main(argc, argv);
+}