name-lite.hpp

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

#include "../c/errors.h"
#include "util/blob-lite.hpp"
#include "../c/name-types.h"

namespace ndn {

class ExcludeLite;

class NameLite : public ndn_Name {
public:
  class Component : private ndn_NameComponent {
  public:
    Component();

    Component
      (const uint8_t* value, size_t valueLength,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1);

    Component
      (const BlobLite& value,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1);

    const BlobLite&
    getValue() const { return BlobLite::downCast(value); }

    ndn_NameComponentType
    getType() const { return type; }

    int
    getOtherTypeCode() const { return otherTypeCode; }

    bool
    isSegment() const;

    bool
    isSegmentOffset() const;

    bool
    isVersion() const;

    bool
    isTimestamp() const;

    bool
    isSequenceNumber() const;

    bool
    isGeneric() const;

    bool
    isImplicitSha256Digest() const;

    bool
    isParametersSha256Digest() const;

    uint64_t
    toNumber() const;

    ndn_Error
    toNumberWithMarker(uint8_t marker, uint64_t& result) const;

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

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

    ndn_Error
    toSegment(uint64_t& result) const;

    ndn_Error
    toSegmentOffset(uint64_t& result) const;

    ndn_Error
    toVersion(uint64_t& result) const;

    ndn_Error
    toTimestamp(uint64_t& result) const;

    ndn_Error
    toSequenceNumber(uint64_t& result) const;

    bool
    equals(const Component& other) const;

    int
    compare(const Component& other) const;

    ndn_Error
    setFromNumber
      (uint64_t number, uint8_t* buffer, size_t bufferLength,
       ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
       int otherTypeCode = -1);

    ndn_Error
    setFromNumberWithMarker
      (uint64_t number, uint8_t marker, uint8_t* buffer, size_t bufferLength);

    ndn_Error
    setSegment(uint64_t segment, uint8_t* buffer, size_t bufferLength);

    ndn_Error
    setSegmentOffset
      (uint64_t segmentOffset, uint8_t* buffer, size_t bufferLength);

    ndn_Error
    setVersion(uint64_t version, uint8_t* buffer, size_t bufferLength);

    ndn_Error
    setTimestamp(uint64_t timestamp, uint8_t* buffer, size_t bufferLength);

    ndn_Error
    setSequenceNumber
      (uint64_t sequenceNumber, uint8_t* buffer, size_t bufferLength);

    ndn_Error
    setImplicitSha256Digest(const uint8_t* digest, size_t digestLength);

    ndn_Error
    setImplicitSha256Digest(const BlobLite& digest)
    {
      return setImplicitSha256Digest(digest.buf(), digest.size());
    }

    ndn_Error
    setParametersSha256Digest(const uint8_t* digest, size_t digestLength);

    ndn_Error
    setParametersSha256Digest(const BlobLite& digest)
    {
      return setParametersSha256Digest(digest.buf(), digest.size());
    }

    static Component&
    downCast(ndn_NameComponent& component) { return *(Component*)&component; }

    static const Component&
    downCast(const ndn_NameComponent& component) { return *(Component*)&component; }

  private:
    friend class NameLite;
    friend class ExcludeLite;
  };

  NameLite(ndn_NameComponent* components, size_t maxComponents);

  const Component&
  get(int i) const
  {
    // TODO: Range check.
    if (i >= 0)
      return Component::downCast(components[i]);
    else
      // Negative index.
      return Component::downCast(components[nComponents - (-i)]);
  }

  size_t
  size() const { return nComponents; }

  bool
  equals(const NameLite& name);

  bool
  match(const NameLite& name) const;

  void
  clear();

  ndn_Error
  append
    (const uint8_t* value, size_t valueLength,
     ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
     int otherTypeCode = -1);

  ndn_Error
  append
    (const BlobLite& value,
     ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
     int otherTypeCode = -1)
  {
    return append(value.buf(), value.size(), type, otherTypeCode);
  }

  ndn_Error
  append(const Component& component);

  ndn_Error
  append(const NameLite& name);

  ndn_Error
  append
    (const char *value,
     ndn_NameComponentType type = ndn_NameComponentType_GENERIC,
     int otherTypeCode = -1);

  ndn_Error
  appendSegment(uint64_t segment, uint8_t* buffer, size_t bufferLength);

  ndn_Error
  appendSegmentOffset
    (uint64_t segmentOffset, uint8_t* buffer, size_t bufferLength);

  ndn_Error
  appendVersion(uint64_t version, uint8_t* buffer, size_t bufferLength);

  ndn_Error
  appendTimestamp(uint64_t timestamp, uint8_t* buffer, size_t bufferLength);

  ndn_Error
  appendSequenceNumber
    (uint64_t sequenceNumber, uint8_t* buffer, size_t bufferLength);

  ndn_Error
  appendImplicitSha256Digest(const uint8_t* digest, size_t digestLength);

  ndn_Error
  appendImplicitSha256Digest(const BlobLite& digest)
  {
    return appendImplicitSha256Digest(digest.buf(), digest.size());
  }

  ndn_Error
  appendParametersSha256Digest(const uint8_t* digest, size_t digestLength);

  ndn_Error
  appendParametersSha256Digest(const BlobLite& digest)
  {
    return appendParametersSha256Digest(digest.buf(), digest.size());
  }

  ndn_Error
  set(const NameLite& other);

  const Component*
  pop();

  static NameLite&
  downCast(ndn_Name& name) { return *(NameLite*)&name; }

  static const NameLite&
  downCast(const ndn_Name& name) { return *(NameLite*)&name; }

private:
  // Declare friends who can downcast to the private base.
  friend class Tlv0_2WireFormatLite;

  NameLite(const NameLite& other);

  NameLite& operator=(const NameLite& other);
};

}

#endif