[2100] make the new implementation compile.

added a mostly-empty implementation of ZoneData.
at this point it's nothing more than "buildable" code.  tests still don't pass.

src/lib/datasrc/memory/Makefile.am

@@ -10,7 +10,6 @@ CLEANFILES = *.gcno *.gcda datasrc_messages.h datasrc_messages.cc
 
 noinst_LTLIBRARIES = libdatasrc_memory.la
 
-libdatasrc_memory_la_SOURCES = \
-	rdata_encoder.h \
-	rdata_encoder.cc \
-	domaintree.h
+libdatasrc_memory_la_SOURCES = rdata_encoder.h rdata_encoder.cc
+libdatasrc_memory_la_SOURCES += domaintree.h
+libdatasrc_memory_la_SOURCES += zone_table.h zone_table.cc

src/lib/datasrc/memory/tests/Makefile.am

@@ -20,6 +20,7 @@ TESTS += run_unittests
 run_unittests_SOURCES = run_unittests.cc
 run_unittests_SOURCES += rdata_encoder_unittest.cc
 run_unittests_SOURCES += domaintree_unittest.cc
+run_unittests_SOURCES += zone_table_unittest.cc
 
 run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES)
 run_unittests_LDFLAGS  = $(AM_LDFLAGS)  $(GTEST_LDFLAGS)

src/lib/datasrc/memory/tests/zone_table_unittest.cc

@@ -19,7 +19,9 @@
 #include <dns/name.h>
 #include <dns/rrclass.h>
 
-#include <datasrc/zonetable.h>
+#include <datasrc/result.h>
+#include <datasrc/memory/zone_data.h>
+#include <datasrc/memory/zone_table.h>
 // We use InMemoryZone to put something into the table
 #include <datasrc/memory_datasrc.h>
 
@@ -27,80 +29,66 @@
 
 using namespace isc::dns;
 using namespace isc::datasrc;
+using namespace isc::datasrc::memory;
 
 namespace {
-TEST(ZoneTest, init) {
-    InMemoryZoneFinder zone(RRClass::IN(), Name("example.com"));
-    EXPECT_EQ(Name("example.com"), zone.getOrigin());
-    EXPECT_EQ(RRClass::IN(), zone.getClass());
-
-    InMemoryZoneFinder ch_zone(RRClass::CH(), Name("example"));
-    EXPECT_EQ(Name("example"), ch_zone.getOrigin());
-    EXPECT_EQ(RRClass::CH(), ch_zone.getClass());
-}
-
-TEST(ZoneTest, find) {
-    InMemoryZoneFinder zone(RRClass::IN(), Name("example.com"));
-    EXPECT_EQ(ZoneFinder::NXDOMAIN,
-              zone.find(Name("www.example.com"), RRType::A())->code);
-}
-
 class ZoneTableTest : public ::testing::Test {
 protected:
-    ZoneTableTest() : zone1(new InMemoryZoneFinder(RRClass::IN(),
-                                                   Name("example.com"))),
-                      zone2(new InMemoryZoneFinder(RRClass::IN(),
-                                                   Name("example.net"))),
-                      zone3(new InMemoryZoneFinder(RRClass::IN(),
-                                                   Name("example"))),
+    ZoneTableTest() : zname1(Name("example.com")),
+                      zname2(Name("example.net")),
+                      zname3(Name("example")),
+                      zone1(new ZoneData(RRClass::IN(), zname1)),
+                      zone2(new ZoneData(RRClass::IN(), zname2)),
+                      zone3(new ZoneData(RRClass::IN(), zname3)),
                       zone_table(ZoneTable::create(mem_sgmt_))
     {}
 
     ~ZoneTableTest() {
         ZoneTable::destroy(mem_sgmt_, zone_table);
     }
-    ZoneFinderPtr zone1, zone2, zone3;
+    const Name zname1, zname2, zname3;
+    ZoneData* zone1;
+    ZoneData* zone2;
+    ZoneData* zone3;
     isc::util::MemorySegmentLocal mem_sgmt_;
     ZoneTable* zone_table;
 };
 
 TEST_F(ZoneTableTest, addZone) {
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone1));
-    EXPECT_EQ(result::EXIST, zone_table->addZone(mem_sgmt_, zone1));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname1, zone1));
+    EXPECT_EQ(result::EXIST, zone_table->addZone(mem_sgmt_, zname1, zone1));
     // names are compared in a case insensitive manner.
     EXPECT_EQ(result::EXIST, zone_table->addZone(
-                  mem_sgmt_,
-                  ZoneFinderPtr(new InMemoryZoneFinder(RRClass::IN(),
-                                                       Name("EXAMPLE.COM")))));
+                  mem_sgmt_, Name("EXAMPLE.COM"),
+                  new ZoneData(RRClass::IN(), Name("EXAMPLE.COM"))));
 
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone2));
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone3));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname2, zone2));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname3, zone3));
 
     // Zone table is indexed only by name.  Duplicate origin name with
     // different zone class isn't allowed.
     EXPECT_EQ(result::EXIST, zone_table->addZone(
-                  mem_sgmt_,
-                  ZoneFinderPtr(new InMemoryZoneFinder(RRClass::CH(),
-                                                       Name("example.com")))));
+                  mem_sgmt_, Name("example.com"),
+                  new ZoneData(RRClass::CH(), Name("example.com"))));
 
     /// Bogus zone (NULL)
