data.h

#ifndef NDN_DATA_H
#define NDN_DATA_H

#include <math.h>
#include <ndn-cpp/c/data-types.h>
#include "name.h"
#include "publisher-public-key-digest.h"
#include "key-locator.h"

#ifdef __cplusplus
extern "C" {
#endif

static __inline void ndn_Signature_initialize(struct ndn_Signature *self, struct ndn_NameComponent *keyNameComponents, size_t maxKeyNameComponents) {
  self->type = (ndn_SignatureType)-1;
  ndn_Blob_initialize(&self->digestAlgorithm, 0, 0);
  ndn_Blob_initialize(&self->witness, 0, 0);
  ndn_Blob_initialize(&self->signature, 0, 0);
  ndn_PublisherPublicKeyDigest_initialize(&self->publisherPublicKeyDigest);
  ndn_KeyLocator_initialize(&self->keyLocator, keyNameComponents, maxKeyNameComponents);
}

static __inline void ndn_Signature_clear(struct ndn_Signature *self)
{
  ndn_Signature_initialize
    (self, self->keyLocator.keyName.components,
     self->keyLocator.keyName.maxComponents);
}

static __inline ndn_Error
ndn_Signature_setFromSignature
  (struct ndn_Signature *self, const struct ndn_Signature *other)
{
  ndn_Error error;

  if (other == self)
    // Setting to itself. Do nothing.
    return NDN_ERROR_success;

  ndn_Blob_setFromBlob(&self->digestAlgorithm, &other->digestAlgorithm);
  ndn_Blob_setFromBlob(&self->witness, &other->witness);
  ndn_Blob_setFromBlob(&self->signature, &other->signature);
  self->publisherPublicKeyDigest = other->publisherPublicKeyDigest;
  if ((error = ndn_KeyLocator_setFromKeyLocator
       (&self->keyLocator, &other->keyLocator)))
    return error;

  return NDN_ERROR_success;
}

static __inline void ndn_MetaInfo_initialize(struct ndn_MetaInfo *self)
{
  self->timestampMilliseconds = -1;
  self->type = ndn_ContentType_BLOB;
  self->freshnessPeriod = -1;
  ndn_NameComponent_initialize(&self->finalBlockId, 0, 0);
}

static __inline int ndn_MetaInfo_getFreshnessSeconds(const struct ndn_MetaInfo *self)
{
  return self->freshnessPeriod < 0 ? -1 : (int)round(self->freshnessPeriod / 1000.0);
}

static __inline void ndn_MetaInfo_setFreshnessSeconds(struct ndn_MetaInfo *self, int freshnessSeconds)
{
  self->freshnessPeriod = freshnessSeconds < 0 ? -1.0 : (double)freshnessSeconds * 1000.0;
}

static __inline ndn_Error
ndn_MetaInfo_setFromMetaInfo
  (struct ndn_MetaInfo *self, const struct ndn_MetaInfo *other)
{
  if (other == self)
    // Setting to itself. Do nothing.
    return NDN_ERROR_success;

  self->timestampMilliseconds = other->timestampMilliseconds;
  self->type = other->type;
  self->freshnessPeriod = other->freshnessPeriod;
  ndn_NameComponent_setFromNameComponent(&self->finalBlockId, &other->finalBlockId);

  return NDN_ERROR_success;
}

static __inline void ndn_Data_initialize
  (struct ndn_Data *self, struct ndn_NameComponent *nameComponents, size_t maxNameComponents,
   struct ndn_NameComponent *keyNameComponents, size_t maxKeyNameComponents)
{
  ndn_Signature_initialize(&self->signature, keyNameComponents, maxKeyNameComponents);
  ndn_Name_initialize(&self->name, nameComponents, maxNameComponents);
  ndn_MetaInfo_initialize(&self->metaInfo);
  ndn_Blob_initialize(&self->content, 0, 0);
}

static __inline ndn_Error
ndn_Data_setFromData(struct ndn_Data *self, const struct ndn_Data *other)
{
  ndn_Error error;

  if (other == self)
    // Setting to itself. Do nothing.
    return NDN_ERROR_success;

  if ((error = ndn_Signature_setFromSignature
       (&self->signature, &other->signature)))
    return error;
  if ((error = ndn_Name_setFromName(&self->name, &other->name)))
    return error;
  if ((error = ndn_MetaInfo_setFromMetaInfo
       (&self->metaInfo, &other->metaInfo)))
    return error;
  ndn_Blob_setFromBlob(&self->content, &other->content);

  return NDN_ERROR_success;
}

#ifdef __cplusplus
}
#endif

#endif