interest.hpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
#ifndef NDN_INTEREST_HPP
#define NDN_INTEREST_HPP

#include "name.hpp"
#include "publisher-public-key-digest.hpp"
#include "key-locator.hpp"
#include "c/interest-types.h"
#include "encoding/wire-format.hpp"
#include "util/signed-blob.hpp"
#include "util/change-counter.hpp"
#include "exclude.hpp"

struct ndn_Interest;

namespace ndn {

class Interest {
public:
  DEPRECATED_IN_NDN_CPP Interest(const Name& name, int minSuffixComponents, int maxSuffixComponents,
    const PublisherPublicKeyDigest& publisherPublicKeyDigest, const Exclude& exclude, int childSelector, int answerOriginKind,
    int scope, Milliseconds interestLifetimeMilliseconds, const Blob& nonce);

  DEPRECATED_IN_NDN_CPP Interest(const Name& name, int minSuffixComponents, int maxSuffixComponents,
    const PublisherPublicKeyDigest& publisherPublicKeyDigest, const Exclude& exclude, int childSelector, int answerOriginKind,
    int scope, Milliseconds interestLifetimeMilliseconds);

  DEPRECATED_IN_NDN_CPP Interest(const Name& name, int minSuffixComponents, int maxSuffixComponents,
    const KeyLocator& keyLocator, const Exclude& exclude, int childSelector, int answerOriginKind,
    int scope, Milliseconds interestLifetimeMilliseconds);

  Interest(const Name& name, Milliseconds interestLifetimeMilliseconds)
  : name_(name), getNonceChangeCount_(0), changeCount_(0), getDefaultWireEncodingChangeCount_(0)
  {
    construct();
    interestLifetimeMilliseconds_ = interestLifetimeMilliseconds;
  }

  Interest(const Name& name)
  : name_(name), getNonceChangeCount_(0), changeCount_(0), getDefaultWireEncodingChangeCount_(0)
  {
    construct();
  }

  Interest(const Interest& interest)
  : name_(interest.name_), minSuffixComponents_(interest.minSuffixComponents_),
    maxSuffixComponents_(interest.maxSuffixComponents_),
    publisherPublicKeyDigest_(interest.publisherPublicKeyDigest_),
    keyLocator_(interest.keyLocator_), exclude_(interest.exclude_),
    childSelector_(interest.childSelector_),
    answerOriginKind_(interest.answerOriginKind_),
    scope_(interest.scope_),
    interestLifetimeMilliseconds_(interest.interestLifetimeMilliseconds_),
    nonce_(interest.nonce_), getNonceChangeCount_(0), changeCount_(0)
  {
    setDefaultWireEncoding
      (interest.defaultWireEncoding_, interest.defaultWireEncodingFormat_);
  }

  Interest()
  : getNonceChangeCount_(0), changeCount_(0), getDefaultWireEncodingChangeCount_(0)
  {
    construct();
  }

  Interest& operator=(const Interest& interest);

  SignedBlob
  wireEncode(WireFormat& wireFormat = *WireFormat::getDefaultWireFormat()) const;

