Major code style change to rename all files to lower case.
diff --git a/ndn-cpp/name.cpp b/ndn-cpp/name.cpp
new file mode 100644
index 0000000..4996c92
--- /dev/null
+++ b/ndn-cpp/name.cpp
@@ -0,0 +1,260 @@
+/**
+ * @author: Jeff Thompson
+ * See COPYING for copyright and distribution information.
+ */
+
+#include <stdexcept>
+#include <sstream>
+#include "name.hpp"
+
+using namespace std;
+
+namespace ndn {
+
+/**
+ * Write the value to result, escaping characters according to the NDN URI Scheme.
+ * This also adds "..." to a value with zero or more ".".
+ * @param value the buffer with the value to escape
+ * @param result the string stream to write to.
+ */
+static void toEscapedString(const vector<unsigned char> &value, ostringstream &result)
+{
+ bool gotNonDot = false;
+ for (unsigned i = 0; i < value.size(); ++i) {
+ if (value[i] != 0x2e) {
+ gotNonDot = true;
+ break;
+ }
+ }
+ if (!gotNonDot) {
+ // Special case for component of zero or more periods. Add 3 periods.
+ result << "...";
+ for (unsigned int i = 0; i < value.size(); ++i)
+ result << '.';
+ }
+ else {
+ // In case we need to escape, set to upper case hex and save the previous flags.
+ ios::fmtflags saveFlags = result.flags(ios::hex | ios::uppercase);
+
+ for (unsigned int i = 0; i < value.size(); ++i) {
+ unsigned char x = value[i];
+ // Check for 0-9, A-Z, a-z, (+), (-), (.), (_)
+ if (x >= 0x30 && x <= 0x39 || x >= 0x41 && x <= 0x5a ||
+ x >= 0x61 && x <= 0x7a || x == 0x2b || x == 0x2d ||
+ x == 0x2e || x == 0x5f)
+ result << x;
+ else {
+ result << '%';
+ if (x < 16)
+ result << '0';
+ result << (unsigned int)x;
+ }
+ }
+
+ // Restore.
+ result.flags(saveFlags);
+ }
+}
+
+static const char *WHITESPACE_CHARS = " \n\r\t";
+
+/**
+ * Modify str in place to erase whitespace on the left.
+ * @param str
+ */
+static inline void trimLeft(string &str)
+{
+ size_t found = str.find_first_not_of(WHITESPACE_CHARS);
+ if (found != string::npos) {
+ if (found > 0)
+ str.erase(0, found);
+ }
+ else
+ // All whitespace
+ str.clear();
+}
+
+/**
+ * Modify str in place to erase whitespace on the right.
+ * @param str
+ */
+static inline void trimRight(string &str)
+{
+ size_t found = str.find_last_not_of(WHITESPACE_CHARS);
+ if (found != string::npos) {
+ if (found + 1 < str.size())
+ str.erase(found + 1);
+ }
+ else
+ // All whitespace
+ str.clear();
+}
+
+/**
+ * Modify str in place to erase whitespace on the left and right.
+ * @param str
+ */
+static void trim(string &str)
+{
+ trimLeft(str);
+ trimRight(str);
+}
+
+/**
+ * Convert the hex character to an integer from 0 to 15, or -1 if not a hex character.
+ * @param c
+ * @return
+ */
+static int fromHexChar(unsigned char c)
+{
+ if (c >= '0' && c <= '9')
+ return (int)c - (int)'0';
+ else if (c >= 'A' && c <= 'F')
+ return (int)c - (int)'A' + 10;
+ else if (c >= 'a' && c <= 'f')
+ return (int)c - (int)'a' + 10;
+ else
+ return -1;
+}
+
+/**
+ * Return a copy of str, converting each escaped "%XX" to the char value.
+ * @param str
+ */
+static string unescape(const string &str)
+{
+ ostringstream result;
+
+ for (unsigned int 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 << (unsigned char)(16 * hi + lo);
+
+ // Skip ahead past the escaped value.
+ i += 2;
+ }
+ else
+ // Just copy through.
+ result << str[i];
+ }
+
+ return result.str();
+}
+
+bool Name::Component::setFromEscapedString(const char *first, const char *last)
+{
+ string trimmedString(first, last);
+ trim(trimmedString);
+ string component = unescape(trimmedString);
+
+ if (component.find_first_not_of(".") == string::npos) {
+ // Special case for component of only periods.
+ if (component.size() <= 2)
+ // Zero, one or two periods is illegal. Ignore this component.
+ return false;
+ else {
+ // Remove 3 periods.
+ value_.clear();
+ value_.insert(value_.begin(), component.begin() + 3, component.end());
+ }
+ }
+ else {
+ value_.clear();
+ value_.insert(value_.begin(), component.begin(), component.end());
+ }
+
+ return true;
+}
+
+Name::Name(const char *uri_cstr)
+{
+ string uri = uri_cstr;
+ trim(uri);
+ if (uri.size() == 0)
+ return;
+
+ size_t iColon = uri.find(':');
+ if (iColon != string::npos) {
+ // Make sure the colon came before a '/'.
+ size_t iFirstSlash = uri.find('/');
+ if (iFirstSlash == string::npos || iColon < iFirstSlash) {
+ // Omit the leading protocol such as ndn:
+ uri.erase(0, iColon + 1);
+ trim(uri);
+ }
+ }
+
+ // Trim the leading slash and possibly the authority.
+ if (uri[0] == '/') {
+ if (uri.size() >= 2 && uri[1] == '/') {
+ // Strip the authority following "//".
+ size_t iAfterAuthority = uri.find('/', 2);
+ if (iAfterAuthority == string::npos)
+ // Unusual case: there was only an authority.
+ return;
+ else {
+ uri.erase(0, iAfterAuthority + 1);
+ trim(uri);
+ }
+ }
+ else {
+ uri.erase(0, 1);
+ trim(uri);
+ }
+ }
+
+ size_t iComponentStart = 0;
+
+ // Unescape the components.
+ while (iComponentStart < uri.size()) {
+ size_t iComponentEnd = uri.find("/", iComponentStart);
+ if (iComponentEnd == string::npos)
+ iComponentEnd = uri.size();
+
+ components_.push_back(Component());
+ if (!components_[components_.size() - 1].setFromEscapedString(&uri[iComponentStart], &uri[iComponentEnd]))
+ // Ignore the illegal component. This also gets rid of a trailing '/'.
+ components_.pop_back();
+
+ iComponentStart = iComponentEnd + 1;
+ }
+}
+
+void Name::get(struct ndn_Name &nameStruct) const
+{
+ if (nameStruct.maxComponents < components_.size())
+ throw runtime_error("nameStruct.maxComponents must be >= this name getNComponents()");
+
+ nameStruct.nComponents = components_.size();
+ for (unsigned int i = 0; i < nameStruct.nComponents; ++i)
+ components_[i].get(nameStruct.components[i]);
+}
+
+void Name::set(const struct ndn_Name &nameStruct)
+{
+ clear();
+ for (unsigned int i = 0; i < nameStruct.nComponents; ++i)
+ addComponent(nameStruct.components[i].value, nameStruct.components[i].valueLength);
+}
+
+std::string Name::to_uri() const
+{
+ if (components_.size() == 0)
+ return "/";
+
+ ostringstream result;
+ for (unsigned int i = 0; i < components_.size(); ++i) {
+ result << "/";
+ toEscapedString(components_[i].getValue(), result);
+ }
+
+ return result.str();
+}
+
+}