-    EXPECT_THROW(zone_table->addZone(mem_sgmt_, ZoneFinderPtr()),
+    EXPECT_THROW(zone_table->addZone(mem_sgmt_, zname1, NULL),
                  isc::InvalidParameter);
 }
 
 TEST_F(ZoneTableTest, DISABLED_removeZone) {
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone1));
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone2));
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone3));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname1, zone1));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname2, zone2));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname3, zone3));
 
     EXPECT_EQ(result::SUCCESS, zone_table->removeZone(Name("example.net")));
     EXPECT_EQ(result::NOTFOUND, zone_table->removeZone(Name("example.net")));
 }
 
 TEST_F(ZoneTableTest, findZone) {
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone1));
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone2));
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone3));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname1, zone1));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname2, zone2));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zname3, zone3));
 
     EXPECT_EQ(result::SUCCESS, zone_table->findZone(Name("example.com")).code);
     EXPECT_EQ(Name("example.com"),
@@ -120,8 +108,10 @@ TEST_F(ZoneTableTest, findZone) {
 
     // make sure the partial match is indeed the longest match by adding
     // a zone with a shorter origin and query again.
-    ZoneFinderPtr zone_com(new InMemoryZoneFinder(RRClass::IN(), Name("com")));
-    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_, zone_com));
+    EXPECT_EQ(result::SUCCESS, zone_table->addZone(mem_sgmt_,
+                                                   Name("com"),
+                                                   new ZoneData(RRClass::IN(),
+                                                                Name("com"))));
     EXPECT_EQ(Name("example.com"),
               zone_table->findZone(Name("www.example.com")).zone->getOrigin());
 }

src/lib/datasrc/memory/zone_data.h

@@ -0,0 +1,42 @@
+// Copyright (C) 2012  Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef DATASRC_MEMORY_ZONE_DATA_H
+#define DATASRC_MEMORY_ZONE_DATA_H 1
+
+#include <dns/name.h>
+#include <dns/rrclass.h>
+
+namespace isc {
+namespace datasrc {
+namespace memory {
+class ZoneData {
+public:
+    ZoneData(dns::RRClass zone_class, const dns::Name& zone_name) :
+        zone_class_(zone_class), zone_name_(zone_name)
+    {}
+
+private:
+    const dns::RRClass zone_class_;
+    const dns::Name zone_name_;
+};
+} // namespace memory
+} // namespace datasrc
+} // namespace isc
+
+#endif // DATASRC_MEMORY_ZONE_DATA_H
+
+// Local Variables:
+// mode: c++
+// End:

src/lib/datasrc/memory/zone_table.cc

@@ -16,8 +16,9 @@
 
 #include <dns/name.h>
 
-#include <datasrc/zonetable.h>
-#include <datasrc/rbtree.h>
+#include <datasrc/memory/zone_data.h>
+#include <datasrc/memory/zone_table.h>
+#include <datasrc/memory/domaintree.h>
 
 #include <cassert>
 
