tlv-encoder.h

#ifndef NDN_TLV_ENCODER_H
#define NDN_TLV_ENCODER_H

#include <math.h>
#include <ndn-cpp/c/errors.h>
#include "../../util/dynamic-uint8-array.h"
#include "../../util/blob.h"
#include "tlv.h"

#ifdef __cplusplus
extern "C" {
#endif

struct ndn_TlvEncoder {
  struct ndn_DynamicUInt8Array *output; 
  size_t offset;                        
  int enableOutput;                     
};

static __inline void
ndn_TlvEncoder_initialize(struct ndn_TlvEncoder *self, struct ndn_DynamicUInt8Array *output)
{
  self->output = output;
  self->offset = 0;
  self->enableOutput = 1;
}

static __inline ndn_Error
ndn_TlvEncoder_seek(struct ndn_TlvEncoder *self, size_t offset)
{
  ndn_Error error;
  if (self->enableOutput) {
    if ((error = ndn_DynamicUInt8Array_ensureLength(self->output, offset)))
      return error;
  }

  self->offset = offset;
  return NDN_ERROR_success;
}

static __inline size_t
ndn_TlvEncoder_sizeOfVarNumber(uint64_t varNumber)
{
  if (varNumber < 253)
    return 1;
  else if (varNumber <= 0xffff)
    return 3;
  else if (varNumber <= 0xffffffff)
    return 5;
  else
    return 9;
}

ndn_Error
ndn_TlvEncoder_writeVarNumberEnabled(struct ndn_TlvEncoder *self, uint64_t varNumber);

static __inline ndn_Error
ndn_TlvEncoder_writeVarNumber(struct ndn_TlvEncoder *self, uint64_t varNumber)
{
  if (self->enableOutput)
    return ndn_TlvEncoder_writeVarNumberEnabled(self, varNumber);
  else {
    // Just advance offset.
    self->offset += ndn_TlvEncoder_sizeOfVarNumber(varNumber);
    return NDN_ERROR_success;
  }
}

static __inline ndn_Error
ndn_TlvEncoder_writeTypeAndLength(struct ndn_TlvEncoder *self, unsigned int type, size_t length)
{
  if (self->enableOutput) {
    ndn_Error error;
    if ((error = ndn_TlvEncoder_writeVarNumberEnabled(self, (uint64_t)type)))
      return error;
    if ((error = ndn_TlvEncoder_writeVarNumberEnabled(self, (uint64_t)length)))
      return error;
  }
  else
    // Just advance offset.
    self->offset += ndn_TlvEncoder_sizeOfVarNumber((uint64_t)type) +
      ndn_TlvEncoder_sizeOfVarNumber((uint64_t)length);

  return NDN_ERROR_success;
}

static __inline size_t
ndn_TlvEncoder_sizeOfNonNegativeInteger(uint64_t value)
{
  if (value <= 0xff)
    return 1;
  else if (value <= 0xffff)
    return 2;
  else if (value <= 0xffffffff)
    return 4;
  else
    return 8;
}

ndn_Error
ndn_TlvEncoder_writeNonNegativeIntegerEnabled(struct ndn_TlvEncoder *self, uint64_t value);

static __inline ndn_Error
ndn_TlvEncoder_writeNonNegativeInteger(struct ndn_TlvEncoder *self, uint64_t value)
{
  if (self->enableOutput)
    return ndn_TlvEncoder_writeNonNegativeIntegerEnabled(self, value);
  else {
    // Just advance offset.
    self->offset += ndn_TlvEncoder_sizeOfNonNegativeInteger(value);
    return NDN_ERROR_success;
  }
}

static __inline size_t
ndn_TlvEncoder_sizeOfBlobTlv(unsigned int type, const struct ndn_Blob *value)
{
  return ndn_TlvEncoder_sizeOfVarNumber((uint64_t)type) + ndn_TlvEncoder_sizeOfVarNumber((uint64_t)value->length) +
    value->length;
}

ndn_Error
ndn_TlvEncoder_writeArrayEnabled
  (struct ndn_TlvEncoder *self, const uint8_t *array, size_t arrayLength);

static __inline ndn_Error
ndn_TlvEncoder_writeArray
  (struct ndn_TlvEncoder *self, const uint8_t *array, size_t arrayLength)
{
  if (self->enableOutput)
    return ndn_TlvEncoder_writeArrayEnabled(self, array, arrayLength);
  else
    // Just advance offset.
    self->offset += arrayLength;

  return NDN_ERROR_success;
}

ndn_Error
ndn_TlvEncoder_writeBlobTlvEnabled
  (struct ndn_TlvEncoder *self, unsigned int type, const struct ndn_Blob *value);

static __inline ndn_Error
ndn_TlvEncoder_writeBlobTlv
  (struct ndn_TlvEncoder *self, unsigned int type, const struct ndn_Blob *value)
{
  if (self->enableOutput)
    return ndn_TlvEncoder_writeBlobTlvEnabled(self, type, value);
  else
    // Just advance offset.
    self->offset += ndn_TlvEncoder_sizeOfBlobTlv(type, value);

  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvEncoder_writeOptionalBlobTlv
  (struct ndn_TlvEncoder *self, unsigned int type, const struct ndn_Blob *value)
{
  if (value->value && value->length > 0)
    return ndn_TlvEncoder_writeBlobTlv(self, type, value);
  else
    return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvEncoder_writeNonNegativeIntegerTlv(struct ndn_TlvEncoder *self, unsigned int type, uint64_t value)
{
  size_t sizeOfInteger = ndn_TlvEncoder_sizeOfNonNegativeInteger(value);
  if (self->enableOutput) {
    ndn_Error error;
    if ((error = ndn_TlvEncoder_writeTypeAndLength(self, type, sizeOfInteger)))
      return error;
    if ((error = ndn_TlvEncoder_writeNonNegativeIntegerEnabled(self, value)))
      return error;
  }
  else
    // Just advance offset.
    self->offset += ndn_TlvEncoder_sizeOfVarNumber((uint64_t)type) +
      ndn_TlvEncoder_sizeOfVarNumber((uint64_t)sizeOfInteger) + sizeOfInteger;

  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvEncoder_writeOptionalNonNegativeIntegerTlv(struct ndn_TlvEncoder *self, unsigned int type, int value)
{
  if (value >= 0)
    return ndn_TlvEncoder_writeNonNegativeIntegerTlv(self, type, (uint64_t)value);
  else
    return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvEncoder_writeOptionalNonNegativeIntegerTlvFromDouble(struct ndn_TlvEncoder *self, unsigned int type, double value)
{
  if (value >= 0.0)
    return ndn_TlvEncoder_writeNonNegativeIntegerTlv(self, type, (uint64_t)round(value));
  else
    return NDN_ERROR_success;
}

ndn_Error
ndn_TlvEncoder_writeNestedTlv
  (struct ndn_TlvEncoder *self, unsigned int type,
   ndn_Error (*writeValue)(const void *context, struct ndn_TlvEncoder *encoder),
   const void *context, int omitZeroLength);

#ifdef  __cplusplus
}
#endif

#endif