diff --git a/src/tlv/adjacency-lsa.hpp b/src/tlv/adjacency-lsa.hpp
index 217366a..f1854a4 100644
--- a/src/tlv/adjacency-lsa.hpp
+++ b/src/tlv/adjacency-lsa.hpp
@@ -43,7 +43,7 @@
                      LsaInfo
                      Adjacency*
 
-   \sa http://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
+   \sa https://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
  */
 class AdjacencyLsa
 {
@@ -109,13 +109,33 @@
     return *this;
   }
 
+  /*! \brief Encodes the Adjacent objects and some info using the method in TAG.
+   *
+   * This function will TLV-format the Adjacent objects and some LSA
+   * info using the implementation speciifed by TAG. Usually this is
+   * called with an estimator first to guess how long the buffer needs
+   * to be, then with an encoder to do the real work. This process is
+   * automated by the other wireEncode.
+   * \sa AdjacencyLsa::wireEncode()
+   */
   template<ndn::encoding::Tag TAG>
   size_t
   wireEncode(ndn::EncodingImpl<TAG>& block) const;
 
+  /*! \brief Create a TLV encoding of this object.
+   *
+   * Create a block containing the TLV encoding of this object. That
+   * involves two steps: estimating the size that the information will
+   * take up, and then creating a buffer of that size and encoding the
+   * information into it. Both steps are accomplished by
+   * AdjacencyLsa::wireEncode(ndn::EncodingImpl<TAG>&)
+   */
   const ndn::Block&
   wireEncode() const;
 
+  /*! \brief Populate this object by decoding the one contained in the
+   * given block.
+   */
   void
   wireDecode(const ndn::Block& wire);
 
diff --git a/src/tlv/adjacency.hpp b/src/tlv/adjacency.hpp
index 5767ce6..2e5dec7 100644
--- a/src/tlv/adjacency.hpp
+++ b/src/tlv/adjacency.hpp
@@ -39,7 +39,7 @@
                   Uri
                   Cost
 
-   \sa http://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
+   \sa https://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
  */
 class Adjacency
 {
@@ -101,13 +101,31 @@
     return *this;
   }
 
+  /*! \brief TLV-encode this object using the implementation in from TAG.
+   *
+   * This method TLV-encodes this Adjacency object using the
+   * implementation given by TAG. Usually two implementations are
+   * provided: a size estimator and a real encoder, which are used in
+   * sequence to allocate the necessary block size and then encode it.
+   * \sa Adjacency::wireEncode()
+   */
   template<ndn::encoding::Tag TAG>
   size_t
   wireEncode(ndn::EncodingImpl<TAG>& block) const;
 
+  /*! \brief Create a TLV encoding of this object.
+   *
+   * This function automates the process of guessing the necessary
+   * size of a block containing this object, and then creating a block
+   * and putting the TLV encoding into it.
+   * \sa Adjacency::wireEncode(ndn::EncodingImpl<TAG>&)
+   */
   const ndn::Block&
   wireEncode() const;
 
+  /*! \brief Populate this object by decoding the object contained in
+   * the given block.
+   */
   void
   wireDecode(const ndn::Block& wire);
 
diff --git a/src/tlv/coordinate-lsa.hpp b/src/tlv/coordinate-lsa.hpp
index 0568cc1..18c32ab 100644
--- a/src/tlv/coordinate-lsa.hpp
+++ b/src/tlv/coordinate-lsa.hpp
@@ -103,13 +103,33 @@
     return *this;
   }
 
+  /*! \brief Encodes the hyperbolic coordinates and some info using the method in TAG.
+   *
+   * This function will TLV-format the hyperbolic coordinates objects and some LSA
+   * info using the implementation speciifed by TAG. Usually this is
+   * called with an estimator first to guess how long the buffer needs
+   * to be, then with an encoder to do the real work. This process is
+   * automated by the other wireEncode.
+   * \sa CoordinateLsa::wireEncode()
+   */
   template<ndn::encoding::Tag TAG>
   size_t
   wireEncode(ndn::EncodingImpl<TAG>& block) const;
 
+  /*! \brief Create a TLV encoding of this object.
+   *
+   * Create a block containing the TLV encoding of this object. That
+   * involves two steps: estimating the size that the information will
+   * take up, and then creating a buffer of that size and encoding the
+   * information into it. Both steps are accomplished by
+   * CoordinateLsa::wireEncode(ndn::EncodingImpl<TAG>&)
+   */
   const ndn::Block&
   wireEncode() const;
 
+  /*! \brief Populate this object by decoding the one contained in the
+   * given block.
+   */
   void
   wireDecode(const ndn::Block& wire);
 
diff --git a/src/tlv/lsa-info.hpp b/src/tlv/lsa-info.hpp
index ef2142a..4573661 100644
--- a/src/tlv/lsa-info.hpp
+++ b/src/tlv/lsa-info.hpp
@@ -22,6 +22,8 @@
 #ifndef NLSR_TLV_LSA_INFO_HPP
 #define NLSR_TLV_LSA_INFO_HPP
 
+#include "lsa.hpp"
+
 #include <ndn-cxx/util/time.hpp>
 #include <ndn-cxx/encoding/block.hpp>
 #include <ndn-cxx/encoding/encoding-buffer.hpp>
@@ -29,8 +31,6 @@
 #include <ndn-cxx/name.hpp>
 #include <boost/throw_exception.hpp>
 
