name.hpp

Go to the documentation of this file.

#ifndef NDNPH_PACKET_NAME_HPP
#define NDNPH_PACKET_NAME_HPP
 
#include "../core/input-iterator-pointer-proxy.hpp"
#include "component.hpp"
 
namespace ndnph {
 
class Name : public Printable {
public:
  explicit Name(const uint8_t* value = nullptr, size_t length = 0) {
    decodeValue(value, length);
  }
 
  template<typename It>
  explicit Name(Region& region, It first, It last) {
    static_assert(std::is_base_of<std::forward_iterator_tag,
                                  typename std::iterator_traits<It>::iterator_category>::value,
                  "");
    static_assert(std::is_same<uint8_t, typename std::iterator_traits<It>::value_type>::value, "");
    size_t length = std::distance(first, last);
    uint8_t* value = region.alloc(length);
    if (value != nullptr) {
      std::copy(first, last, value);
      decodeValue(value, length);
    }
  }
 
  explicit Name(Region& region, std::initializer_list<uint8_t> value)
    : Name(region, value.begin(), value.end()) {}
 
  static Name parse(Region& region, const char* uri) {
    size_t uriLen = std::strlen(uri);
    size_t bufLen = 2 * uriLen;
    uint8_t* buf = region.alloc(bufLen);
    if (buf == nullptr) {
      return Name();
    }
 
    size_t nComps = 0;
    ssize_t length = parseUri(buf, bufLen, uri, uriLen, nComps);
    if (length < 0) {
      region.free(buf, bufLen);
      return Name();
    }
 
    uint8_t* value = buf + bufLen - length;
    if (value != buf) {
      std::copy_backward(buf, buf + length, value + length);
      region.free(buf, bufLen - length);
    }
    return Name(value, length, nComps);
  }
 
  explicit operator bool() const {
    return m_nComps > 0;
  }
 
  size_t length() const {
    return m_length;
  }
 
  const uint8_t* value() const {
    return m_value;
  }
 
  size_t size() const {
    return m_nComps;
  }
 
  class Iterator : public Decoder::Iterator {
  public:
    using super = Decoder::Iterator;
    using iterator_category = std::input_iterator_tag;
    using value_type = const Component;
    using difference_type = std::ptrdiff_t;
    using pointer = detail::InputIteratorPointerProxy<value_type>;
    using reference = value_type;
 
    Iterator() = default;
 
    explicit Iterator(const super& inner)
      : super(inner) {}
 
    reference operator*() {
      Component comp;
      comp.decodeFrom(super::operator*());
      return comp;
    }
 
    pointer operator->() {
      return pointer(this->operator*());
    }
  };
 
  Iterator begin() const {
    return Iterator(Decoder(m_value, m_length).begin());
  }
 
  Iterator end() const {
    return Iterator(Decoder(m_value, m_length).end());
  }
 
  Component operator[](int i) const {
    if (i < 0) {
      i += m_nComps;
    }
    if (isOutOfRange(i)) {
      return Component();
    }
    auto it = begin();
    std::advance(it, i);
    return *it;
  }
 
  Name slice(int first = 0, int last = 0) const {
    if (first < 0) {
      first += m_nComps;
    }
    if (last <= 0) {
      last += m_nComps;
    }
    if (isOutOfRange(first) || isOutOfRange(last, true) || first >= last) {
      return Name();
    }
 
    auto it = begin();
    std::advance(it, first);
    auto firstComp = *it;
    std::advance(it, last - first - 1);
    auto lastComp = *it; // inclusive last component
    return Name(firstComp.tlv(), lastComp.tlv() + lastComp.size() - firstComp.tlv(), last - first);
  }
 
  Name getPrefix(int n = 0) const {
    return slice(0, n);
  }
 
  template<typename... C>
  Name append(Region& region, const C&... comps) const {
    Encoder encoder(region);
    size_t nComps = prependComps(encoder, comps...);
    uint8_t* room = encoder.prependRoom(m_length);
    if (room != nullptr) {
      std::copy_n(m_value, m_length, room);
    }
    if (!encoder) {
      encoder.discard();
      return Name();
    }
    encoder.trim();
    return Name(encoder.begin(), encoder.size(), m_nComps + nComps);
  }
 
  Name clone(Region& region) const {
    return append(region);
  }
 
  enum CompareResult {
    CMP_LT = -2,      
    CMP_LPREFIX = -1, 
    CMP_EQUAL = 0,    
    CMP_RPREFIX = +1, 
    CMP_GT = +2,      
  };
 
  CompareResult compare(const Name& other) const {
    size_t commonLength = std::min(m_length, other.m_length);
    if (commonLength > 0) {
      int commonCmp = std::memcmp(m_value, other.m_value, commonLength);
      if (commonCmp < 0) {
        return CMP_LT;
      }
      if (commonCmp > 0) {
        return CMP_GT;
      }
    }
 
    if (m_length > commonLength) {
      return CMP_RPREFIX;
    }
    if (other.m_length > commonLength) {
      return CMP_LPREFIX;
    }
    return CMP_EQUAL;
  }
 