  void
  wireDecode
    (const Blob& input,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  wireDecode
    (const uint8_t *input, size_t inputLength,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  wireDecode(const std::vector<uint8_t>& input, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    wireDecode(&input[0], input.size(), wireFormat);
  }

  std::string
  toUri() const;

  void
  get(struct ndn_Interest& interestStruct) const;

  Name&
  getName() { return name_.get(); }

  const Name&
  getName() const { return name_.get(); }

  int
  getMinSuffixComponents() const { return minSuffixComponents_; }

  int
  getMaxSuffixComponents() const { return maxSuffixComponents_; }

  PublisherPublicKeyDigest&
  DEPRECATED_IN_NDN_CPP getPublisherPublicKeyDigest() { return publisherPublicKeyDigest_.get(); }

  const PublisherPublicKeyDigest&
  DEPRECATED_IN_NDN_CPP getPublisherPublicKeyDigest() const { return publisherPublicKeyDigest_.get(); }

  const KeyLocator&
  getKeyLocator() const { return keyLocator_.get(); }

  KeyLocator&
  getKeyLocator() { return keyLocator_.get(); }

  Exclude&
  getExclude() { return exclude_.get(); }

  const Exclude&
  getExclude() const { return exclude_.get(); }

  int
  getChildSelector() const { return childSelector_; }

  int
  DEPRECATED_IN_NDN_CPP getAnswerOriginKind() const;

  bool
  getMustBeFresh() const
  {
    // Imitate ndn_Interest_getMustBeFresh.
    if (answerOriginKind_ < 0)
      return true;
    else
      return (answerOriginKind_ & ndn_Interest_ANSWER_STALE) == 0;
  }

  int
  getScope() const { return scope_; }

  Milliseconds
  getInterestLifetimeMilliseconds() const { return interestLifetimeMilliseconds_; }

  const Blob&
  getNonce() const
  {
    if (getNonceChangeCount_ != getChangeCount()) {
      // The values have changed, so the existing nonce is invalidated.
      // This method can be called on a const object, but we want to be able to update the default cached value.
      const_cast<Interest*>(this)->nonce_ = Blob();
      const_cast<Interest*>(this)->getNonceChangeCount_ = getChangeCount();
    }

    return nonce_;
  }

  void
  set(const struct ndn_Interest& interestStruct);

  Interest&
  setName(const Name& name)
  {
    name_.set(name);
    ++changeCount_;
    return *this;
  }

  Interest&
  setMinSuffixComponents(int minSuffixComponents)
  {
    minSuffixComponents_ = minSuffixComponents;
    ++changeCount_;
    return *this;
  }

  Interest&
  setMaxSuffixComponents(int maxSuffixComponents)
  {
    maxSuffixComponents_ = maxSuffixComponents;
    ++changeCount_;
    return *this;
  }

  Interest&
  setChildSelector(int childSelector)
  {
    childSelector_ = childSelector;
    ++changeCount_;
    return *this;
  }

  Interest&
  DEPRECATED_IN_NDN_CPP setAnswerOriginKind(int answerOriginKind);

  Interest&
  setMustBeFresh(bool mustBeFresh)
  {
    if (answerOriginKind_ < 0) {
      // It is is already the default where MustBeFresh is true.
      if (!mustBeFresh) {
        // Set answerOriginKind_ so that getMustBeFresh returns false.
        answerOriginKind_ = ndn_Interest_ANSWER_STALE;
        ++changeCount_;
      }
    }
    else {
      if (mustBeFresh)
        // Clear the stale bit.
        answerOriginKind_ &= ~ndn_Interest_ANSWER_STALE;
      else
        // Set the stale bit.
        answerOriginKind_ |= ndn_Interest_ANSWER_STALE;
      ++changeCount_;
    }
    return *this;
  }

  Interest&
  setScope(int scope)
  {
    scope_ = scope;
    ++changeCount_;
    return *this;
  }

  Interest&
  setInterestLifetimeMilliseconds(Milliseconds interestLifetimeMilliseconds)
  {
    interestLifetimeMilliseconds_ = interestLifetimeMilliseconds;
    ++changeCount_;
    return *this;
  }

  Interest&
  DEPRECATED_IN_NDN_CPP setNonce(const Blob& nonce)
  {
    nonce_ = nonce;
    // Set getNonceChangeCount_ so that the next call to getNonce() won't clear nonce_.
    ++changeCount_;
    getNonceChangeCount_ = getChangeCount();
    return *this;
  }

  Interest&
  setKeyLocator(const KeyLocator& keyLocator)
  {
    keyLocator_ = keyLocator;
    ++changeCount_;
    return *this;
  }

  Interest&
  setExclude(const Exclude& exclude)
  {
    exclude_ = exclude;
    ++changeCount_;
    return *this;
  }

  bool
  matchesName(const Name& name) const;

  const SignedBlob&
  getDefaultWireEncoding() const
  {
    if (getDefaultWireEncodingChangeCount_ != getChangeCount()) {
      // The values have changed, so the default wire encoding is invalidated.
      // This method can be called on a const object, but we want to be able to update the default cached value.
      const_cast<Interest*>(this)->defaultWireEncoding_ = SignedBlob();
      const_cast<Interest*>(this)->defaultWireEncodingFormat_ = 0;
      const_cast<Interest*>(this)->getDefaultWireEncodingChangeCount_ = getChangeCount();
    }

    return defaultWireEncoding_;
  }

  WireFormat*
  getDefaultWireEncodingFormat() const { return defaultWireEncodingFormat_; }

  uint64_t
  getChangeCount() const
  {
    // Make sure each of the checkChanged is called.
    bool changed = name_.checkChanged();
    changed = publisherPublicKeyDigest_.checkChanged() || changed;
    changed = keyLocator_.checkChanged() || changed;
    changed = exclude_.checkChanged() || changed;
    if (changed)
      // A child object has changed, so update the change count.
      // This method can be called on a const object, but we want to be able to update the changeCount_.
      ++const_cast<Interest*>(this)->changeCount_;

    return changeCount_;
  }

private:
  void
  construct()
  {
    minSuffixComponents_ = -1;
    maxSuffixComponents_ = -1;
    childSelector_ = -1;
    answerOriginKind_ = -1;
    scope_ = -1;
    interestLifetimeMilliseconds_ = -1.0;
  }

  void
  setDefaultWireEncoding
    (const SignedBlob& defaultWireEncoding,
     WireFormat *defaultWireEncodingFormat)
  {
    defaultWireEncoding_ = defaultWireEncoding;
    defaultWireEncodingFormat_ = defaultWireEncodingFormat;
    // Set getDefaultWireEncodingChangeCount_ so that the next call to
    //   getDefaultWireEncoding() won't clear defaultWireEncoding_.
    getDefaultWireEncodingChangeCount_ = getChangeCount();
  }

  ChangeCounter<Name> name_;
  int minSuffixComponents_; 
  int maxSuffixComponents_; 
  ChangeCounter<PublisherPublicKeyDigest> publisherPublicKeyDigest_;
  ChangeCounter<KeyLocator> keyLocator_;
  ChangeCounter<Exclude> exclude_;
  int childSelector_;       
  int answerOriginKind_;    
  int scope_;               
  Milliseconds interestLifetimeMilliseconds_; 
  Blob nonce_;
  uint64_t getNonceChangeCount_;
  SignedBlob defaultWireEncoding_;
  WireFormat *defaultWireEncodingFormat_;
  uint64_t getDefaultWireEncodingChangeCount_;
  uint64_t changeCount_;
};

}

#endif