name.hpp

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

#include <vector>
#include <string>
#include <string.h>
#include <sstream>
#include "util/blob.hpp"
#include "encoding/wire-format.hpp"
#include "lite/name-lite.hpp"

namespace ndn {

class Name {
public:
  class Component {
  public:
    Component()
    : type_(ndn_NameComponentType_GENERIC),
      otherTypeCode_(-1),
      value_((const uint8_t*)0, 0)
    {
    }

    Component
      (const std::vector<uint8_t>& value,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1)
    : value_(value)
    {
      setType(type, otherTypeCode);
    }

    Component
      (const uint8_t *value, size_t valueLength,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1)
    : value_(value, valueLength)
    {
      setType(type, otherTypeCode);
    }

    Component
      (const char* value,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1)
    : value_((const uint8_t*)value, ::strlen(value))
    {
      setType(type, otherTypeCode);
    }

    Component
      (const std::string& value,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1)
    : value_((const uint8_t*)&value[0], value.size())
    {
      setType(type, otherTypeCode);
    }

    Component
      (const Blob &value,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1)
    : value_(value)
    {
      setType(type, otherTypeCode);
    }

    Component(const NameLite::Component &componentLite)
    : type_(componentLite.getType()),
      otherTypeCode_(componentLite.getOtherTypeCode()),
      value_(componentLite.getValue())
    {
    }

    void
    get(NameLite::Component& componentLite) const;

    const Blob&
    getValue() const { return value_; }

    ndn_NameComponentType
    getType() const { return type_; }

    int
    getOtherTypeCode() const { return otherTypeCode_; }

    void
    toEscapedString(std::ostringstream& result) const;

    std::string
    toEscapedString() const;

    bool
    isSegment() const
    {
      return value_.size() >= 1 && value_.buf()[0] == 0x00 &&
             type_ == ndn_NameComponentType_GENERIC;
    }

    bool
    isSegmentOffset() const
    {
      return value_.size() >= 1 && value_.buf()[0] == 0xFB &&
             type_ == ndn_NameComponentType_GENERIC;
    }

    bool
    isVersion() const
    {
      return value_.size() >= 1 && value_.buf()[0] == 0xFD &&
             type_ == ndn_NameComponentType_GENERIC;
    }

    bool
    isTimestamp() const
    {
      return value_.size() >= 1 && value_.buf()[0] == 0xFC &&
             type_ == ndn_NameComponentType_GENERIC;
    }

    bool
    isSequenceNumber() const
    {
      return value_.size() >= 1 && value_.buf()[0] == 0xFE &&
             type_ == ndn_NameComponentType_GENERIC;
    }

    bool
    isGeneric() const
    {
      return type_ == ndn_NameComponentType_GENERIC;
    }

    bool
    isImplicitSha256Digest() const
    {
      return type_ == ndn_NameComponentType_IMPLICIT_SHA256_DIGEST;
    }

    bool
    isParametersSha256Digest() const
    {
      return type_ == ndn_NameComponentType_PARAMETERS_SHA256_DIGEST;
    }

    uint64_t
    toNumber() const;

    uint64_t
    toNumberWithMarker(uint8_t marker) const;

    uint64_t
    toNumberWithPrefix(const uint8_t* prefix, size_t prefixLength) const;

    bool
    hasPrefix(const uint8_t* prefix, size_t prefixLength) const;

    uint64_t
    toSegment() const
    {
      return toNumberWithMarker(0x00);
    }

    uint64_t
    toSegmentOffset() const
    {
      return toNumberWithMarker(0xFB);
    }

    uint64_t
    DEPRECATED_IN_NDN_CPP toSeqNum() const
    {
      return toSegment();
    }

    bool
    DEPRECATED_IN_NDN_CPP isFinalSegment() const { return hasPrefix(getFinalSegmentPrefix(), getFinalSegmentPrefixLength()); }

    uint64_t
    DEPRECATED_IN_NDN_CPP toFinalSegment() const
    {
      return toNumberWithPrefix(getFinalSegmentPrefix(), getFinalSegmentPrefixLength());
    }

    uint64_t
    toVersion() const
    {
      return toNumberWithMarker(0xFD);
    }

