interest.hpp

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

#include "name.hpp"
#include "link.hpp"
#include "key-locator.hpp"
#include "lite/interest-lite.hpp"
#include "encoding/wire-format.hpp"
#include "util/signed-blob.hpp"
#include "util/change-counter.hpp"
#include "exclude.hpp"
#include "delegation-set.hpp"

namespace ndn {

class LpPacket;
class Data;

class Interest {
public:
  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_),
    keyLocator_(interest.keyLocator_), exclude_(interest.exclude_),
    childSelector_(interest.childSelector_),
    mustBeFresh_(interest.mustBeFresh_),
    interestLifetimeMilliseconds_(interest.interestLifetimeMilliseconds_),
    nonce_(interest.nonce_), getNonceChangeCount_(0),
    forwardingHint_(interest.forwardingHint_),
    linkWireEncoding_(interest.linkWireEncoding_),
    linkWireEncodingFormat_(interest.linkWireEncodingFormat_),
    selectedDelegationIndex_(interest.selectedDelegationIndex_),
    changeCount_(0)
  {
    if (interest.link_.get())
      link_.set(ptr_lib::make_shared<Link>(*interest.link_.get()));

    setDefaultWireEncoding
      (interest.getDefaultWireEncoding(), 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(InterestLite& interestLite, WireFormat& wireFormat) const;

  void
  set(const InterestLite& interestLite, WireFormat& wireFormat);

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

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

  int
  getMinSuffixComponents() const { return minSuffixComponents_; }

  int
  getMaxSuffixComponents() const { return maxSuffixComponents_; }

  bool
  getCanBePrefix() const
  {
    // Use the closest v0.2 semantics. CanBePrefix is the opposite of exact
    // match where MaxSuffixComponents is 1 (for the implicit digest).
    return maxSuffixComponents_ != 1;
  }

  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_; }

  bool
  getMustBeFresh() const { return mustBeFresh_; }

  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_;
  }

  DelegationSet&
  getForwardingHint() { return forwardingHint_.get(); }

  const DelegationSet&
  getForwardingHint() const { return forwardingHint_.get(); }

  bool
  DEPRECATED_IN_NDN_CPP hasLink() const
  {
    return link_.get() || !linkWireEncoding_.isNull();
  }


  Link*
  DEPRECATED_IN_NDN_CPP getLink();

  const Link*
  DEPRECATED_IN_NDN_CPP getLink() const { return const_cast<Interest*>(this)->getLink(); }

  Blob
  DEPRECATED_IN_NDN_CPP getLinkWireEncoding
    (WireFormat& wireFormat = *WireFormat::getDefaultWireFormat()) const;

  int
  DEPRECATED_IN_NDN_CPP getSelectedDelegationIndex() const { return selectedDelegationIndex_; }

  uint64_t
  getIncomingFaceId() const;

  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&
  setCanBePrefix(int canBePrefix)
  {
    // Use the closest v0.2 semantics. CanBePrefix is the opposite of exact
    // match where MaxSuffixComponents is 1 (for the implicit digest).
    maxSuffixComponents_ = (canBePrefix ? -1 : 1);
    ++changeCount_;
    return *this;
  }

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

  Interest&
  setMustBeFresh(bool mustBeFresh)
  {
    mustBeFresh_ = mustBeFresh;
    ++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;
  }

  Interest&
  setForwardingHint(const DelegationSet& forwardingHint)
  {
    forwardingHint_ = forwardingHint;
    ++changeCount_;
    return *this;
  }

  Interest&
  DEPRECATED_IN_NDN_CPP setLinkWireEncoding
    (Blob encoding,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    linkWireEncoding_ = encoding;
    linkWireEncodingFormat_ = &wireFormat;

    // Clear the link object, assuming that it has a different encoding.
    link_.set(ptr_lib::shared_ptr<Link>());

    ++changeCount_;
    return *this;
  }

  Interest&
  DEPRECATED_IN_NDN_CPP unsetLink()
  {
    WireFormat* wireFormat = 0;
    return setLinkWireEncoding(Blob(), *wireFormat);
  }

  Interest&
  DEPRECATED_IN_NDN_CPP setSelectedDelegationIndex(int selectedDelegationIndex)
  {
    selectedDelegationIndex_ = selectedDelegationIndex;
    ++changeCount_;
    return *this;
  }

  Interest&
  setLpPacket(const ptr_lib::shared_ptr<LpPacket>& lpPacket)
  {
    lpPacket_ = lpPacket;
    // Don't update changeCount_ since this doesn't affect the wire encoding.
    return *this;
  }

  void
  refreshNonce();

  bool
  matchesName(const Name& name) const;

  bool
  matchesData
    (const Data& data,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat()) 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 = keyLocator_.checkChanged() || changed;
    changed = exclude_.checkChanged() || changed;
    changed = forwardingHint_.checkChanged() || changed;
    changed = link_.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;
    mustBeFresh_ = true;
    interestLifetimeMilliseconds_ = -1.0;
    linkWireEncodingFormat_ = 0;
    selectedDelegationIndex_ = -1;
  }

  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<KeyLocator> keyLocator_;
  ChangeCounter<Exclude> exclude_;
  int childSelector_;       
  bool mustBeFresh_;
  Milliseconds interestLifetimeMilliseconds_; 
  Blob nonce_;
  uint64_t getNonceChangeCount_;
  ChangeCounter<DelegationSet> forwardingHint_;
  Blob linkWireEncoding_;
  WireFormat* linkWireEncodingFormat_;
  SharedPointerChangeCounter<Link> link_;
  int selectedDelegationIndex_; 
  SignedBlob defaultWireEncoding_;
  WireFormat *defaultWireEncodingFormat_;
  uint64_t getDefaultWireEncodingChangeCount_;
  ptr_lib::shared_ptr<LpPacket> lpPacket_;
  uint64_t changeCount_;
};

}

#endif