name-component.hpp

Go to the documentation of this file.

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

#include "common.hpp"
#include "encoding/block.hpp"
#include "encoding/block-helpers.hpp"
#include "util/time.hpp"

namespace ndn {
namespace name {

static const uint8_t SEGMENT_MARKER = 0x00;
static const uint8_t SEGMENT_OFFSET_MARKER = 0xFB;
static const uint8_t VERSION_MARKER = 0xFD;
static const uint8_t TIMESTAMP_MARKER = 0xFC;
static const uint8_t SEQUENCE_NUMBER_MARKER = 0xFE;

class Component : public Block
{
public:
  class Error : public Block::Error
  {
  public:
    explicit
    Error(const std::string& what)
      : Block::Error(what)
    {
    }
  };

  Component();

  Component(const Block& wire);

  explicit
  Component(const ConstBufferPtr& buffer);

  explicit
  Component(const Buffer& buffer);

  Component(const uint8_t* buffer, size_t bufferSize);

  template<class Iterator>
  Component(Iterator first, Iterator last);

  explicit
  Component(const char* str);

  explicit
  Component(const std::string& str);

  template<encoding::Tag TAG>
  size_t
  wireEncode(EncodingImpl<TAG>& encoder) const;

  const Block&
  wireEncode() const;

  void
  wireDecode(const Block& wire);

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

  static Component
  fromEscapedString(const char* escapedString)
  {
    return fromEscapedString(escapedString, 0, std::char_traits<char>::length(escapedString));
  }

  static Component
  fromEscapedString(const std::string& escapedString)
  {
    return fromEscapedString(escapedString.c_str(), 0, escapedString.size());
  }

  DEPRECATED(
  void
  toEscapedString(std::ostream& os) const)
  {
    return toUri(os);
  }

  DEPRECATED(
  std::string
  toEscapedString() const)
  {
    return toUri();
  }

  void
  toUri(std::ostream& os) const;

  std::string
  toUri() const;


  bool
  isNumber() const;

  bool
  isNumberWithMarker(uint8_t marker) const;

  bool
  isVersion() const;

  bool
  isSegment() const;

  bool
  isSegmentOffset() const;

  bool
  isTimestamp() const;

  bool
  isSequenceNumber() const;


  uint64_t
  toNumber() const;

  uint64_t
  toNumberWithMarker(uint8_t marker) const;

  uint64_t
  toVersion() const;

  uint64_t
  toSegment() const;

  uint64_t
  toSegmentOffset() const;

  time::system_clock::TimePoint
  toTimestamp() const;

  uint64_t
  toSequenceNumber() const;


  static Component
  fromNumber(uint64_t number);

  static Component
  fromNumberWithMarker(uint8_t marker, uint64_t number);

  static Component
  fromVersion(uint64_t version);

  static Component
  fromSegment(uint64_t segmentNo);

  static Component
  fromSegmentOffset(uint64_t offset);

  static Component
  fromTimestamp(const time::system_clock::TimePoint& timePoint);

  static Component
  fromSequenceNumber(uint64_t seqNo);


  bool
  isGeneric() const;

  bool
  isImplicitSha256Digest() const;

  static Component
  fromImplicitSha256Digest(const ConstBufferPtr& digest);

  static Component
  fromImplicitSha256Digest(const uint8_t* digest, size_t digestSize);


  bool
  empty() const
  {
    return !hasValue() || value_size() == 0;
  }

  Component
  getSuccessor() const;

  bool
  equals(const Component& other) const
  {
    if (value_size() != other.value_size())
      return false;
    if (value_size() == 0 /* == other.value_size()*/)
      return true;

    // somehow, behavior is wrong on OSX 10.9 when component is empty
    // (probably some bug in STL...)
    return std::equal(value_begin(), value_end(), other.value_begin());
  }

  int
  compare(const Component& other) const;

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

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

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

  // !!! NOTE TO IMPLEMENTOR !!!
  //
  // This class MUST NOT contain any data fields.
  // Block can be reinterpret_cast'ed as Component type.
};

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

template<class Iterator>
inline
Component::Component(Iterator first, Iterator last)
  : Block(makeBinaryBlock(tlv::NameComponent, first, last))
{
}

} // namespace name
} // namespace ndn

#endif // NDN_NAME_COMPONENT_HPP