    uint64_t
    toTimestamp() const
    {
      return toNumberWithMarker(0xFC);
    }

    uint64_t
    toSequenceNumber() const
    {
      return toNumberWithMarker(0xFE);
    }

    static Component
    fromNumber
      (uint64_t number,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1);

    static Component
    fromNumberWithMarker(uint64_t number, uint8_t marker);

    static Component
    fromNumberWithPrefix(uint64_t number, const uint8_t* prefix, size_t prefixLength);

    static Component
    fromSegment(uint64_t segment)
    {
      return fromNumberWithMarker(segment, 0x00);
    }

    static Component
    fromSegmentOffset(uint64_t segmentOffset)
    {
      return fromNumberWithMarker(segmentOffset, 0xFB);
    }

    static Component
    fromVersion(uint64_t version)
    {
      return fromNumberWithMarker(version, 0xFD);
    }

    static Component
    fromTimestamp(uint64_t timestamp)
    {
      return fromNumberWithMarker(timestamp, 0xFC);
    }

    static Component
    fromSequenceNumber(uint64_t sequenceNumber)
    {
      return fromNumberWithMarker(sequenceNumber, 0xFE);
    }

    static Component
    fromImplicitSha256Digest(const Blob& digest);

    static Component
    fromImplicitSha256Digest(const uint8_t *digest, size_t digestLength)
    {
      return fromImplicitSha256Digest(Blob(digest, digestLength));
    }

    static Component
    fromImplicitSha256Digest(const std::vector<uint8_t>& digest)
    {
      return fromImplicitSha256Digest(Blob(digest));
    }

    static Component
    fromParametersSha256Digest(const Blob& digest);

    static Component
    fromParametersSha256Digest(const uint8_t *digest, size_t digestLength)
    {
      return fromParametersSha256Digest(Blob(digest, digestLength));
    }

    static Component
    fromParametersSha256Digest(const std::vector<uint8_t>& digest)
    {
      return fromParametersSha256Digest(Blob(digest));
    }

    static const uint8_t*
    getFinalSegmentPrefix() { return FINAL_SEGMENT_PREFIX; }

    static size_t
    getFinalSegmentPrefixLength() { return FINAL_SEGMENT_PREFIX_LENGTH; }

    Component
    getSuccessor() const;

    bool
    equals(const Component& other) const
    {
      if (type_ == ndn_NameComponentType_OTHER_CODE)
        return  *value_ == *other.value_ &&
          other.type_ == ndn_NameComponentType_OTHER_CODE &&
          otherTypeCode_ == other.otherTypeCode_;
      else
        return *value_ == *other.value_ && type_ == other.type_;
    }

    bool
    operator == (const Component& other) const { return equals(other); }

    bool
    operator != (const Component& other) const { return !equals(other); }

    int
    compare(const Component& other) const;

    bool
    operator <= (const Component& other) const { return compare(other) <= 0; }

    bool
    operator < (const Component& other) const { return compare(other) < 0; }

    bool
    operator >= (const Component& other) const { return compare(other) >= 0; }

    bool
    operator > (const Component& other) const { return compare(other) > 0; }

  private:
    void
    setType(ndn_NameComponentType type, int otherTypeCode);

    static const uint8_t FINAL_SEGMENT_PREFIX[];
    static size_t FINAL_SEGMENT_PREFIX_LENGTH;

    ndn_NameComponentType type_;
    int otherTypeCode_;
    Blob value_;
  };

  Name()
  : changeCount_(0)
  {
  }

  Name(const std::vector<Component>& components)
  : components_(components), changeCount_(0)
  {
  }

  Name(const char* uri)
  : changeCount_(0)
  {
    set(uri);
  }

  Name(const std::string& uri)
  : changeCount_(0)
  {
    set(uri.c_str());
  }

  void
  get(NameLite& nameLite) const;

  void
  set(const NameLite& nameLite);

  void
  set(const char *uri);

  void
  set(const std::string& uri) { set(uri.c_str()); }

  Name&
  append
    (const uint8_t *value, size_t valueLength,
     ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
     int otherTypeCode = -1)
  {
    if (type == ndn_NameComponentType_OTHER_CODE)
      checkAppendOtherTypeCode(otherTypeCode);

    return append(Component(value, valueLength, type, otherTypeCode));
  }

