interest.h

#ifndef NDN_INTEREST_H
#define NDN_INTEREST_H

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

#ifdef __cplusplus
extern "C" {
#endif

static __inline void ndn_ExcludeEntry_initialize(struct ndn_ExcludeEntry *self, ndn_ExcludeType type, const uint8_t *component, size_t componentLength)
{
  self->type = type;
  ndn_NameComponent_initialize(&self->component, component, componentLength);
}

static __inline void
ndn_ExcludeEntry_setFromExcludeEntry
  (struct ndn_ExcludeEntry *self, const struct ndn_ExcludeEntry *other)
{
  *self = *other;
}

static __inline void ndn_Exclude_initialize(struct ndn_Exclude *self, struct ndn_ExcludeEntry *entries, size_t maxEntries)
{
  self->entries = entries;
  self->maxEntries = maxEntries;
  self->nEntries = 0;
}

static __inline void
ndn_Exclude_clear(struct ndn_Exclude *self)
{
  self->nEntries = 0;
}

ndn_Error
ndn_Exclude_appendAny(struct ndn_Exclude *self);

ndn_Error
ndn_Exclude_appendComponent
  (struct ndn_Exclude *self, const uint8_t* component, size_t componentLength);

ndn_Error
ndn_Exclude_setFromExclude
  (struct ndn_Exclude *self, const struct ndn_Exclude *other);

static __inline void ndn_Interest_initialize
  (struct ndn_Interest *self, struct ndn_NameComponent *nameComponents, size_t maxNameComponents,
   struct ndn_ExcludeEntry *excludeEntries, size_t maxExcludeEntries, struct ndn_NameComponent *keyNameComponents,
   size_t maxKeyNameComponents)
{
  ndn_Name_initialize(&self->name, nameComponents, maxNameComponents);
  self->minSuffixComponents = -1;
  self->maxSuffixComponents = -1;
  ndn_PublisherPublicKeyDigest_initialize(&self->publisherPublicKeyDigest);
  ndn_Exclude_initialize(&self->exclude, excludeEntries, maxExcludeEntries);
  self->childSelector = -1;
  self->answerOriginKind = -1;
  self->scope = -1;
  self->interestLifetimeMilliseconds = -1.0;
  ndn_Blob_initialize(&self->nonce, 0, 0);
  ndn_KeyLocator_initialize(&self->keyLocator, keyNameComponents, maxKeyNameComponents);
}

static __inline int ndn_Interest_getMustBeFresh(const struct ndn_Interest *self)
{
  if (self->answerOriginKind < 0)
    return 1;
  else
    return (self->answerOriginKind & ndn_Interest_ANSWER_STALE) == 0 ? 1 : 0;
}

static __inline void
ndn_Interest_setMustBeFresh(struct ndn_Interest *self, int mustBeFresh)
{
  if (self->answerOriginKind < 0) {
    // It is is already the default where MustBeFresh is true.
    if (!mustBeFresh)
      // Set answerOriginKind so that getMustBeFresh returns false.
      self->answerOriginKind = ndn_Interest_ANSWER_STALE;
  }
  else {
    if (mustBeFresh)
      // Clear the stale bit.
      self->answerOriginKind &= ~ndn_Interest_ANSWER_STALE;
    else
      // Set the stale bit.
      self->answerOriginKind |= ndn_Interest_ANSWER_STALE;
  }
}

static __inline ndn_Error
ndn_Interest_setFromInterest
  (struct ndn_Interest *self, const struct ndn_Interest *other)
{
  ndn_Error error;

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

  if ((error = ndn_Name_setFromName(&self->name, &other->name)))
    return error;
  self->minSuffixComponents = other->minSuffixComponents;
  self->maxSuffixComponents = other->maxSuffixComponents;
  self->publisherPublicKeyDigest = other->publisherPublicKeyDigest;
  if ((error = ndn_Exclude_setFromExclude(&self->exclude, &other->exclude)))
    return error;
  self->childSelector = other->childSelector;
  self->answerOriginKind = other->answerOriginKind;
  self->scope = other->scope;
  self->interestLifetimeMilliseconds = other->interestLifetimeMilliseconds;
  ndn_Blob_setFromBlob(&self->nonce, &other->nonce);
  if ((error = ndn_KeyLocator_setFromKeyLocator
       (&self->keyLocator, &other->keyLocator)))
    return error;

  return NDN_ERROR_success;
}

#ifdef __cplusplus
}
#endif

#endif