name.h

#ifndef NDN_NAME_H
#define NDN_NAME_H

#include <ndn-cpp/c/name-types.h>
#include <ndn-cpp/c/errors.h>
#include "util/blob.h"

#ifdef __cplusplus
extern "C" {
#endif

static __inline void ndn_NameComponent_initialize(struct ndn_NameComponent *self, const uint8_t *value, size_t valueLength)
{
  self->type = ndn_NameComponentType_GENERIC;
  self->otherTypeCode = -1;
  ndn_Blob_initialize(&self->value, value, valueLength);
}

static __inline void
ndn_NameComponent_setType
  (struct ndn_NameComponent *self, ndn_NameComponentType type,
   int otherTypeCode)
{
  self->type = type;
  self->otherTypeCode =
    (type == ndn_NameComponentType_OTHER_CODE ? otherTypeCode : -1);
}

static __inline int
ndn_NameComponent_isSegment(const struct ndn_NameComponent *self)
{
  return (self->value.length >= 1 && self->value.value[0] == 0x00 &&
          self->type == ndn_NameComponentType_GENERIC) ? 1 : 0;
}

static __inline int
ndn_NameComponent_isSegmentOffset(const struct ndn_NameComponent *self)
{
  return (self->value.length >= 1 && self->value.value[0] == 0xFB &&
          self->type == ndn_NameComponentType_GENERIC) ? 1 : 0;
}

static __inline int
ndn_NameComponent_isVersion(const struct ndn_NameComponent *self)
{
  return (self->value.length >= 1 && self->value.value[0] == 0xFD &&
          self->type == ndn_NameComponentType_GENERIC) ? 1 : 0;
}

static __inline int
ndn_NameComponent_isTimestamp(const struct ndn_NameComponent *self)
{
  return (self->value.length >= 1 && self->value.value[0] == 0xFC &&
          self->type == ndn_NameComponentType_GENERIC) ? 1 : 0;
}

static __inline int
ndn_NameComponent_isSequenceNumber(const struct ndn_NameComponent *self)
{
  return (self->value.length >= 1 && self->value.value[0] == 0xFE &&
          self->type == ndn_NameComponentType_GENERIC) ? 1 : 0;
}

static __inline int
ndn_NameComponent_isGeneric(const struct ndn_NameComponent *self)
{
  return self->type == ndn_NameComponentType_GENERIC ? 1 : 0;
}

static __inline int
ndn_NameComponent_isImplicitSha256Digest(const struct ndn_NameComponent *self)
{
  return self->type == ndn_NameComponentType_IMPLICIT_SHA256_DIGEST ? 1 : 0;
}

static __inline int
ndn_NameComponent_isParametersSha256Digest(const struct ndn_NameComponent *self)
{
  return self->type == ndn_NameComponentType_PARAMETERS_SHA256_DIGEST ? 1 : 0;
}

uint64_t ndn_NameComponent_toNumber(const struct ndn_NameComponent *self);

ndn_Error ndn_NameComponent_toNumberWithMarker
  (const struct ndn_NameComponent *self, uint8_t marker, uint64_t *result);

static __inline ndn_Error
ndn_NameComponent_toSegment
  (const struct ndn_NameComponent *self, uint64_t *result)
{
  return ndn_NameComponent_toNumberWithMarker(self, 0x00, result);
}

static __inline ndn_Error
ndn_NameComponent_toSegmentOffset
  (const struct ndn_NameComponent *self, uint64_t *result)
{
  return ndn_NameComponent_toNumberWithMarker(self, 0xFB, result);
}

static __inline ndn_Error
ndn_NameComponent_toVersion
  (const struct ndn_NameComponent *self, uint64_t *result)
{
  return ndn_NameComponent_toNumberWithMarker(self, 0xFD, result);
}

static __inline ndn_Error
ndn_NameComponent_toTimestamp
  (const struct ndn_NameComponent *self, uint64_t *result)
{
  return ndn_NameComponent_toNumberWithMarker(self, 0xFC, result);
}

static __inline ndn_Error
ndn_NameComponent_toSequenceNumber
  (const struct ndn_NameComponent *self, uint64_t *result)
{
  return ndn_NameComponent_toNumberWithMarker(self, 0xFE, result);
}

ndn_Error ndn_NameComponent_toNumberWithPrefix
  (const struct ndn_NameComponent *self, const uint8_t *prefix,
   size_t prefixLength, uint64_t *result);

int
ndn_NameComponent_hasPrefix
  (const struct ndn_NameComponent *self, const uint8_t *prefix,
   size_t prefixLength);

int ndn_NameComponent_equals
  (const struct ndn_NameComponent *self, const struct ndn_NameComponent *other);

int ndn_NameComponent_compare
  (const struct ndn_NameComponent *self, const struct ndn_NameComponent *other);

static __inline void
ndn_NameComponent_setFromNameComponent
  (struct ndn_NameComponent *self, const struct ndn_NameComponent *other)
{
  *self = *other;
}

ndn_Error
ndn_NameComponent_setFromNumber
  (struct ndn_NameComponent *self, uint64_t number, uint8_t *buffer,
   size_t bufferLength);

ndn_Error
ndn_NameComponent_setFromNumberWithMarker
  (struct ndn_NameComponent *self, uint64_t number, uint8_t marker,
   uint8_t *buffer, size_t bufferLength);

static __inline ndn_Error
ndn_NameComponent_setSegment
  (struct ndn_NameComponent *self, uint64_t segment, uint8_t* buffer,
   size_t bufferLength)
{
  return ndn_NameComponent_setFromNumberWithMarker
    (self, segment, 0x00, buffer, bufferLength);
}

static __inline ndn_Error
ndn_NameComponent_setSegmentOffset
  (struct ndn_NameComponent *self, uint64_t segmentOffset, uint8_t* buffer,
   size_t bufferLength)
{
  return ndn_NameComponent_setFromNumberWithMarker
    (self, segmentOffset, 0xFB, buffer, bufferLength);
}

static __inline ndn_Error
ndn_NameComponent_setVersion
  (struct ndn_NameComponent *self, uint64_t version, uint8_t* buffer,
   size_t bufferLength)
{
  return ndn_NameComponent_setFromNumberWithMarker
    (self, version, 0xFD, buffer, bufferLength);
}

static __inline ndn_Error
ndn_NameComponent_setTimestamp
  (struct ndn_NameComponent *self, uint64_t timestamp, uint8_t* buffer,
   size_t bufferLength)
{
  return ndn_NameComponent_setFromNumberWithMarker
    (self, timestamp, 0xFC, buffer, bufferLength);
}

static __inline ndn_Error
ndn_NameComponent_setSequenceNumber
  (struct ndn_NameComponent *self, uint64_t sequenceNumber, uint8_t* buffer,
   size_t bufferLength)
{
  return ndn_NameComponent_setFromNumberWithMarker
    (self, sequenceNumber, 0xFE, buffer, bufferLength);
}

ndn_Error
ndn_NameComponent_setImplicitSha256Digest
  (struct ndn_NameComponent *self, const uint8_t* digest, size_t digestLength);

ndn_Error
ndn_NameComponent_setParametersSha256Digest
  (struct ndn_NameComponent *self, const uint8_t* digest, size_t digestLength);

static __inline void ndn_Name_initialize(struct ndn_Name *self, struct ndn_NameComponent *components, size_t maxComponents)
{
  self->components = components;
  self->maxComponents = maxComponents;
  self->nComponents = 0;
}

static __inline void
ndn_Name_clear(struct ndn_Name *self) { self->nComponents = 0; }

int ndn_Name_equals(const struct ndn_Name *self, const struct ndn_Name *name);

int ndn_Name_match(const struct ndn_Name *self, const struct ndn_Name *name);

ndn_Error ndn_Name_appendComponent(struct ndn_Name *self, const uint8_t* value, size_t valueLength);

ndn_Error ndn_Name_appendNameComponent
  (struct ndn_Name *self, const struct ndn_NameComponent *component);

ndn_Error ndn_Name_appendName(struct ndn_Name *self, const struct ndn_Name *name);

static __inline ndn_Error ndn_Name_appendBlob(struct ndn_Name *self, struct ndn_Blob *value)
{
  return ndn_Name_appendComponent(self, value->value, value->length);
}

static __inline ndn_Error ndn_Name_appendImplicitSha256Digest
  (struct ndn_Name *self, const uint8_t* digest, size_t digestLength)
{
  ndn_Error error;
  // Add an empty component.
  if ((error = ndn_Name_appendComponent(self, 0, 0)))
    return error;
  return ndn_NameComponent_setImplicitSha256Digest
    (&self->components[self->nComponents - 1], digest, digestLength);
}

static __inline ndn_Error ndn_Name_appendParametersSha256Digest
  (struct ndn_Name *self, const uint8_t* digest, size_t digestLength)
{
  ndn_Error error;
  // Add an empty component.
  if ((error = ndn_Name_appendComponent(self, 0, 0)))
    return error;
  return ndn_NameComponent_setParametersSha256Digest
    (&self->components[self->nComponents - 1], digest, digestLength);
}

ndn_Error ndn_Name_appendString(struct ndn_Name *self, const char * value);

ndn_Error
ndn_Name_setFromName(struct ndn_Name *self, const struct ndn_Name *other);

#ifdef __cplusplus
}
#endif

#endif