name.hpp

Go to the documentation of this file.

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

#include "common.hpp"
#include "name-component.hpp"

#include <boost/iterator/reverse_iterator.hpp>

namespace ndn {

class Name;

typedef Name PartialName;

class Name : public enable_shared_from_this<Name>
{
public:
  class Error : public name::Component::Error
  {
  public:
    explicit
    Error(const std::string& what)
      : name::Component::Error(what)
    {
    }
  };

  typedef name::Component Component;

  typedef std::vector<Component>  component_container;

  typedef Component               value_type;
  typedef void                    allocator_type;
  typedef Component&              reference;
  typedef const Component         const_reference;
  typedef Component*              pointer;
  typedef const Component*        const_pointer;
  typedef Component*              iterator;
  typedef const Component*        const_iterator;

  typedef boost::reverse_iterator<iterator>       reverse_iterator;
  typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;

  typedef component_container::difference_type difference_type;
  typedef component_container::size_type       size_type;

  Name();

  explicit
  Name(const Block& wire);

  Name(const char* uri);

  Name(const std::string& uri);

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

  const Block&
  wireEncode() const;

  void
  wireDecode(const Block& wire);

  bool
  hasWire() const;

  DEPRECATED(
  void
  set(const char* uri));

  DEPRECATED(
  void
  set(const std::string& uri));

  Name&
  append(const uint8_t* value, size_t valueLength)
  {
    m_nameBlock.push_back(Component(value, valueLength));
    return *this;
  }

  template<class Iterator>
  Name&
  append(Iterator first, Iterator last)
  {
    m_nameBlock.push_back(Component(first, last));
    return *this;
  }

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

  Name&
  append(const char* value)
  {
    m_nameBlock.push_back(Component(value));
    return *this;
  }

  Name&
  append(const Block& value)
  {
    if (value.type() == tlv::NameComponent)
      m_nameBlock.push_back(value);
    else
      m_nameBlock.push_back(Block(tlv::NameComponent, value));

    return *this;
  }

  Name&
  append(const PartialName& name);

  void
  clear()
  {
    m_nameBlock = Block(tlv::Name);
  }

  PartialName
  getSubName(ssize_t iStartComponent, size_t nComponents = npos) const;

  PartialName
  getPrefix(ssize_t nComponents) const
  {
    if (nComponents < 0)
      return getSubName(0, m_nameBlock.elements_size() + nComponents);
    else
      return getSubName(0, nComponents);
  }

  std::string
  toUri() const;

  Name&
  appendNumber(uint64_t number);

  Name&
  appendNumberWithMarker(uint8_t marker, uint64_t number);

  Name&
  appendVersion(uint64_t version);

  Name&
  appendVersion();

  Name&
  appendSegment(uint64_t segmentNo);

  Name&
  appendSegmentOffset(uint64_t offset);

  Name&
  appendTimestamp(const time::system_clock::TimePoint& timePoint = time::system_clock::now());

  Name&
  appendSequenceNumber(uint64_t seqNo);

  Name&
  appendImplicitSha256Digest(const ConstBufferPtr& digest);

  Name&
  appendImplicitSha256Digest(const uint8_t* digest, size_t digestSize);

  Name
  getSuccessor() const;

  bool
  equals(const Name& name) const;

  bool
  isPrefixOf(const Name& name) const;

  //
  // vector equivalent interface.
  //

  bool
  empty() const
  {
    return m_nameBlock.elements().empty();
  }

  size_t
  size() const
  {
    return m_nameBlock.elements_size();
  }

  const Component&
  get(ssize_t i) const
  {
    if (i >= 0)
      return reinterpret_cast<const Component&>(m_nameBlock.elements()[i]);
    else
      return reinterpret_cast<const Component&>(m_nameBlock.elements()[size() + i]);
  }

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

  const Component&
  at(ssize_t i) const
  {
    if ((i >= 0 && static_cast<size_t>(i) >= size()) ||
        (i < 0  && static_cast<size_t>(-i) > size()))
      BOOST_THROW_EXCEPTION(Error("Requested component does not exist (out of bounds)"));

    return get(i);
  }

  int
  compare(const Name& other) const
  {
    return this->compare(0, npos, other);
  }

  int
  compare(size_t pos1, size_t count1,
          const Name& other, size_t pos2 = 0, size_t count2 = npos) const;

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

  //
  // Iterator interface to name components.
  //

  const_iterator
  begin() const
  {
    return reinterpret_cast<const_iterator>(&*m_nameBlock.elements().begin());
  }

  const_iterator
  end() const
  {
    return reinterpret_cast<const_iterator>(&*m_nameBlock.elements().end());
  }

  const_reverse_iterator
  rbegin() const
  {
    return const_reverse_iterator(end());
  }

  const_reverse_iterator
  rend() const
  {
    return const_reverse_iterator(begin());
  }

private:
  void
  construct(const char* uri);

public:
  static const size_t npos;

private:
  mutable Block m_nameBlock;
};

std::ostream&
operator<<(std::ostream& os, const Name& name);

std::istream&
operator>>(std::istream& is, Name& name);

inline bool
Name::hasWire() const
{
  return m_nameBlock.hasWire();
}

} // namespace ndn

namespace std {
template<>
struct hash<ndn::Name>
{
  size_t
  operator()(const ndn::Name& name) const;
};

} // namespace std

#endif