Major code style change to rename all files to lower case.
diff --git a/ndn-cpp/interest.hpp b/ndn-cpp/interest.hpp
new file mode 100644
index 0000000..ddc6fce
--- /dev/null
+++ b/ndn-cpp/interest.hpp
@@ -0,0 +1,243 @@
+/**
+ * @author: Jeff Thompson
+ * See COPYING for copyright and distribution information.
+ */
+
+#ifndef NDN_INTEREST_HPP
+#define NDN_INTEREST_HPP
+
+#include "name.hpp"
+#include "publisher-public-key-digest.hpp"
+#include "c/interest.h"
+
+namespace ndn {
+
+/**
+ * An ExcludeEntry holds an ndn_ExcludeType, and if it is a COMPONENT, it holds the component value.
+ */
+class ExcludeEntry {
+public:
+ /**
+ * Create an ExcludeEntry of type ndn_Exclude_ANY
+ */
+ ExcludeEntry()
+ : type_(ndn_Exclude_ANY)
+ {
+ }
+
+ /**
+ * Create an ExcludeEntry of type ndn_Exclude_COMPONENT
+ */
+ ExcludeEntry(unsigned char *component, unsigned int componentLen)
+ : type_(ndn_Exclude_COMPONENT), component_(component, component + componentLen)
+ {
+ }
+
+ /**
+ * Set the type in the excludeEntryStruct and to point to this component, without copying any memory.
+ * WARNING: The resulting pointer in excludeEntryStruct is invalid after a further use of this object which could reallocate memory.
+ * @param excludeEntryStruct the C ndn_NameComponent struct to receive the pointer
+ */
+ void get(struct ndn_ExcludeEntry &excludeEntryStruct) const
+ {
+ excludeEntryStruct.type = type_;
+ if (type_ == ndn_Exclude_COMPONENT) {
+ excludeEntryStruct.componentLength = component_.size();
+ excludeEntryStruct.component = (unsigned char *)&component_[0];
+ }
+ }
+
+ ndn_ExcludeType getType() const { return type_; }
+
+ const std::vector<unsigned char> &getComponent() const { return component_; }
+
+private:
+ ndn_ExcludeType type_;
+ std::vector<unsigned char> component_; /**< only used if type_ is ndn_Exclude_COMPONENT */
+};
+
+/**
+ * An Exclude holds a vector of ExcludeEntry.
+ */
+class Exclude {
+public:
+ /**
+ * Create a new Exclude with no entries.
+ */
+ Exclude() {
+ }
+
+ unsigned int getEntryCount() const {
+ return entries_.size();
+ }
+
+ const ExcludeEntry &getEntry(unsigned int i) const { return entries_[i]; }
+
+ /**
+ * Set the excludeStruct to point to the entries in this Exclude, without copying any memory.
+ * WARNING: The resulting pointers in excludeStruct are invalid after a further use of this object which could reallocate memory.
+ * @param excludeStruct a C ndn_Exclude struct where the entries array is already allocated
+ */
+ void get(struct ndn_Exclude &excludeStruct) const;
+
+ /**
+ * Clear this Exclude, and set the entries by copying from the ndn_Exclude struct.
+ * @param excludeStruct a C ndn_Exclude struct
+ */
+ void set(const struct ndn_Exclude &excludeStruct);
+
+ /**
+ * Add a new entry of type ndn_Exclude_ANY
+ */
+ void addAny()
+ {
+ entries_.push_back(ExcludeEntry());
+ }
+
+ /**
+ * Add a new entry of type ndn_Exclude_COMPONENT, copying from component of length compnentLength
+ */
+ void addComponent(unsigned char *component, unsigned int componentLen)
+ {
+ entries_.push_back(ExcludeEntry(component, componentLen));
+ }
+
+ /**
+ * Clear all the entries.
+ */
+ void clear() {
+ entries_.clear();
+ }
+
+private:
+ std::vector<ExcludeEntry> entries_;
+};
+
+/**
+ * An Interest holds a Name and other fields for an interest.
+ */
+class Interest {
+public:
+ Interest()
+ {
+ construct();
+ }
+
+ Interest(const Name &name)
+ : name_(name)
+ {
+ name_ = name;
+ construct();
+ }
+
+ Interest(const Name &name, int minSuffixComponents, int maxSuffixComponents,
+ const PublisherPublicKeyDigest &publisherPublicKeyDigest, const Exclude &exclude, int childSelector, int answerOriginKind,
+ int scope, double interestLifetimeMilliseconds, const std::vector<unsigned char> &nonce)
+ : name_(name), minSuffixComponents_(minSuffixComponents), maxSuffixComponents_(maxSuffixComponents),
+ publisherPublicKeyDigest_(publisherPublicKeyDigest), exclude_(exclude), childSelector_(childSelector),
+ answerOriginKind_(answerOriginKind), scope_(scope), interestLifetimeMilliseconds_(interestLifetimeMilliseconds),
+ nonce_(nonce)
+ {
+ }
+
+ ptr_lib::shared_ptr<std::vector<unsigned char> > wireEncode(WireFormat &wireFormat) const
+ {
+ return wireFormat.encodeInterest(*this);
+ }
+ ptr_lib::shared_ptr<std::vector<unsigned char> > wireEncode() const
+ {
+ return wireEncode(*WireFormat::getDefaultWireFormat());
+ }
+ void wireDecode(const unsigned char *input, unsigned int inputLength, WireFormat &wireFormat)
+ {
+ wireFormat.decodeInterest(*this, input, inputLength);
+ }
+ void wireDecode(const unsigned char *input, unsigned int inputLength)
+ {
+ wireDecode(input, inputLength, *WireFormat::getDefaultWireFormat());
+ }
+ void wireDecode(const std::vector<unsigned char> &input, WireFormat &wireFormat)
+ {
+ wireDecode(&input[0], input.size(), wireFormat);
+ }
+ void wireDecode(const std::vector<unsigned char> &input)
+ {
+ wireDecode(&input[0], input.size());
+ }
+
+ /**
+ * Set the interestStruct to point to the components in this interest, without copying any memory.
+ * WARNING: The resulting pointers in interestStruct are invalid after a further use of this object which could reallocate memory.
+ * @param interestStruct a C ndn_Interest struct where the name components array is already allocated.
+ */
+ void get(struct ndn_Interest &interestStruct) const;
+
+ Name &getName() { return name_; }
+ const Name &getName() const { return name_; }
+
+ int getMinSuffixComponents() const { return minSuffixComponents_; }
+
+ int getMaxSuffixComponents() const { return maxSuffixComponents_; }
+
+ PublisherPublicKeyDigest &getPublisherPublicKeyDigest() { return publisherPublicKeyDigest_; }
+ const PublisherPublicKeyDigest &getPublisherPublicKeyDigest() const { return publisherPublicKeyDigest_; }
+
+ Exclude &getExclude() { return exclude_; }
+ const Exclude &getExclude() const { return exclude_; }
+
+ int getChildSelector() const { return childSelector_; }
+
+ int getAnswerOriginKind() const { return answerOriginKind_; }
+
+ int getScope() const { return scope_; }
+
+ double getInterestLifetimeMilliseconds() const { return interestLifetimeMilliseconds_; }
+
+ const std::vector<unsigned char> getNonce() const { return nonce_; }
+
+ /**
+ * Clear this interest, and set the values by copying from the interest struct.
+ * @param interestStruct a C ndn_Interest struct
+ */
+ void set(const struct ndn_Interest &interestStruct);
+
+ void setMinSuffixComponents(int value) { minSuffixComponents_ = value; }
+
+ void setMaxSuffixComponents(int value) { maxSuffixComponents_ = value; }
+
+ void setChildSelector(int value) { childSelector_ = value; }
+
+ void setAnswerOriginKind(int value) { answerOriginKind_ = value; }
+
+ void setScope(int value) { scope_ = value; }
+
+ void setInterestLifetimeMilliseconds(double value) { interestLifetimeMilliseconds_ = value; }
+
+ void setNonce(const std::vector<unsigned char> &value) { nonce_ = value; }
+
+private:
+ void construct()
+ {
+ minSuffixComponents_ = -1;
+ maxSuffixComponents_ = -1;
+ childSelector_ = -1;
+ answerOriginKind_ = -1;
+ scope_ = -1;
+ interestLifetimeMilliseconds_ = -1.0;
+ }
+
+ Name name_;
+ int minSuffixComponents_;
+ int maxSuffixComponents_;
+ PublisherPublicKeyDigest publisherPublicKeyDigest_;
+ Exclude exclude_;
+ int childSelector_;
+ int answerOriginKind_;
+ int scope_;
+ double interestLifetimeMilliseconds_;
+ std::vector<unsigned char> nonce_;
+};
+
+}
+
+#endif