Avoid having to use numbered indexes by given all indexes a tag

and specifying them in the call if needed.

diff --git a/pdns/auth-packetcache.cc b/pdns/auth-packetcache.cc
index 715a5008f8a688a1e192b935be68b9b6327cad63..038d752368e583780aac35b463b1e836a78d9bd3 100644 (file)
--- a/pdns/auth-packetcache.cc
+++ b/pdns/auth-packetcache.cc
@@ -207,7 +207,7 @@ uint64_t AuthPacketCache::purge()
 uint64_t AuthPacketCache::purgeExact(const DNSName& qname)
 {
   auto& mc = getMap(qname);
-  uint64_t delcount = purgeExactLockedCollection(mc, qname);
+  uint64_t delcount = purgeExactLockedCollection<NameTag>(mc, qname);
 
   *d_statnumentries -= delcount;
 
@@ -224,7 +224,7 @@ uint64_t AuthPacketCache::purge(const string &match)
   uint64_t delcount = 0;
 
   if(ends_with(match, "$")) {
-    delcount = purgeLockedCollectionsVector(d_maps, match);
+    delcount = purgeLockedCollectionsVector<NameTag>(d_maps, match);
     *d_statnumentries -= delcount;
   }
   else {
@@ -240,7 +240,7 @@ void AuthPacketCache::cleanup()
   uint64_t cacheSize = *d_statnumentries;
   uint64_t totErased = 0;
 
-  totErased = pruneLockedCollectionsVector(d_maps, maxCached, cacheSize);
+  totErased = pruneLockedCollectionsVector<SequencedTag>(d_maps, maxCached, cacheSize);
   *d_statnumentries -= totErased;
 
   DLOG(g_log<<"Done with cache clean, cacheSize: "<<(*d_statnumentries)<<", totErased"<<totErased<<endl);

diff --git a/pdns/auth-packetcache.hh b/pdns/auth-packetcache.hh
index 94dad631df417dc2ba8cffad0b9c19779ebb27c2..5cfa055afd315e328f54eee6ff79366c15f1ee83 100644 (file)
--- a/pdns/auth-packetcache.hh
+++ b/pdns/auth-packetcache.hh
@@ -92,13 +92,13 @@ private:
 
   struct HashTag{};
   struct NameTag{};
-  struct SequenceTag{};
+  struct SequencedTag{};
   typedef multi_index_container<
     CacheEntry,
     indexed_by <
       hashed_non_unique<tag<HashTag>, member<CacheEntry,uint32_t,&CacheEntry::hash> >,
       ordered_non_unique<tag<NameTag>, member<CacheEntry,DNSName,&CacheEntry::qname>, CanonDNSNameCompare >,
-      sequenced<tag<SequenceTag>>
+      sequenced<tag<SequencedTag>>
       >
     > cmap_t;
 

diff --git a/pdns/auth-querycache.cc b/pdns/auth-querycache.cc
index 033ed32312f08595922749be930833c32fedb57b..2e39d2d225f8a7421e13fc54a6819d37a9f41da5 100644 (file)
--- a/pdns/auth-querycache.cc
+++ b/pdns/auth-querycache.cc
@@ -173,7 +173,7 @@ uint64_t AuthQueryCache::purge()
 uint64_t AuthQueryCache::purgeExact(const DNSName& qname)
 {
   auto& mc = getMap(qname);
-  uint64_t delcount = purgeExactLockedCollection(mc, qname);
+  uint64_t delcount = purgeExactLockedCollection<NameTag>(mc, qname);
 
   *d_statnumentries -= delcount;
 
@@ -186,7 +186,7 @@ uint64_t AuthQueryCache::purge(const string &match)
   uint64_t delcount = 0;
 
   if(ends_with(match, "$")) {
-    delcount = purgeLockedCollectionsVector(d_maps, match);
+    delcount = purgeLockedCollectionsVector<NameTag>(d_maps, match);
     *d_statnumentries -= delcount;
   }
   else {
@@ -202,7 +202,7 @@ void AuthQueryCache::cleanup()
   uint64_t cacheSize = *d_statnumentries;
   uint64_t totErased = 0;
 
-  totErased = pruneLockedCollectionsVector(d_maps, maxCached, cacheSize);
+  totErased = pruneLockedCollectionsVector<SequencedTag>(d_maps, maxCached, cacheSize);
 
   *d_statnumentries -= totErased;
   DLOG(g_log<<"Done with cache clean, cacheSize: "<<*d_statnumentries<<", totErased"<<totErased<<endl);

diff --git a/pdns/auth-querycache.hh b/pdns/auth-querycache.hh
index 21e35add37f9beec47497f4e0a27933eaecaed70..90144a3c8527b394599daa40f4084645b28f1d77 100644 (file)
--- a/pdns/auth-querycache.hh
+++ b/pdns/auth-querycache.hh
@@ -71,7 +71,7 @@ private:
 
   struct HashTag{};
   struct NameTag{};
-  struct SequenceTag{};
+  struct SequencedTag{};
   typedef multi_index_container<
     CacheEntry,
     indexed_by <
@@ -80,7 +80,7 @@ private:
                                                          member<CacheEntry,uint16_t,&CacheEntry::qtype>,
                                                          member<CacheEntry,int, &CacheEntry::zoneID> > > ,
       ordered_non_unique<tag<NameTag>, member<CacheEntry,DNSName,&CacheEntry::qname>, CanonDNSNameCompare >,
-      sequenced<tag<SequenceTag>>
+      sequenced<tag<SequencedTag>>
                            >
   > cmap_t;
 

diff --git a/pdns/cachecleaner.hh b/pdns/cachecleaner.hh
index 884029858e1af8108b2eac2ad40fe609b4f15e45..732631d00194c1d82b4994e52b18bde3ceacf5c2 100644 (file)
--- a/pdns/cachecleaner.hh
+++ b/pdns/cachecleaner.hh
@@ -26,7 +26,7 @@
 // this function can clean any cache that has a getTTD() method on its entries, a preRemoval() method and a 'sequence' index as its second index
 // the ritual is that the oldest entries are in *front* of the sequence collection, so on a hit, move an item to the end
 // on a miss, move it to the beginning
-template <typename C, typename T> void pruneCollection(C& container, T& collection, unsigned int maxCached, unsigned int scanFraction=1000)
+template <typename S, typename C, typename T> void pruneCollection(C& container, T& collection, unsigned int maxCached, unsigned int scanFraction=1000)
 {
   time_t now=time(0);
   unsigned int toTrim=0;
@@ -39,8 +39,8 @@ template <typename C, typename T> void pruneCollection(C& container, T& collecti
 
 //  cout<<"Need to trim "<<toTrim<<" from cache to meet target!\n";
 
-  typedef typename T::template nth_index<1>::type sequence_t;
-  sequence_t& sidx=collection.template get<1>();
+  typedef typename T::template index<S>::type sequence_t;
+  sequence_t& sidx=collection.template get<S>();
 
   unsigned int tried=0, lookAt, erased=0;
 
@@ -89,29 +89,29 @@ template <typename C, typename T> void pruneCollection(C& container, T& collecti
   }
 }
 
-// note: this expects iterator from first index, and sequence MUST be second index!
-template <typename T> void moveCacheItemToFrontOrBack(T& collection, typename T::iterator& iter, bool front)
+// note: this expects iterator from first index
+template <typename S, typename T> void moveCacheItemToFrontOrBack(T& collection, typename T::iterator& iter, bool front)
 {
-  typedef typename T::template nth_index<1>::type sequence_t;
-  sequence_t& sidx=collection.template get<1>();
-  typename sequence_t::iterator si=collection.template project<1>(iter);
+  typedef typename T::template index<S>::type sequence_t;
+  sequence_t& sidx=collection.template get<S>();
+  typename sequence_t::iterator si=collection.template project<S>(iter);
   if(front)
     sidx.relocate(sidx.begin(), si); // at the beginning of the delete queue
   else
     sidx.relocate(sidx.end(), si);  // back
 }
 
-template <typename T> void moveCacheItemToFront(T& collection, typename T::iterator& iter)
+template <typename S, typename T> void moveCacheItemToFront(T& collection, typename T::iterator& iter)
 {
-  moveCacheItemToFrontOrBack(collection, iter, true);
+  moveCacheItemToFrontOrBack<S>(collection, iter, true);
 }
 
-template <typename T> void moveCacheItemToBack(T& collection, typename T::iterator& iter)
+template <typename S, typename T> void moveCacheItemToBack(T& collection, typename T::iterator& iter)
 {
-  moveCacheItemToFrontOrBack(collection, iter, false);
+  moveCacheItemToFrontOrBack<S>(collection, iter, false);
 }
 
-template <typename T> uint64_t pruneLockedCollectionsVector(vector<T>& maps, uint64_t maxCached, uint64_t cacheSize)
+template <typename S, typename T> uint64_t pruneLockedCollectionsVector(vector<T>& maps, uint64_t maxCached, uint64_t cacheSize)
 {
   time_t now = time(nullptr);
   uint64_t totErased = 0;
@@ -129,7 +129,7 @@ template <typename T> uint64_t pruneLockedCollectionsVector(vector<T>& maps, uin
 
   for(auto& mc : maps) {
     WriteLock wl(&mc.d_mut);
-    auto& sidx = boost::multi_index::get<2>(mc.d_map);
+    auto& sidx = boost::multi_index::get<S>(mc.d_map);
     uint64_t erased = 0, lookedAt = 0;
     for(auto i = sidx.begin(); i != sidx.end(); lookedAt++) {
       if(i->ttd < now) {
@@ -164,7 +164,7 @@ template <typename T> uint64_t purgeLockedCollectionsVector(vector<T>& maps)
   return delcount;
 }
 
-template <typename T> uint64_t purgeLockedCollectionsVector(vector<T>& maps, const std::string& match)
+template <typename N, typename T> uint64_t purgeLockedCollectionsVector(vector<T>& maps, const std::string& match)
 {
   uint64_t delcount=0;
   string prefix(match);
@@ -172,7 +172,7 @@ template <typename T> uint64_t purgeLockedCollectionsVector(vector<T>& maps, con
   DNSName dprefix(prefix);
   for(auto& mc : maps) {
     WriteLock wl(&mc.d_mut);
-    auto& idx = boost::multi_index::get<1>(mc.d_map);
+    auto& idx = boost::multi_index::get<N>(mc.d_map);
     auto iter = idx.lower_bound(dprefix);
     auto start = iter;
 
@@ -188,11 +188,11 @@ template <typename T> uint64_t purgeLockedCollectionsVector(vector<T>& maps, con
   return delcount;
 }
 
-template <typename T> uint64_t purgeExactLockedCollection(T& mc, const DNSName& qname)
+template <typename N, typename T> uint64_t purgeExactLockedCollection(T& mc, const DNSName& qname)
 {
   uint64_t delcount=0;
   WriteLock wl(&mc.d_mut);
-  auto& idx = boost::multi_index::get<1>(mc.d_map);
+  auto& idx = boost::multi_index::get<N>(mc.d_map);
   auto range = idx.equal_range(qname);
   if(range.first != range.second) {
     delcount += distance(range.first, range.second);
@@ -202,13 +202,13 @@ template <typename T> uint64_t purgeExactLockedCollection(T& mc, const DNSName&
   return delcount;
 }
 
-template<typename Index>
+template<typename S, typename Index>
 std::pair<typename Index::iterator,bool>
 lruReplacingInsert(Index& i,const typename Index::value_type& x)
 {
   std::pair<typename Index::iterator,bool> res = i.insert(x);
   if (!res.second) {
-    moveCacheItemToBack(i, res.first);
+    moveCacheItemToBack<S>(i, res.first);
     res.second = i.replace(res.first, x);
   }
   return res;

diff --git a/pdns/dbdnsseckeeper.cc b/pdns/dbdnsseckeeper.cc
index 2fa9b78bef5b0ef55612aebc3c0771a2228dfde9..1e9eb07d80e1a9221d212dbedf78f4d18f1c66ca 100644 (file)
--- a/pdns/dbdnsseckeeper.cc
+++ b/pdns/dbdnsseckeeper.cc
@@ -224,7 +224,7 @@ void DNSSECKeeper::getFromMeta(const DNSName& zname, const std::string& key, std
     nce.d_value = value;
     {
       WriteLock l(&s_metacachelock);
-      lruReplacingInsert(s_metacache, nce);
+      lruReplacingInsert<SequencedTag>(s_metacache, nce);
     }
   }
 }
@@ -514,7 +514,7 @@ DNSSECKeeper::keyset_t DNSSECKeeper::getKeys(const DNSName& zone, bool useCache)
     kce.d_ttd = now + ttl;
     {
       WriteLock l(&s_keycachelock);
-      lruReplacingInsert(s_keycache, kce);
+      lruReplacingInsert<SequencedTag>(s_keycache, kce);
     }
   }
 
@@ -832,11 +832,11 @@ void DNSSECKeeper::cleanup()
   if(now.tv_sec - s_last_prune > (time_t)(30)) {
     {
         WriteLock l(&s_metacachelock);
-        pruneCollection(*this, s_metacache, ::arg().asNum("max-cache-entries"));
+        pruneCollection<SequencedTag>(*this, s_metacache, ::arg().asNum("max-cache-entries"));
     }
     {
         WriteLock l(&s_keycachelock);
-        pruneCollection(*this, s_keycache, ::arg().asNum("max-cache-entries"));
+        pruneCollection<SequencedTag>(*this, s_keycache, ::arg().asNum("max-cache-entries"));
     }
     s_last_prune=time(0);
   }

diff --git a/pdns/dnsdistdist/dnsdist-rules.hh b/pdns/dnsdistdist/dnsdist-rules.hh
index e443fd3425e606d4f5d0387953c0e7f2c04f42f3..ebcc8aa795b97ee18189e433fbd5d01225201c00 100644 (file)
--- a/pdns/dnsdistdist/dnsdist-rules.hh
+++ b/pdns/dnsdistdist/dnsdist-rules.hh
@@ -103,7 +103,7 @@ public:
         iter = d_limits.insert(e).first;
       }
 
-      moveCacheItemToBack(d_limits, iter);
+      moveCacheItemToBack<SequencedTag>(d_limits, iter);
       return !iter->d_limiter.check(d_qps, d_burst);
     }
   }

diff --git a/pdns/dnsseckeeper.hh b/pdns/dnsseckeeper.hh
index f4bf04fe705cfc67f3da70e42426cb52e5f5c4d8..f280f4de985e98bb99fc7fcc4c6953a8acb1181c 100644 (file)
--- a/pdns/dnsseckeeper.hh
+++ b/pdns/dnsseckeeper.hh
@@ -256,24 +256,27 @@ private:
   
   };
   
+  struct KeyCacheTag{};
+  struct CompositeTag{};
+  struct SequencedTag{};
   
   typedef multi_index_container<
     KeyCacheEntry,
     indexed_by<
-      ordered_unique<member<KeyCacheEntry, DNSName, &KeyCacheEntry::d_domain> >,
-      sequenced<>
+    ordered_unique<tag<KeyCacheTag>,member<KeyCacheEntry, DNSName, &KeyCacheEntry::d_domain> >,
+    sequenced<tag<SequencedTag>>
     >
   > keycache_t;
   typedef multi_index_container<
     METACacheEntry,
     indexed_by<
-      ordered_unique<
+      ordered_unique<tag<CompositeTag>,
         composite_key< 
           METACacheEntry, 
           member<METACacheEntry, DNSName, &METACacheEntry::d_domain> ,
           member<METACacheEntry, std::string, &METACacheEntry::d_key>
         >, composite_key_compare<std::less<DNSName>, CIStringCompare> >,
-      sequenced<>
+      sequenced<tag<SequencedTag>>
     >
   > metacache_t;
 

diff --git a/pdns/recpacketcache.cc b/pdns/recpacketcache.cc
index e474b0d218b3d093e34653616f2fa58522a9d42b..1b952ba19670044ea9ea5a9d8617cb40ef3abcd2 100644 (file)
--- a/pdns/recpacketcache.cc
+++ b/pdns/recpacketcache.cc
@@ -73,7 +73,7 @@ bool RecursorPacketCache::checkResponseMatches(std::pair<packetCache_t::index<Ha
       }
 
       d_hits++;
-      moveCacheItemToBack(d_packetCache, iter);
+      moveCacheItemToBack<SequencedTag>(d_packetCache, iter);
 #ifdef HAVE_PROTOBUF
       if (protobufMessage) {
         if (iter->d_protobufMessage) {
@@ -88,7 +88,7 @@ bool RecursorPacketCache::checkResponseMatches(std::pair<packetCache_t::index<Ha
       return true;
     }
     else {
-      moveCacheItemToFront(d_packetCache, iter); 
+      moveCacheItemToFront<SequencedTag>(d_packetCache, iter); 
       d_misses++;
       break;
     }
@@ -161,7 +161,7 @@ void RecursorPacketCache::insertResponsePacket(unsigned int tag, uint32_t qhash,
       continue;
     }
 
-    moveCacheItemToBack(d_packetCache, iter);
+    moveCacheItemToBack<SequencedTag>(d_packetCache, iter);
     iter->d_packet = std::move(responsePacket);
     iter->d_query = std::move(query);
     iter->d_ecsBegin = ecsBegin;
@@ -214,7 +214,7 @@ uint64_t RecursorPacketCache::bytes()
 
 void RecursorPacketCache::doPruneTo(unsigned int maxCached)
 {
-  pruneCollection(*this, d_packetCache, maxCached);
+  pruneCollection<SequencedTag>(*this, d_packetCache, maxCached);
 }
 
 uint64_t RecursorPacketCache::doDump(int fd)

diff --git a/pdns/recpacketcache.hh b/pdns/recpacketcache.hh
index 395d9101c8db2b762a7dc8b2130574d891f7213c..c1930cddfa2f4248f51ecadd6a7ec6619af30110 100644 (file)
--- a/pdns/recpacketcache.hh
+++ b/pdns/recpacketcache.hh
@@ -98,11 +98,12 @@ private:
     }
   };
 
+  struct SequencedTag{};
   typedef multi_index_container<
     Entry,
     indexed_by  <
       hashed_non_unique<tag<HashTag>, composite_key<Entry, member<Entry,uint32_t,&Entry::d_tag>, member<Entry,uint32_t,&Entry::d_qhash> > >,
-      sequenced<> ,
+      sequenced<tag<SequencedTag>> ,
       ordered_non_unique<tag<NameTag>, member<Entry,DNSName,&Entry::d_name>, CanonDNSNameCompare >
       >
   > packetCache_t;

diff --git a/pdns/recursor_cache.cc b/pdns/recursor_cache.cc
index 7e0bf054ce2b5c4193c5bdd03cdd289492588fce..ca1f8bd1cbe029bc07fcf12ed2de378790bd6417 100644 (file)
--- a/pdns/recursor_cache.cc
+++ b/pdns/recursor_cache.cc
@@ -78,7 +78,7 @@ int32_t MemRecursorCache::handleHit(MemRecursorCache::OrderedTagIterator_t& entr
     *wasAuth = entry->d_auth;
   }
 
-  moveCacheItemToBack(d_cache, entry);
+  moveCacheItemToBack<SequencedTag>(d_cache, entry);
 
   return ttd;
 }
@@ -116,7 +116,7 @@ MemRecursorCache::cache_t::const_iterator MemRecursorCache::getEntryUsingECSInde
       }
       else {
         /* this netmask-specific entry has expired */
-        moveCacheItemToFront(d_cache, entry);
+        moveCacheItemToFront<SequencedTag>(d_cache, entry);
         ecsIndex->removeNetmask(best);
         if (ecsIndex->isEmpty()) {
           d_ecsIndex.erase(ecsIndex);
@@ -136,7 +136,7 @@ MemRecursorCache::cache_t::const_iterator MemRecursorCache::getEntryUsingECSInde
       }
     }
     else {
-      moveCacheItemToFront(d_cache, entry);
+      moveCacheItemToFront<SequencedTag>(d_cache, entry);
     }
   }
 
@@ -217,7 +217,7 @@ int32_t MemRecursorCache::get(time_t now, const DNSName &qname, const QType& qt,
 
       auto firstIndexIterator = d_cache.project<OrderedTag>(i);
       if (i->d_ttd <= now) {
-        moveCacheItemToFront(d_cache, firstIndexIterator);
+        moveCacheItemToFront<SequencedTag>(d_cache, firstIndexIterator);
         continue;
       }
 
@@ -311,7 +311,7 @@ void MemRecursorCache::replace(time_t now, const DNSName &qname, const QType& qt
   }
 
   if (!isNew) {
-    moveCacheItemToBack(d_cache, stored);
+    moveCacheItemToBack<SequencedTag>(d_cache, stored);
   }
   d_cache.replace(stored, ce);
 }
@@ -480,6 +480,6 @@ void MemRecursorCache::doPrune(unsigned int keep)
 {
   d_cachecachevalid=false;
 
-  pruneCollection(*this, d_cache, keep);
+  pruneCollection<SequencedTag>(*this, d_cache, keep);
 }
 

diff --git a/pdns/recursordist/negcache.cc b/pdns/recursordist/negcache.cc
index 54399b75c1f433f2e5f338374ade440b69a2f1f3..a48107e761c633f0f8cb057635897ed6636c6b6e 100644 (file)
--- a/pdns/recursordist/negcache.cc
+++ b/pdns/recursordist/negcache.cc
@@ -50,10 +50,10 @@ bool NegCache::getRootNXTrust(const DNSName& qname, const struct timeval& now, c
     // We have something
     if ((uint32_t)now.tv_sec < ni->d_ttd) {
       *ne = &(*ni);
-      moveCacheItemToBack(d_negcache, ni);
+      moveCacheItemToBack<SequenceTag>(d_negcache, ni);
       return true;
     }
-    moveCacheItemToFront(d_negcache, ni);
+    moveCacheItemToFront<SequenceTag>(d_negcache, ni);
     ++ni;
   }
   return false;
@@ -83,11 +83,11 @@ bool NegCache::get(const DNSName& qname, const QType& qtype, const struct timeva
       if ((uint32_t)now.tv_sec < ni->d_ttd) {
         // Not expired
         *ne = &(*ni);
-        moveCacheItemToBack(d_negcache, firstIndexIterator);
+        moveCacheItemToBack<SequenceTag>(d_negcache, firstIndexIterator);
         return true;
       }
       // expired
-      moveCacheItemToFront(d_negcache, firstIndexIterator);
+      moveCacheItemToFront<SequenceTag>(d_negcache, firstIndexIterator);
     }
     ++ni;
   }
@@ -101,7 +101,7 @@ bool NegCache::get(const DNSName& qname, const QType& qtype, const struct timeva
  */
 void NegCache::add(const NegCacheEntry& ne)
 {
-  lruReplacingInsert(d_negcache, ne);
+  lruReplacingInsert<SequenceTag>(d_negcache, ne);
 }
 
 /*!
@@ -185,7 +185,7 @@ void NegCache::clear()
  */
 void NegCache::prune(unsigned int maxEntries)
 {
-  pruneCollection(*this, d_negcache, maxEntries, 200);
+  pruneCollection<SequenceTag>(*this, d_negcache, maxEntries, 200);
 }
 
 /*!
@@ -199,7 +199,7 @@ uint64_t NegCache::dumpToFile(FILE* fp)
   struct timeval now;
   Utility::gettimeofday(&now, nullptr);
 
-  negcache_sequence_t& sidx = d_negcache.get<1>();
+  negcache_sequence_t& sidx = d_negcache.get<SequenceTag>();
   for (const NegCacheEntry& ne : sidx) {
     ret++;
     fprintf(fp, "%s %" PRId64 " IN %s VIA %s ; (%s)\n", ne.d_name.toString().c_str(), static_cast<int64_t>(ne.d_ttd - now.tv_sec), ne.d_qtype.getName().c_str(), ne.d_auth.toString().c_str(), vStates[ne.d_validationState]);

diff --git a/pdns/recursordist/negcache.hh b/pdns/recursordist/negcache.hh
index e8d2b49cbab417d96ba78c8f6015d2c7ce10217f..2dbabb0f4be514238399a9c1f73749dc15b1a902 100644 (file)
--- a/pdns/recursordist/negcache.hh
+++ b/pdns/recursordist/negcache.hh
@@ -83,18 +83,24 @@ public:
   }
 
 private:
+  struct CompositeKey
+  {
+  };
+  struct SequenceTag
+  {
+  };
   typedef boost::multi_index_container<
     NegCacheEntry,
     indexed_by<
-      ordered_unique<
+      ordered_unique<tag<CompositeKey>,
         composite_key<
           NegCacheEntry,
           member<NegCacheEntry, DNSName, &NegCacheEntry::d_name>,
           member<NegCacheEntry, QType, &NegCacheEntry::d_qtype>>,
         composite_key_compare<
           CanonDNSNameCompare, std::less<QType>>>,
-      sequenced<>,
-      hashed_non_unique<
+      sequenced<tag<SequenceTag>>,
+      hashed_non_unique<tag<NegCacheEntry>,
         member<NegCacheEntry, DNSName, &NegCacheEntry::d_name>>>>
     negcache_t;