-#include "lsa.hpp"
-
 namespace nlsr {
 namespace tlv {
 
@@ -115,13 +115,33 @@
     return m_hasInfiniteExpirationPeriod;
   }
 
+  /*! \brief Encodes LSA info using the method in TAG.
+   *
+   * This function will TLV-format LSA info using the implementation
+   * speciifed by TAG. Usually this is called with an estimator first
+   * to guess how long the buffer needs to be, then with an encoder to
+   * do the real work. This process is automated by the other
+   * wireEncode.
+   * \sa LsaInfo::wireEncode()
+   */
   template<ndn::encoding::Tag TAG>
   size_t
   wireEncode(ndn::EncodingImpl<TAG>& block) const;
 
+  /*! \brief Create a TLV encoding of this object.
+   *
+   * Create a block containing the TLV encoding of this object. That
+   * involves two steps: estimating the size that the information will
+   * take up, and then creating a buffer of that size and encoding the
+   * information into it. Both steps are accomplished by
+   * LsaInfo::wireEncode(ndn::EncodingImpl<TAG>&)
+   */
   const ndn::Block&
   wireEncode() const;
 
+  /*! \brief Populate this object by decoding the one contained in the
+   * given block.
+   */
   void
   wireDecode(const ndn::Block& wire);
 
diff --git a/src/tlv/lsdb-status.hpp b/src/tlv/lsdb-status.hpp
index 5fc8f8c..fb494e6 100644
--- a/src/tlv/lsdb-status.hpp
+++ b/src/tlv/lsdb-status.hpp
@@ -45,7 +45,7 @@
                    CoordinateLsa*
                    NameLsa*
 
-   \sa http://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
+   \sa https://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
  */
 class LsdbStatus
 {
@@ -156,13 +156,34 @@
     return m_hasNameLsas;
   }
 
+  /*! \brief Encodes the LSA objects and some info for each LSA using
+   * the method in TAG.
+   *
+   * This function will TLV-format the LSA objects and some LSA
+   * info using the implementation specified by TAG. Usually this is
+   * called with an estimator first to guess how long the buffer needs
+   * to be, then with an encoder to do the real work. This process is
+   * automated by the other wireEncode.
+   * \sa LsdbStatus::wireEncode()
+   */
   template<ndn::encoding::Tag TAG>
   size_t
   wireEncode(ndn::EncodingImpl<TAG>& block) const;
 
+  /*! \brief Create a TLV encoding of this object.
+   *
+   * Create a block containing the TLV encoding of this object. That
+   * involves two steps: estimating the size that the information will
+   * take up, and then creating a buffer of that size and encoding the
+   * information into it. Both steps are accomplished by
+   * LsdbStatus::wireEncode(ndn::EncodingImpl<TAG>&)
+   */
   const ndn::Block&
   wireEncode() const;
 
+  /*! \brief Populate this object by decoding the one contained in the
+   * given block.
+   */
   void
   wireDecode(const ndn::Block& wire);
 
diff --git a/src/tlv/name-lsa.hpp b/src/tlv/name-lsa.hpp
index e120af8..2e137be 100644
--- a/src/tlv/name-lsa.hpp
+++ b/src/tlv/name-lsa.hpp
@@ -42,7 +42,7 @@
                 LsaInfo
                 Name+
 
-   \sa http://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
+   \sa https://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
  */
 class NameLsa
 {
@@ -108,13 +108,33 @@
     return *this;
   }
 
+  /*! \brief Encodes the Name objects and some info using the method in TAG.
+   *
+   * This function will TLV-format the Name objects and some LSA
+   * info using the implementation speciifed by TAG. Usually this is
+   * called with an estimator first to guess how long the buffer needs
+   * to be, then with an encoder to do the real work. This process is
+   * automated by the other wireEncode.
+   * \sa NameLsa::wireEncode()
+   */
   template<ndn::encoding::Tag TAG>
   size_t
   wireEncode(ndn::EncodingImpl<TAG>& block) const;
 
+  /*! \brief Create a TLV encoding of this object.
+   *
+   * Create a block containing the TLV encoding of this object. That
+   * involves two steps: estimating the size that the information will
+   * take up, and then creating a buffer of that size and encoding the
+   * information into it. Both steps are accomplished by
+   * NameLsa::wireEncode(ndn::EncodingImpl<TAG>&)
+   */
   const ndn::Block&
   wireEncode() const;
 
+  /*! \brief Populate this object by decoding the one contained in the
+   * given block.
+   */
   void
   wireDecode(const ndn::Block& wire);
 
diff --git a/src/tlv/tlv-nlsr.hpp b/src/tlv/tlv-nlsr.hpp
index e202b64..4a52b1b 100644
--- a/src/tlv/tlv-nlsr.hpp
+++ b/src/tlv/tlv-nlsr.hpp
@@ -24,11 +24,15 @@
 
 #include <ndn-cxx/encoding/tlv.hpp>
 
-namespace ndn  {
-namespace tlv  {
+namespace ndn {
+namespace tlv {
 namespace nlsr {
 
-// LSDB DataSet
+/*! The TLV block types that NLSR uses to encode/decode LSA types. The
+ *  way NLSR encodes LSAs to TLV is by encoding each element of the
+ *  LSA as a separate TLV block. So, block types are needed. These are
+ *  used in the LSDB Status Dataset.
+ */
 enum {
   LsaInfo          = 128,
   OriginRouter     = 129,