  Name&
  append
    (const std::vector<uint8_t>& value,
     ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
     int otherTypeCode = -1)
  {
    if (type == ndn_NameComponentType_OTHER_CODE)
      checkAppendOtherTypeCode(otherTypeCode);

    return append(Component(value, type, otherTypeCode));
  }

  Name&
  append
    (const Blob &value,
     ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
     int otherTypeCode = -1)
  {
    if (type == ndn_NameComponentType_OTHER_CODE)
      checkAppendOtherTypeCode(otherTypeCode);

    return append(Component(value, type, otherTypeCode));
  }

  Name&
  append(const Component &value)
  {
    components_.push_back(value);
    ++changeCount_;
    return *this;
  }

  Name&
  append
    (const char* value,
     ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
     int otherTypeCode = -1)
  {
    if (type == ndn_NameComponentType_OTHER_CODE)
      checkAppendOtherTypeCode(otherTypeCode);

    return append(Component(value, type, otherTypeCode));
  }

  Name&
  append
    (const std::string& value,
     ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
     int otherTypeCode = -1)
  {
    if (type == ndn_NameComponentType_OTHER_CODE)
      checkAppendOtherTypeCode(otherTypeCode);

    return append(Component(value, type, otherTypeCode));
  }

  Name&
  append(const Name& name);

  Name&
  DEPRECATED_IN_NDN_CPP appendComponent(const uint8_t *value, size_t valueLength)
  {
    return append(value, valueLength);
  }

  Name&
  DEPRECATED_IN_NDN_CPP appendComponent(const std::vector<uint8_t>& value)
  {
    return append(value);
  }

  Name&
  DEPRECATED_IN_NDN_CPP appendComponent(const Blob &value)
  {
    return append(value);
  }

  Name&
  DEPRECATED_IN_NDN_CPP addComponent(const uint8_t *value, size_t valueLength)
  {
    return append(value, valueLength);
  }

  Name&
  DEPRECATED_IN_NDN_CPP addComponent(const std::vector<uint8_t>& value)
  {
    return append(value);
  }

  Name&
  DEPRECATED_IN_NDN_CPP addComponent(const Blob &value)
  {
    return append(value);
  }

  void
  clear() {
    components_.clear();
    ++changeCount_;
  }

  size_t
  DEPRECATED_IN_NDN_CPP getComponentCount() const { return size(); }

  const Component&
  DEPRECATED_IN_NDN_CPP getComponent(size_t i) const { return get(i); }

  Name
  getSubName(int iStartComponent, size_t nComponents) const;

  Name
  getSubName(int iStartComponent) const
  {
    return getSubName(iStartComponent, components_.size());
  }

  Name
  getPrefix(int nComponents) const
  {
    if (nComponents < 0)
      return getSubName(0, components_.size() + nComponents);
    else
      return getSubName(0, nComponents);
  }

  std::string
  toUri(bool includeScheme = false) const;

  std::string
  DEPRECATED_IN_NDN_CPP to_uri() const
  {
    return toUri();
  }

  Name&
  appendSegment(uint64_t segment)
  {
    return append(Component::fromSegment(segment));
  }

  Name&
  appendSegmentOffset(uint64_t segmentOffset)
  {
    return append(Component::fromSegmentOffset(segmentOffset));
  }

  Name&
  DEPRECATED_IN_NDN_CPP appendFinalSegment(uint64_t segment)
  {
    return append(Component::fromNumberWithPrefix
      (segment, Component::getFinalSegmentPrefix(), Component::getFinalSegmentPrefixLength()));
  }

  Name&
  appendVersion(uint64_t version)
  {
    return append(Component::fromVersion(version));
  }

  Name&
  appendTimestamp(uint64_t timestamp)
  {
    return append(Component::fromTimestamp(timestamp));
  }

  Name&
  appendSequenceNumber(uint64_t sequenceNumber)
  {
    return append(Component::fromSequenceNumber(sequenceNumber));
  }

  Name&
  appendImplicitSha256Digest(const Blob& digest)
  {
    return append(Component::fromImplicitSha256Digest(digest));
  }

  Name&
  appendImplicitSha256Digest(const uint8_t *digest, size_t digestLength)
  {
    return append(Component::fromImplicitSha256Digest(digest, digestLength));
  }

  Name&
  appendImplicitSha256Digest(const std::vector<uint8_t>& digest)
  {
    return append(Component::fromImplicitSha256Digest(digest));
  }

  Name&
  appendParametersSha256Digest(const Blob& digest)
  {
    return append(Component::fromParametersSha256Digest(digest));
  }

  Name&
  appendParametersSha256Digest(const uint8_t *digest, size_t digestLength)
  {
    return append(Component::fromParametersSha256Digest(digest, digestLength));
  }

  Name&
  appendParametersSha256Digest(const std::vector<uint8_t>& digest)
  {
    return append(Component::fromParametersSha256Digest(digest));
  }

  bool
  equals(const Name& name) const;

  Name
  getSuccessor() const;

  bool
  match(const Name& name) const;

  bool
  isPrefixOf(const Name& name) const { return match(name); }

  static Blob
  fromEscapedString(const char *escapedString, size_t beginOffset, size_t endOffset);

  static Blob
  fromEscapedString(const char *escapedString);

  static Blob
  fromEscapedString(const std::string& escapedString) { return fromEscapedString(escapedString.c_str()); }

  static void
  toEscapedString(const std::vector<uint8_t>& value, std::ostringstream& result);

  static std::string
  toEscapedString(const std::vector<uint8_t>& value);

  //
  // vector equivalent interface.
  //

  size_t
  size() const { return components_.size(); }

  Blob
  wireEncode(WireFormat& wireFormat = *WireFormat::getDefaultWireFormat()) const
  {
    return wireFormat.encodeName(*this);
  }

  void
  wireDecode
    (const uint8_t *input, size_t inputLength,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    wireFormat.decodeName(*this, input, inputLength);
  }

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

  void
  wireDecode
    (const Blob& input,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    wireDecode(input.buf(), input.size(), wireFormat);
  }

  const Component&
  get(int i) const;

  uint64_t
  getChangeCount() const { return changeCount_; }

  int
  compare(const Name& other) const
  {
    return compare(0, components_.size(), other);
  }

  int
  compare
    (int iStartComponent, size_t nComponents, const Name& other,
     int iOtherStartComponent, size_t nOtherComponents) const;


  int
  compare
    (int iStartComponent, size_t nComponents, const Name& other,
     int iOtherStartComponent = 0) const
  {
    return compare
      (iStartComponent, nComponents, other, iOtherStartComponent,
       other.components_.size());
  }

  const Component&
  operator [] (int i) const
  {
    return get(i);
  }

  template<class T> void
  push_back(const T &component)
  {
    append(component);
  }

  bool
  operator == (const Name &name) const { return equals(name); }

  bool
  operator != (const Name &name) const { return !equals(name); }

  bool
  operator <= (const Name& other) const { return compare(other) <= 0; }

  bool
  operator < (const Name& other) const { return compare(other) < 0; }

  bool
  operator >= (const Name& other) const { return compare(other) >= 0; }

  bool
  operator > (const Name& other) const { return compare(other) > 0; }

  static bool
  DEPRECATED_IN_NDN_CPP breadthFirstLess(const Name& name1, const Name& name2) { return name1 < name2; }

  struct BreadthFirstLess {
    bool operator() (const Name& name1, const Name& name2) const { return name1 < name2; }
  };

  //
  // Iterator interface to name components.
  //
  typedef std::vector<Component>::const_iterator const_iterator;
  typedef std::vector<Component>::const_reverse_iterator const_reverse_iterator;

  typedef Component partial_type;

  const_iterator
  begin() const { return components_.begin(); }

  const_iterator
  end() const { return components_.end(); }

  const_reverse_iterator
  rbegin() const { return components_.rbegin(); }

  const_reverse_iterator
  rend() const { return components_.rend(); }

private:
  void
  checkAppendOtherTypeCode(int otherTypeCode);

  std::vector<Component> components_;
  uint64_t changeCount_;
};

inline std::ostream&
operator << (std::ostream& os, const Name& name)
{
  os << name.toUri();
  return os;
}

}

#endif