@@ -26,19 +27,27 @@ using namespace isc::dns;
 
 namespace isc {
 namespace datasrc {
+namespace memory {
+
+namespace {
+struct ZoneDataDeleter {
+    ZoneDataDeleter() {}
+    void operator()(util::MemorySegment&, ZoneData*) const {}
+};
+}
 
 /// \short Private data and implementation of ZoneTable
 struct ZoneTable::ZoneTableImpl {
     // Type aliases to make it shorter
-    typedef RBTree<ZoneFinder> ZoneTree;
-    typedef RBNode<ZoneFinder> ZoneNode;
+    typedef DomainTree<ZoneData, ZoneDataDeleter> ZoneTableTree;
+    typedef DomainTreeNode<ZoneData, ZoneDataDeleter> ZoneTableNode;
 
     // The actual storage
-    ZoneTree* zones_;
+    ZoneTableTree* zones_;
 
     // Constructor
     ZoneTableImpl(util::MemorySegment& mem_sgmt) :
-        zones_(ZoneTree::create(mem_sgmt))
+        zones_(ZoneTableTree::create(mem_sgmt))
     {}
 
     /*
@@ -48,30 +57,32 @@ struct ZoneTable::ZoneTableImpl {
      */
 
     // Implementation of ZoneTable::addZone
-    result::Result addZone(util::MemorySegment& mem_sgmt, ZoneFinderPtr zone) {
+    result::Result addZone(util::MemorySegment& mem_sgmt,
+                           const Name& zone_name, ZoneData* zone_data)
+    {
         // Sanity check
-        if (!zone) {
+        if (zone_data == NULL) {
             isc_throw(InvalidParameter,
                       "Null pointer is passed to ZoneTable::addZone()");
         }
 
         // Get the node where we put the zone
-        ZoneNode* node(NULL);
-        switch (zones_->insert(mem_sgmt, zone->getOrigin(), &node)) {
+        ZoneTableNode* node(NULL);
+        switch (zones_->insert(mem_sgmt, zone_name, &node)) {
             // This is OK
-            case ZoneTree::SUCCESS:
-            case ZoneTree::ALREADYEXISTS:
+            case ZoneTableTree::SUCCESS:
+            case ZoneTableTree::ALREADYEXISTS:
                 break;
             // Can Not Happen
             default:
                 assert(0);
         }
         // Can Not Happen
-        assert(node);
+        assert(node != NULL);
 
         // Is it empty? We either just created it or it might be nonterminal
         if (node->isEmpty()) {
-            node->setData(zone);
+            node->setData(mem_sgmt, zone_data);
             return (result::SUCCESS);
         } else { // There's something there already
             return (result::EXIST);
@@ -80,19 +91,19 @@ struct ZoneTable::ZoneTableImpl {
 
     // Implementation of ZoneTable::findZone
     ZoneTable::FindResult findZone(const Name& name) const {
-        ZoneNode *node(NULL);
+        ZoneTableNode* node(NULL);
         result::Result my_result;
 
         // Translate the return codes
         switch (zones_->find(name, &node)) {
-            case ZoneTree::EXACTMATCH:
+            case ZoneTableTree::EXACTMATCH:
                 my_result = result::SUCCESS;
                 break;
-            case ZoneTree::PARTIALMATCH:
+            case ZoneTableTree::PARTIALMATCH:
                 my_result = result::PARTIALMATCH;
                 break;
             // We have no data there, so translate the pointer to NULL as well
-            case ZoneTree::NOTFOUND:
+            case ZoneTableTree::NOTFOUND:
                 return (FindResult(result::NOTFOUND, ZoneFinderPtr()));
             // Can Not Happen
             default:
@@ -102,9 +113,11 @@ struct ZoneTable::ZoneTableImpl {
         }
 
         // Can Not Happen (remember, NOTFOUND is handled)
-        assert(node);
+        assert(node != NULL);
 
-        return (FindResult(my_result, node->getData()));
+        // Temporarily return an easy fake value
+        return (FindResult(result::NOTFOUND, ZoneFinderPtr()));
+        //return (FindResult(my_result, node->getData()));
     }
 };
 
@@ -133,14 +146,16 @@ ZoneTable::create(util::MemorySegment& mem_sgmt) {
 
 void
 ZoneTable::destroy(util::MemorySegment& mem_sgmt, ZoneTable* ztable) {
-    ZoneTableImpl::ZoneTree::destroy(mem_sgmt, ztable->impl_->zones_);
+    ZoneTableImpl::ZoneTableTree::destroy(mem_sgmt, ztable->impl_->zones_);
     ztable->~ZoneTable();
     mem_sgmt.deallocate(ztable, sizeof(ZoneTable));
 }
 
 result::Result
-ZoneTable::addZone(util::MemorySegment& mem_sgmt, ZoneFinderPtr zone) {
-    return (impl_->addZone(mem_sgmt, zone));
+ZoneTable::addZone(util::MemorySegment& mem_sgmt, const Name& zone_name,
+                   ZoneData* zone_data)
+{
+    return (impl_->addZone(mem_sgmt, zone_name, zone_data));
 }
 
 result::Result
@@ -156,5 +171,6 @@ ZoneTable::findZone(const Name& name) const {
     return (impl_->findZone(name));
 }
 
+} // end of namespace memory
 } // end of namespace datasrc
 } // end of namespace isc

src/lib/datasrc/memory/zone_table.h

@@ -30,6 +30,8 @@ class RRClass;
 }
 
 namespace datasrc {
+namespace memory {
+class ZoneData;
 
 /// \brief A set of authoritative zones.
 ///
@@ -114,7 +116,8 @@ public:
     /// added to the zone table.
     /// \return \c result::EXIST The zone table already contains
     /// zone of the same origin.
-    result::Result addZone(util::MemorySegment& mem_sgmt, ZoneFinderPtr zone);
+    result::Result addZone(util::MemorySegment& mem_sgmt,
+                           const dns::Name& zone_name, ZoneData* zone_data);
 
     /// Remove a \c Zone of the given origin name from the \c ZoneTable.
     ///
@@ -153,6 +156,7 @@ private:
 };
 }
 }
+}
 #endif  // __ZONETABLE_H
 
 // Local Variables: