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), value_((const uint8_t*)0, 0)
    {
    }

    Component(const std::vector<uint8_t>& value)
    : type_(ndn_NameComponentType_GENERIC), value_(value)
    {
    }

    Component(const uint8_t *value, size_t valueLength)
    : type_(ndn_NameComponentType_GENERIC), value_(value, valueLength)
    {
    }

    Component(const char* value)
    : type_(ndn_NameComponentType_GENERIC), value_((const uint8_t*)value, ::strlen(value))
    {
    }

    Component(const std::string& value)
    : type_(ndn_NameComponentType_GENERIC),
      value_((const uint8_t*)&value[0], value.size())
    {
    }

    Component(const Blob &value)
    : type_(ndn_NameComponentType_GENERIC), value_(value)
    {
    }

    Component(const NameLite::Component &componentLite)
    : type_(componentLite.isImplicitSha256Digest() ?
        ndn_NameComponentType_IMPLICIT_SHA256_DIGEST : ndn_NameComponentType_GENERIC),
      value_(componentLite.getValue())
    {
    }

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

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

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

    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);

    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 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
    {
      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:
    static const uint8_t FINAL_SEGMENT_PREFIX[];
    static size_t FINAL_SEGMENT_PREFIX_LENGTH;

    // Note: We keep the type_ internal because it is only used to distinguish
    // from ImplicitSha256Digest. If we support general typed components then
    // we can provide public access.
    ndn_NameComponentType type_;
    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)
  {
    return append(Component(value, valueLength));
  }

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

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

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

  Name&
  append(const char* value)
  {
    return append(Component(value));
  }

  Name&
  append(const std::string& value)
  {
    return append(Component(value));
  }

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

  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:
  std::vector<Component> components_;
  uint64_t changeCount_;
};

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

}

#endif