diff --git a/allclasses-frame.html b/allclasses-frame.html
index 3a501df..7d54ffc 100644
--- a/allclasses-frame.html
+++ b/allclasses-frame.html
@@ -2,10 +2,10 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:42 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>All Classes (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>All Classes (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
diff --git a/allclasses-noframe.html b/allclasses-noframe.html
index 027da44..5f5ec4c 100644
--- a/allclasses-noframe.html
+++ b/allclasses-noframe.html
@@ -2,10 +2,10 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:42 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>All Classes (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>All Classes (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
diff --git a/com/intel/jndn/management/EncodingHelper.html b/com/intel/jndn/management/EncodingHelper.html
index 9740460..f69a20f 100644
--- a/com/intel/jndn/management/EncodingHelper.html
+++ b/com/intel/jndn/management/EncodingHelper.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:40 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:51 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>EncodingHelper (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>EncodingHelper (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="EncodingHelper (jndn-management 0.9.7 API)";
+        parent.document.title="EncodingHelper (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/ManagementException.html b/com/intel/jndn/management/ManagementException.html
index cf9e82c..394abe3 100644
--- a/com/intel/jndn/management/ManagementException.html
+++ b/com/intel/jndn/management/ManagementException.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:40 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:51 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>ManagementException (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>ManagementException (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="ManagementException (jndn-management 0.9.7 API)";
+        parent.document.title="ManagementException (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/NFD.html b/com/intel/jndn/management/NFD.html
index 19eb1a8..d6fe5a4 100644
--- a/com/intel/jndn/management/NFD.html
+++ b/com/intel/jndn/management/NFD.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:40 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>NFD (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>NFD (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="NFD (jndn-management 0.9.7 API)";
+        parent.document.title="NFD (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
@@ -224,6 +224,12 @@
 </td>
 </tr>
 <tr class="altColor">
+<td class="colFirst"><code>static net.named_data.jndn.KeyLocator</code></td>
+<td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#getKeyLocator(net.named_data.jndn.Face)">getKeyLocator</a></strong>(net.named_data.jndn.Face&nbsp;forwarder)</code>
+<div class="block">Retrieve the <code>KeyLocator</code> for an NFD.</div>
+</td>
+</tr>
+<tr class="rowColor">
 <td class="colFirst"><code>static <a href="http://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../com/intel/jndn/management/types/RibEntry.html" title="class in com.intel.jndn.management.types">RibEntry</a>&gt;</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#getRouteList(net.named_data.jndn.Face)">getRouteList</a></strong>(net.named_data.jndn.Face&nbsp;forwarder)</code>
 <div class="block">Retrieve a list of routing entries from the RIB; calls
@@ -231,7 +237,7 @@
  are dropped).</div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static boolean</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#ping(net.named_data.jndn.Face, net.named_data.jndn.Name)">ping</a></strong>(net.named_data.jndn.Face&nbsp;face,
     net.named_data.jndn.Name&nbsp;name)</code>
@@ -239,7 +245,7 @@
  responding to requests.</div>
 </td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static boolean</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#pingLocal(net.named_data.jndn.Face)">pingLocal</a></strong>(net.named_data.jndn.Face&nbsp;face)</code>
 <div class="block">Ping a forwarder on an existing face to verify that the forwarder is
@@ -248,7 +254,7 @@
  same machine as the NDN forwarding daemon.</div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#register(net.named_data.jndn.Face, net.named_data.jndn.ControlParameters)">register</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
         net.named_data.jndn.ControlParameters&nbsp;controlParameters)</code>
@@ -259,7 +265,7 @@
  for protocol documentation.</div>
 </td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#register(net.named_data.jndn.Face, int, net.named_data.jndn.Name, int)">register</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
         int&nbsp;faceId,
@@ -269,7 +275,7 @@
  is provided a faceId.</div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#register(net.named_data.jndn.Face, java.lang.String, net.named_data.jndn.Name, int)">register</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
         <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;uri,
@@ -279,7 +285,7 @@
  forwarder to the given URI/route pair.</div>
 </td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static net.named_data.jndn.Data</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#retrieveDataSet(net.named_data.jndn.Face, net.named_data.jndn.Name)">retrieveDataSet</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
                net.named_data.jndn.Name&nbsp;datasetName)</code>
@@ -288,7 +294,7 @@
  <a href="http://redmine.named-data.net/projects/nfd/wiki/StatusDataset">http://redmine.named-data.net/projects/nfd/wiki/StatusDataset</a></div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static <a href="../../../../com/intel/jndn/management/types/ControlResponse.html" title="class in com.intel.jndn.management.types">ControlResponse</a></code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#sendCommand(net.named_data.jndn.Face, net.named_data.jndn.Interest)">sendCommand</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
            net.named_data.jndn.Interest&nbsp;interest)</code>
@@ -297,7 +303,7 @@
  from the forwarder.</div>
 </td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#setStrategy(net.named_data.jndn.Face, net.named_data.jndn.Name, net.named_data.jndn.Name)">setStrategy</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
            net.named_data.jndn.Name&nbsp;prefix,
@@ -309,7 +315,7 @@
  for protocol documentation.</div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#unregister(net.named_data.jndn.Face, net.named_data.jndn.ControlParameters)">unregister</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
           net.named_data.jndn.ControlParameters&nbsp;controlParameters)</code>
@@ -320,7 +326,7 @@
  for protocol documentation.</div>
 </td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#unregister(net.named_data.jndn.Face, net.named_data.jndn.Name)">unregister</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
           net.named_data.jndn.Name&nbsp;route)</code>
@@ -331,7 +337,7 @@
  for protocol documentation.</div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#unregister(net.named_data.jndn.Face, net.named_data.jndn.Name, int)">unregister</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
           net.named_data.jndn.Name&nbsp;route,
@@ -343,7 +349,7 @@
  for protocol documentation.</div>
 </td>
 </tr>
-<tr class="altColor">
+<tr class="rowColor">
 <td class="colFirst"><code>static void</code></td>
 <td class="colLast"><code><strong><a href="../../../../com/intel/jndn/management/NFD.html#unregister(net.named_data.jndn.Face, net.named_data.jndn.Name, java.lang.String)">unregister</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
           net.named_data.jndn.Name&nbsp;route,
@@ -524,6 +530,23 @@
 <dd><code><a href="http://docs.oracle.com/javase/7/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></code></dd></dl>
 </li>
 </ul>
+<a name="getKeyLocator(net.named_data.jndn.Face)">
+<!--   -->
+</a>
+<ul class="blockList">
+<li class="blockList">
+<h4>getKeyLocator</h4>
+<pre>public static&nbsp;net.named_data.jndn.KeyLocator&nbsp;getKeyLocator(net.named_data.jndn.Face&nbsp;forwarder)
+                                                    throws <a href="../../../../com/intel/jndn/management/ManagementException.html" title="class in com.intel.jndn.management">ManagementException</a>,
+                                                           <a href="http://docs.oracle.com/javase/7/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
+<div class="block">Retrieve the <code>KeyLocator</code> for an NFD.</div>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>forwarder</code> - only a localhost <code>Face</code></dd>
+<dt><span class="strong">Returns:</span></dt><dd>the <code>KeyLocator</code> of the NFD's key</dd>
+<dt><span class="strong">Throws:</span></dt>
+<dd><code><a href="../../../../com/intel/jndn/management/ManagementException.html" title="class in com.intel.jndn.management">ManagementException</a></code> - if the key is not available</dd>
+<dd><code><a href="http://docs.oracle.com/javase/7/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if the request fails</dd></dl>
+</li>
+</ul>
 <a name="addNextHop(net.named_data.jndn.Face, int, net.named_data.jndn.Name)">
 <!--   -->
 </a>
@@ -789,11 +812,11 @@
 <div class="block">Build an interest to retrieve a segmented data set from the NFD; for
  details on the DataSet, see
  <a href="http://redmine.named-data.net/projects/nfd/wiki/StatusDataset">http://redmine.named-data.net/projects/nfd/wiki/StatusDataset</a></div>
-<dl><dt><span class="strong">Parameters:</span></dt><dd><code>forwarder</code> - </dd><dd><code>datasetName</code> - </dd>
-<dt><span class="strong">Returns:</span></dt><dd></dd>
+<dl><dt><span class="strong">Parameters:</span></dt><dd><code>forwarder</code> - the <code>Face</code> to an NFD</dd><dd><code>datasetName</code> - the <code>Name</code> of the dataset to retrieve</dd>
+<dt><span class="strong">Returns:</span></dt><dd>the re-assembled <code>Data</code> packet</dd>
 <dt><span class="strong">Throws:</span></dt>
-<dd><code><a href="http://docs.oracle.com/javase/7/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
-<dd><code><a href="../../../../com/intel/jndn/management/ManagementException.html" title="class in com.intel.jndn.management">ManagementException</a></code></dd></dl>
+<dd><code><a href="http://docs.oracle.com/javase/7/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if the request fails</dd>
+<dd><code><a href="../../../../com/intel/jndn/management/ManagementException.html" title="class in com.intel.jndn.management">ManagementException</a></code> - if the returned TLV is not the expected type</dd></dl>
 </li>
 </ul>
 <a name="sendCommand(net.named_data.jndn.Face, net.named_data.jndn.Interest)">
@@ -816,7 +839,7 @@
  <a href="http://redmine.named-data.net/projects/nfd/wiki/ControlCommand,">http://redmine.named-data.net/projects/nfd/wiki/ControlCommand,</a>
  the requested interest must have encoded ControlParameters appended to the
  interest name</dd>
-<dt><span class="strong">Returns:</span></dt><dd></dd>
+<dt><span class="strong">Returns:</span></dt><dd>a <a href="../../../../com/intel/jndn/management/types/ControlResponse.html" title="class in com.intel.jndn.management.types"><code>ControlResponse</code></a></dd>
 <dt><span class="strong">Throws:</span></dt>
 <dd><code><a href="http://docs.oracle.com/javase/7/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
 <dd><code>net.named_data.jndn.encoding.EncodingException</code></dd>
diff --git a/com/intel/jndn/management/class-use/EncodingHelper.html b/com/intel/jndn/management/class-use/EncodingHelper.html
index d0a2203..58869f3 100644
--- a/com/intel/jndn/management/class-use/EncodingHelper.html
+++ b/com/intel/jndn/management/class-use/EncodingHelper.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.EncodingHelper (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.EncodingHelper (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.EncodingHelper (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.EncodingHelper (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/class-use/ManagementException.html b/com/intel/jndn/management/class-use/ManagementException.html
index d76f895..d7a54ba 100644
--- a/com/intel/jndn/management/class-use/ManagementException.html
+++ b/com/intel/jndn/management/class-use/ManagementException.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.ManagementException (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.ManagementException (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.ManagementException (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.ManagementException (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
@@ -122,6 +122,12 @@
 </tr>
 <tbody>
 <tr class="altColor">
+<td class="colFirst"><code>static net.named_data.jndn.KeyLocator</code></td>
+<td class="colLast"><span class="strong">NFD.</span><code><strong><a href="../../../../../com/intel/jndn/management/NFD.html#getKeyLocator(net.named_data.jndn.Face)">getKeyLocator</a></strong>(net.named_data.jndn.Face&nbsp;forwarder)</code>
+<div class="block">Retrieve the <code>KeyLocator</code> for an NFD.</div>
+</td>
+</tr>
+<tr class="rowColor">
 <td class="colFirst"><code>static net.named_data.jndn.Data</code></td>
 <td class="colLast"><span class="strong">NFD.</span><code><strong><a href="../../../../../com/intel/jndn/management/NFD.html#retrieveDataSet(net.named_data.jndn.Face, net.named_data.jndn.Name)">retrieveDataSet</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
                net.named_data.jndn.Name&nbsp;datasetName)</code>
@@ -130,7 +136,7 @@
  <a href="http://redmine.named-data.net/projects/nfd/wiki/StatusDataset">http://redmine.named-data.net/projects/nfd/wiki/StatusDataset</a></div>
 </td>
 </tr>
-<tr class="rowColor">
+<tr class="altColor">
 <td class="colFirst"><code>static <a href="../../../../../com/intel/jndn/management/types/ControlResponse.html" title="class in com.intel.jndn.management.types">ControlResponse</a></code></td>
 <td class="colLast"><span class="strong">NFD.</span><code><strong><a href="../../../../../com/intel/jndn/management/NFD.html#sendCommand(net.named_data.jndn.Face, net.named_data.jndn.Interest)">sendCommand</a></strong>(net.named_data.jndn.Face&nbsp;forwarder,
            net.named_data.jndn.Interest&nbsp;interest)</code>
diff --git a/com/intel/jndn/management/class-use/NFD.html b/com/intel/jndn/management/class-use/NFD.html
index c440517..4d9a913 100644
--- a/com/intel/jndn/management/class-use/NFD.html
+++ b/com/intel/jndn/management/class-use/NFD.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.NFD (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.NFD (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.NFD (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.NFD (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/package-frame.html b/com/intel/jndn/management/package-frame.html
index 310d141..2c03510 100644
--- a/com/intel/jndn/management/package-frame.html
+++ b/com/intel/jndn/management/package-frame.html
@@ -2,10 +2,10 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>com.intel.jndn.management (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>com.intel.jndn.management (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 </head>
 <body>
diff --git a/com/intel/jndn/management/package-summary.html b/com/intel/jndn/management/package-summary.html
index 50fe309..0961415 100644
--- a/com/intel/jndn/management/package-summary.html
+++ b/com/intel/jndn/management/package-summary.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>com.intel.jndn.management (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>com.intel.jndn.management (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="com.intel.jndn.management (jndn-management 0.9.7 API)";
+        parent.document.title="com.intel.jndn.management (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/package-tree.html b/com/intel/jndn/management/package-tree.html
index a4bdc7d..91be34c 100644
--- a/com/intel/jndn/management/package-tree.html
+++ b/com/intel/jndn/management/package-tree.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>com.intel.jndn.management Class Hierarchy (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>com.intel.jndn.management Class Hierarchy (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="com.intel.jndn.management Class Hierarchy (jndn-management 0.9.7 API)";
+        parent.document.title="com.intel.jndn.management Class Hierarchy (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/package-use.html b/com/intel/jndn/management/package-use.html
index f9f91c5..fd2509b 100644
--- a/com/intel/jndn/management/package-use.html
+++ b/com/intel/jndn/management/package-use.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Package com.intel.jndn.management (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Package com.intel.jndn.management (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Package com.intel.jndn.management (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Package com.intel.jndn.management (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/ControlResponse.html b/com/intel/jndn/management/types/ControlResponse.html
index d506b3a..8df9dd7 100644
--- a/com/intel/jndn/management/types/ControlResponse.html
+++ b/com/intel/jndn/management/types/ControlResponse.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>ControlResponse (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>ControlResponse (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="ControlResponse (jndn-management 0.9.7 API)";
+        parent.document.title="ControlResponse (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/Decodable.html b/com/intel/jndn/management/types/Decodable.html
index 818316c..dd02f8b 100644
--- a/com/intel/jndn/management/types/Decodable.html
+++ b/com/intel/jndn/management/types/Decodable.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Decodable (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Decodable (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Decodable (jndn-management 0.9.7 API)";
+        parent.document.title="Decodable (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/FacePersistency.html b/com/intel/jndn/management/types/FacePersistency.html
index ddc7c5e..4f97c11 100644
--- a/com/intel/jndn/management/types/FacePersistency.html
+++ b/com/intel/jndn/management/types/FacePersistency.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>FacePersistency (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>FacePersistency (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="FacePersistency (jndn-management 0.9.7 API)";
+        parent.document.title="FacePersistency (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/FaceScope.html b/com/intel/jndn/management/types/FaceScope.html
index 3ccba85..b5ab776 100644
--- a/com/intel/jndn/management/types/FaceScope.html
+++ b/com/intel/jndn/management/types/FaceScope.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>FaceScope (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>FaceScope (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="FaceScope (jndn-management 0.9.7 API)";
+        parent.document.title="FaceScope (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/FaceStatus.html b/com/intel/jndn/management/types/FaceStatus.html
index a861394..37710eb 100644
--- a/com/intel/jndn/management/types/FaceStatus.html
+++ b/com/intel/jndn/management/types/FaceStatus.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>FaceStatus (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>FaceStatus (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="FaceStatus (jndn-management 0.9.7 API)";
+        parent.document.title="FaceStatus (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/FibEntry.html b/com/intel/jndn/management/types/FibEntry.html
index 8c687df..67e386a 100644
--- a/com/intel/jndn/management/types/FibEntry.html
+++ b/com/intel/jndn/management/types/FibEntry.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>FibEntry (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>FibEntry (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="FibEntry (jndn-management 0.9.7 API)";
+        parent.document.title="FibEntry (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/ForwarderStatus.html b/com/intel/jndn/management/types/ForwarderStatus.html
index f44ea35..4816ab8 100644
--- a/com/intel/jndn/management/types/ForwarderStatus.html
+++ b/com/intel/jndn/management/types/ForwarderStatus.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>ForwarderStatus (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>ForwarderStatus (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="ForwarderStatus (jndn-management 0.9.7 API)";
+        parent.document.title="ForwarderStatus (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/LinkType.html b/com/intel/jndn/management/types/LinkType.html
index fb6b0ce..a3c445c 100644
--- a/com/intel/jndn/management/types/LinkType.html
+++ b/com/intel/jndn/management/types/LinkType.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>LinkType (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>LinkType (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="LinkType (jndn-management 0.9.7 API)";
+        parent.document.title="LinkType (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/LocalControlHeader.html b/com/intel/jndn/management/types/LocalControlHeader.html
index 85fd8a8..fa6efeb 100644
--- a/com/intel/jndn/management/types/LocalControlHeader.html
+++ b/com/intel/jndn/management/types/LocalControlHeader.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>LocalControlHeader (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>LocalControlHeader (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="LocalControlHeader (jndn-management 0.9.7 API)";
+        parent.document.title="LocalControlHeader (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/NextHopRecord.html b/com/intel/jndn/management/types/NextHopRecord.html
index 0438019..d4150c0 100644
--- a/com/intel/jndn/management/types/NextHopRecord.html
+++ b/com/intel/jndn/management/types/NextHopRecord.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>NextHopRecord (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>NextHopRecord (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="NextHopRecord (jndn-management 0.9.7 API)";
+        parent.document.title="NextHopRecord (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/RibEntry.html b/com/intel/jndn/management/types/RibEntry.html
index 5e09df5..4c651ab 100644
--- a/com/intel/jndn/management/types/RibEntry.html
+++ b/com/intel/jndn/management/types/RibEntry.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:52 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>RibEntry (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>RibEntry (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="RibEntry (jndn-management 0.9.7 API)";
+        parent.document.title="RibEntry (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/Route.html b/com/intel/jndn/management/types/Route.html
index 88f13d9..11eae6c 100644
--- a/com/intel/jndn/management/types/Route.html
+++ b/com/intel/jndn/management/types/Route.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Route (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Route (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Route (jndn-management 0.9.7 API)";
+        parent.document.title="Route (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/StatusDataset.html b/com/intel/jndn/management/types/StatusDataset.html
index 4cfb59a..5ae8b76 100644
--- a/com/intel/jndn/management/types/StatusDataset.html
+++ b/com/intel/jndn/management/types/StatusDataset.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>StatusDataset (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>StatusDataset (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="StatusDataset (jndn-management 0.9.7 API)";
+        parent.document.title="StatusDataset (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/ControlResponse.html b/com/intel/jndn/management/types/class-use/ControlResponse.html
index 797c3b7..e6777f2 100644
--- a/com/intel/jndn/management/types/class-use/ControlResponse.html
+++ b/com/intel/jndn/management/types/class-use/ControlResponse.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.ControlResponse (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.ControlResponse (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.ControlResponse (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.ControlResponse (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/Decodable.html b/com/intel/jndn/management/types/class-use/Decodable.html
index ded46ca..2746591 100644
--- a/com/intel/jndn/management/types/class-use/Decodable.html
+++ b/com/intel/jndn/management/types/class-use/Decodable.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Interface com.intel.jndn.management.types.Decodable (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Interface com.intel.jndn.management.types.Decodable (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Interface com.intel.jndn.management.types.Decodable (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Interface com.intel.jndn.management.types.Decodable (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/FacePersistency.html b/com/intel/jndn/management/types/class-use/FacePersistency.html
index cee0bbe..d0133e0 100644
--- a/com/intel/jndn/management/types/class-use/FacePersistency.html
+++ b/com/intel/jndn/management/types/class-use/FacePersistency.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.FacePersistency (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.FacePersistency (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.FacePersistency (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.FacePersistency (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/FaceScope.html b/com/intel/jndn/management/types/class-use/FaceScope.html
index b0be27b..ff34c04 100644
--- a/com/intel/jndn/management/types/class-use/FaceScope.html
+++ b/com/intel/jndn/management/types/class-use/FaceScope.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.FaceScope (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.FaceScope (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.FaceScope (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.FaceScope (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/FaceStatus.html b/com/intel/jndn/management/types/class-use/FaceStatus.html
index cbaa482..1ef7611 100644
--- a/com/intel/jndn/management/types/class-use/FaceStatus.html
+++ b/com/intel/jndn/management/types/class-use/FaceStatus.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.FaceStatus (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.FaceStatus (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.FaceStatus (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.FaceStatus (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/FibEntry.html b/com/intel/jndn/management/types/class-use/FibEntry.html
index 1a27815..80595cb 100644
--- a/com/intel/jndn/management/types/class-use/FibEntry.html
+++ b/com/intel/jndn/management/types/class-use/FibEntry.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.FibEntry (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.FibEntry (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.FibEntry (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.FibEntry (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/ForwarderStatus.html b/com/intel/jndn/management/types/class-use/ForwarderStatus.html
index f5247be..a95a95d 100644
--- a/com/intel/jndn/management/types/class-use/ForwarderStatus.html
+++ b/com/intel/jndn/management/types/class-use/ForwarderStatus.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.ForwarderStatus (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.ForwarderStatus (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.ForwarderStatus (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.ForwarderStatus (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/LinkType.html b/com/intel/jndn/management/types/class-use/LinkType.html
index 128c6df..780729c 100644
--- a/com/intel/jndn/management/types/class-use/LinkType.html
+++ b/com/intel/jndn/management/types/class-use/LinkType.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.LinkType (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.LinkType (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.LinkType (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.LinkType (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/LocalControlHeader.html b/com/intel/jndn/management/types/class-use/LocalControlHeader.html
index 335c07d..d86e866 100644
--- a/com/intel/jndn/management/types/class-use/LocalControlHeader.html
+++ b/com/intel/jndn/management/types/class-use/LocalControlHeader.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.LocalControlHeader (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.LocalControlHeader (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.LocalControlHeader (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.LocalControlHeader (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/NextHopRecord.html b/com/intel/jndn/management/types/class-use/NextHopRecord.html
index d2360da..aa672cd 100644
--- a/com/intel/jndn/management/types/class-use/NextHopRecord.html
+++ b/com/intel/jndn/management/types/class-use/NextHopRecord.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.NextHopRecord (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.NextHopRecord (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.NextHopRecord (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.NextHopRecord (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/RibEntry.html b/com/intel/jndn/management/types/class-use/RibEntry.html
index df08cd7..930f94a 100644
--- a/com/intel/jndn/management/types/class-use/RibEntry.html
+++ b/com/intel/jndn/management/types/class-use/RibEntry.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.RibEntry (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.RibEntry (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.RibEntry (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.RibEntry (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/Route.html b/com/intel/jndn/management/types/class-use/Route.html
index cb4ef78..49057da 100644
--- a/com/intel/jndn/management/types/class-use/Route.html
+++ b/com/intel/jndn/management/types/class-use/Route.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.Route (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.Route (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.Route (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.Route (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/class-use/StatusDataset.html b/com/intel/jndn/management/types/class-use/StatusDataset.html
index 4796eb7..5631b9b 100644
--- a/com/intel/jndn/management/types/class-use/StatusDataset.html
+++ b/com/intel/jndn/management/types/class-use/StatusDataset.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Class com.intel.jndn.management.types.StatusDataset (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Class com.intel.jndn.management.types.StatusDataset (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Class com.intel.jndn.management.types.StatusDataset (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Class com.intel.jndn.management.types.StatusDataset (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/package-frame.html b/com/intel/jndn/management/types/package-frame.html
index 31fdca7..438881d 100644
--- a/com/intel/jndn/management/types/package-frame.html
+++ b/com/intel/jndn/management/types/package-frame.html
@@ -2,10 +2,10 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>com.intel.jndn.management.types (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>com.intel.jndn.management.types (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
diff --git a/com/intel/jndn/management/types/package-summary.html b/com/intel/jndn/management/types/package-summary.html
index 74d16be..1f1ba65 100644
--- a/com/intel/jndn/management/types/package-summary.html
+++ b/com/intel/jndn/management/types/package-summary.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>com.intel.jndn.management.types (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>com.intel.jndn.management.types (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="com.intel.jndn.management.types (jndn-management 0.9.7 API)";
+        parent.document.title="com.intel.jndn.management.types (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/package-tree.html b/com/intel/jndn/management/types/package-tree.html
index f6e107a..f58db48 100644
--- a/com/intel/jndn/management/types/package-tree.html
+++ b/com/intel/jndn/management/types/package-tree.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>com.intel.jndn.management.types Class Hierarchy (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>com.intel.jndn.management.types Class Hierarchy (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="com.intel.jndn.management.types Class Hierarchy (jndn-management 0.9.7 API)";
+        parent.document.title="com.intel.jndn.management.types Class Hierarchy (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/com/intel/jndn/management/types/package-use.html b/com/intel/jndn/management/types/package-use.html
index 4a65fc6..be30a0c 100644
--- a/com/intel/jndn/management/types/package-use.html
+++ b/com/intel/jndn/management/types/package-use.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Uses of Package com.intel.jndn.management.types (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Uses of Package com.intel.jndn.management.types (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Uses of Package com.intel.jndn.management.types (jndn-management 0.9.7 API)";
+        parent.document.title="Uses of Package com.intel.jndn.management.types (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/constant-values.html b/constant-values.html
index a8e43f5..38920a6 100644
--- a/constant-values.html
+++ b/constant-values.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Constant Field Values (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Constant Field Values (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Constant Field Values (jndn-management 0.9.7 API)";
+        parent.document.title="Constant Field Values (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/deprecated-list.html b/deprecated-list.html
index 6b45348..9a78111 100644
--- a/deprecated-list.html
+++ b/deprecated-list.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:42 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Deprecated List (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Deprecated List (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Deprecated List (jndn-management 0.9.7 API)";
+        parent.document.title="Deprecated List (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/help-doc.html b/help-doc.html
index c89a806..ee09a96 100644
--- a/help-doc.html
+++ b/help-doc.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:42 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>API Help (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>API Help (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="API Help (jndn-management 0.9.7 API)";
+        parent.document.title="API Help (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/index-all.html b/index-all.html
index ec940e6..fd7da04 100644
--- a/index-all.html
+++ b/index-all.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Index (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Index (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="./stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Index (jndn-management 0.9.7 API)";
+        parent.document.title="Index (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
@@ -287,6 +287,10 @@
 <dd>
 <div class="block">Get number of received Interest packets</div>
 </dd>
+<dt><span class="strong"><a href="./com/intel/jndn/management/NFD.html#getKeyLocator(net.named_data.jndn.Face)">getKeyLocator(Face)</a></span> - Static method in class com.intel.jndn.management.<a href="./com/intel/jndn/management/NFD.html" title="class in com.intel.jndn.management">NFD</a></dt>
+<dd>
+<div class="block">Retrieve the <code>KeyLocator</code> for an NFD.</div>
+</dd>
 <dt><span class="strong"><a href="./com/intel/jndn/management/types/FaceStatus.html#getLinkType()">getLinkType()</a></span> - Method in class com.intel.jndn.management.types.<a href="./com/intel/jndn/management/types/FaceStatus.html" title="class in com.intel.jndn.management.types">FaceStatus</a></dt>
 <dd>
 <div class="block">Get link type</div>
diff --git a/index.html b/index.html
index 87bf372..dedc7e9 100644
--- a/index.html
+++ b/index.html
@@ -2,9 +2,9 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc on Wed Mar 25 12:53:42 PDT 2015 -->
+<!-- Generated by javadoc on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>jndn-management 0.9.7 API</title>
+<title>jndn-management 0.9.8 API</title>
 <script type="text/javascript">
     targetPage = "" + window.location.search;
     if (targetPage != "" && targetPage != "undefined")
diff --git a/overview-frame.html b/overview-frame.html
index 05b03a4..3db2c29 100644
--- a/overview-frame.html
+++ b/overview-frame.html
@@ -2,10 +2,10 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Overview List (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Overview List (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
diff --git a/overview-summary.html b/overview-summary.html
index 3e2a83b..caee68c 100644
--- a/overview-summary.html
+++ b/overview-summary.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:42 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Overview (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Overview (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Overview (jndn-management 0.9.7 API)";
+        parent.document.title="Overview (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
@@ -64,7 +64,7 @@
 </a></div>
 <!-- ========= END OF TOP NAVBAR ========= -->
 <div class="header">
-<h1 class="title">jndn-management 0.9.7 API</h1>
+<h1 class="title">jndn-management 0.9.8 API</h1>
 </div>
 <div class="contentContainer">
 <table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Packages table, listing packages, and an explanation">
diff --git a/overview-tree.html b/overview-tree.html
index c0e0ef0..0051e8f 100644
--- a/overview-tree.html
+++ b/overview-tree.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Class Hierarchy (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Class Hierarchy (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Class Hierarchy (jndn-management 0.9.7 API)";
+        parent.document.title="Class Hierarchy (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
diff --git a/serialized-form.html b/serialized-form.html
index 6317284..3aff1aa 100644
--- a/serialized-form.html
+++ b/serialized-form.html
@@ -2,16 +2,16 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (version 1.7.0_51) on Wed Mar 25 12:53:41 PDT 2015 -->
+<!-- Generated by javadoc (version 1.7.0_51) on Mon Apr 13 09:43:53 PDT 2015 -->
 <meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
-<title>Serialized Form (jndn-management 0.9.7 API)</title>
-<meta name="date" content="2015-03-25">
+<title>Serialized Form (jndn-management 0.9.8 API)</title>
+<meta name="date" content="2015-04-13">
 <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
 </head>
 <body>
 <script type="text/javascript"><!--
     if (location.href.indexOf('is-external=true') == -1) {
-        parent.document.title="Serialized Form (jndn-management 0.9.7 API)";
+        parent.document.title="Serialized Form (jndn-management 0.9.8 API)";
     }
 //-->
 </script>