  bool isPrefixOf(const Name& other) const {
    auto cmp = compare(other);
    return cmp == CMP_LPREFIX || cmp == CMP_EQUAL;
  }
 
  void encodeTo(Encoder& encoder) const {
    encoder.prependTlv(TT::Name, tlv::Value(m_value, m_length));
  }
 
  bool decodeFrom(const Decoder::Tlv& d) {
    return decodeValue(d.value, d.length);
  }
 
#ifdef NDNPH_PRINT_ARDUINO
  size_t printTo(::Print& p) const final {
    size_t count = 0;
    if (m_nComps == 0) {
      count += p.print('/');
    } else {
      for (const auto& comp : *this) {
        count += p.print('/');
        // count += p.print(comp);
        count += comp.printTo(p);
      }
    }
    return count;
  }
#endif
 
private:
  explicit Name(const uint8_t* value, size_t length, size_t nComps)
    : m_value(value)
    , m_length(length)
    , m_nComps(nComps) {}
 
  bool decodeValue(const uint8_t* value, size_t length) {
    m_value = value;
    if (decodeComps(length)) {
      return true;
    }
    m_value = nullptr;
    m_length = m_nComps = 0;
    return false;
  }
 
  bool decodeComps(size_t length) {
    Decoder decoder(m_value, length);
    auto it = decoder.begin(), end = decoder.end();
    for (; it != end; ++it) {
      Component comp;
      if (!it->decode(comp)) {
        return false;
      }
      m_length += it->size;
      ++m_nComps;
    }
    return !it.hasError();
  }
 
  bool isOutOfRange(int i, bool acceptPastEnd = false) const {
    return i < 0 ||
           (acceptPastEnd ? i > static_cast<int>(m_nComps) : i >= static_cast<int>(m_nComps));
  }
 
  static ssize_t parseUri(uint8_t* buf, size_t bufLen, const char* uri, size_t uriLen,
                          size_t& nComps) {
    nComps = 0;
    if (uriLen <= 1) { // empty Name
      return 0;
    }
    const char* uriEnd = uri + uriLen;
    size_t length = 0;
    while (uri < uriEnd) {
      ++uri; // skip '/'
      const char* compEnd = std::strchr(uri, '/');
      if (compEnd == nullptr) {
        compEnd = uriEnd;
      }
 
      auto comp = Component::parse(buf + length, bufLen - length, uri, compEnd - uri);
      if (!comp) {
        return -1;
      }
      ++nComps;
      length += comp.size();
      uri = compEnd;
    }
    return length;
  }
 
  template<typename... C>
  static size_t prependComps(Encoder& encoder, const Component& comp, const C&... rest) {
    size_t nComps = prependComps(encoder, rest...);
    encoder.prepend(comp);
    return 1 + nComps;
  }
 
  template<typename Convention, typename Arg, typename... C>
  static typename std::enable_if<!std::is_base_of<Component, Convention>::value, size_t>::type
  prependComps(Encoder& encoder, const Convention&, const Arg& arg, const C&... rest) {
    size_t nComps = prependComps(encoder, rest...);
 
    size_t headroom = encoder.availableHeadroom();
    Region overlay(const_cast<uint8_t*>(encoder.begin() - headroom), headroom);
    auto comp = Convention::create(overlay, arg);
 
    uint8_t* room = encoder.prependRoom(comp.size());
    if (!comp || room == nullptr) {
      encoder.setError();
      return 0;
    }
    std::memmove(room, comp.tlv(), comp.size());
    return 1 + nComps;
  }
 
  static size_t prependComps(Encoder&) {
    return 0;
  }
 
private:
  const uint8_t* m_value = nullptr;
  size_t m_length = 0;
  size_t m_nComps = 0;
};
 
inline bool
operator==(const Name& lhs, const Name& rhs) {
  return lhs.compare(rhs) == Name::CMP_EQUAL;
}
 
inline bool
operator<(const Name& lhs, const Name& rhs) {
  auto cmp = lhs.compare(rhs);
  return cmp == Name::CMP_LT || cmp == Name::CMP_LPREFIX;
}
 
NDNPH_DECLARE_NE(Name, inline)
NDNPH_DECLARE_GT_LE_GE(Name, inline)
 
#ifdef NDNPH_PRINT_OSTREAM
inline std::ostream&
operator<<(std::ostream& os, const Name& name) {
  if (name.size() == 0) {
    return os << '/';
  }
  for (const auto& comp : name) {
    os << '/' << comp;
  }
  return os;
}
#endif
 
} // namespace ndnph
 
#endif // NDNPH_PACKET_NAME_HPP