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 NameLite : private ndn_Name {
public:
  class Component : private ndn_NameComponent {
  public:
    Component();

    Component(const uint8_t* value, size_t valueLength);

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

    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;

    int compare(const Component& other) const;

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

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

  NameLite(ndn_NameComponent* components, size_t maxComponents);

  const Component&
  get(int i) const
  {
    // TODO: Range check.
    if (i >= 0)
      return Component::upCast(components[i]);
    else
      // Negative index.
      return Component::upCast(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_Error
  append(const BlobLite& value) { return append(value.buf(), value.size()); }

  ndn_Error
  append(const NameLite::Component& component)
  {
    return append(component.getValue().buf(), component.getValue().size());
  }

  ndn_Error
  append(const char *value);

  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
  set(const NameLite& other);

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

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

private:
  NameLite(NameLite& other);
  NameLite(const NameLite& other);

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

}

#endif