interest.h

#ifndef NDN_INTEREST_H
#define NDN_INTEREST_H

#include <ndn-cpp/c/interest-types.h>
#include "name.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_Exclude_initialize(&self->exclude, excludeEntries, maxExcludeEntries);
  self->childSelector = -1;
  self->mustBeFresh = 1;
  self->interestLifetimeMilliseconds = -1.0;
  ndn_Blob_initialize(&self->nonce, 0, 0);
  ndn_KeyLocator_initialize(&self->keyLocator, keyNameComponents, maxKeyNameComponents);
  ndn_Blob_initialize(&self->forwardingHintWireEncoding, 0, 0);
  ndn_Blob_initialize(&self->linkWireEncoding, 0, 0);
  self->selectedDelegationIndex = -1;
}

static __inline int ndn_Interest_getCanBePrefix(const struct ndn_Interest *self)
{
  // Use the closest v0.2 semantics. CanBePrefix is the opposite of exact
  // match where MaxSuffixComponents is 1 (for the implicit digest).
  return self->maxSuffixComponents != 1;
}

static __inline int ndn_Interest_getMustBeFresh(const struct ndn_Interest *self)
{
  return self->mustBeFresh;
}

static __inline void
ndn_Interest_setCanBePrefix(struct ndn_Interest *self, int canBePrefix)
{
  // Use the closest v0.2 semantics. CanBePrefix is the opposite of exact
  // match where MaxSuffixComponents is 1 (for the implicit digest).
  self->maxSuffixComponents = (canBePrefix ? -1 : 1);
}

static __inline void
ndn_Interest_setMustBeFresh(struct ndn_Interest *self, int mustBeFresh)
{
  self->mustBeFresh = (mustBeFresh ? 1 : 0);
}

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;
  if ((error = ndn_Exclude_setFromExclude(&self->exclude, &other->exclude)))
    return error;
  self->childSelector = other->childSelector;
  self->mustBeFresh = other->mustBeFresh;
  self->interestLifetimeMilliseconds = other->interestLifetimeMilliseconds;
  ndn_Blob_setFromBlob(&self->nonce, &other->nonce);
  if ((error = ndn_KeyLocator_setFromKeyLocator
       (&self->keyLocator, &other->keyLocator)))
    return error;
  ndn_Blob_setFromBlob(&self->forwardingHintWireEncoding, &other->forwardingHintWireEncoding);
  ndn_Blob_setFromBlob(&self->linkWireEncoding, &other->linkWireEncoding);
  self->selectedDelegationIndex = other->selectedDelegationIndex;

  return NDN_ERROR_success;
}

#ifdef __cplusplus
}
#endif

#endif