pit-iterator.h

Go to the documentation of this file.

#ifndef NDNDPDK_PCCT_PIT_DN_UP_IT_H
#define NDNDPDK_PCCT_PIT_DN_UP_IT_H
 
#include "pit-entry.h"
 
typedef struct PitDnUpIt_ {
  union {
    void* current;
    PitDn* dn; 
    PitUp* up; 
  };
  int index; 
 
  int i;   
  int max; 
  union {
    void* array; // (pvt) start of array
    PitDn* dns;
    PitUp* ups;
  };
  PitEntryExt** nextPtr; 
} PitDnUpIt_;
 
__attribute__((nonnull)) static inline PitDnUpIt_
PitDnUpIt_New_(PitEntry* entry, int maxInEntry, void* array) {
  return (PitDnUpIt_){
    current: array,
    max: maxInEntry,
    array: array,
    nextPtr: &entry->ext,
  };
}
 
__attribute__((nonnull)) bool
PitDnUpIt_Extend_(PitDnUpIt_* it, PitEntry* entry, int maxInExt, size_t offsetInExt);
 
__attribute__((nonnull)) static inline bool
PitDnUpIt_Valid_(PitDnUpIt_* it, bool canExtend, PitEntry* entry, int maxInExt,
                 size_t offsetInExt) {
  if (likely(it->i < it->max)) {
    return true;
  }
  return canExtend && PitDnUpIt_Extend_(it, entry, maxInExt, offsetInExt);
}
 
__attribute__((nonnull)) static inline void
PitDnUpIt_EnterExt_(PitDnUpIt_* it, PitEntryExt* ext, int maxInExt, size_t offsetInExt) {
  it->i = 0;
  it->max = maxInExt;
  it->array = RTE_PTR_ADD(ext, offsetInExt);
  it->current = it->array;
  it->nextPtr = &ext->next;
}
 
__attribute__((nonnull)) static inline void
PitDnUpIt_Next_(PitDnUpIt_* it, size_t sizeofRecord, int maxInExt, size_t offsetInExt) {
  NDNDPDK_ASSERT(it->i < it->max);
  ++it->index;
  ++it->i;
  it->current = RTE_PTR_ADD(it->current, sizeofRecord);
  if (likely(it->i < it->max)) {
    return;
  }
 
  PitEntryExt* ext = *it->nextPtr;
  if (ext == NULL) {
    return;
  }
  PitDnUpIt_EnterExt_(it, ext, maxInExt, offsetInExt);
}
 
typedef PitDnUpIt_ PitDnIt;
 
__attribute__((nonnull)) static inline void
PitDn_UseSlot(PitDnIt* it) {
  int next = it->i + 1;
  if (likely(next < it->max)) {
    it->dns[next].face = 0;
  }
}
 
#define PitDn_Each(var, entry, canExtend)                                                          \
  for (PitDnIt var = PitDnUpIt_New_((entry), PitMaxDns, (entry)->dns);                             \
       PitDnUpIt_Valid_(&var, (canExtend), (entry), PitMaxExtDns, offsetof(PitEntryExt, dns));     \
       PitDnUpIt_Next_(&var, sizeof(PitDn), PitMaxExtDns, offsetof(PitEntryExt, dns)))
 
typedef PitDnUpIt_ PitUpIt;
 
__attribute__((nonnull)) static inline void
PitUp_UseSlot(PitUpIt* it) {
  int next = it->i + 1;
  if (likely(next < it->max)) {
    it->ups[next].face = 0;
  }
}
 
#define PitUp_Each(var, entry, canExtend)                                                          \
  for (PitUpIt var = PitDnUpIt_New_((entry), PitMaxUps, (entry)->ups);                             \
       PitDnUpIt_Valid_(&var, (canExtend), (entry), PitMaxExtUps, offsetof(PitEntryExt, ups));     \
       PitDnUpIt_Next_(&var, sizeof(PitUp), PitMaxExtUps, offsetof(PitEntryExt, ups)))
 
#endif // NDNDPDK_PCCT_PIT_DN_UP_IT_H