[2100] simplify: move definitions to the main class instead of pimpl.

this is mostly private class and is not expected to be referenced outside
of this psuedo module ("memory"), so it's raltively safer.
also, the ZoneTable structure will be embedable in a shared memory space,
so introducing the another pointer indirection will make it unnecessarily
complicated.

still don't pass tests.

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

@@ -22,8 +22,6 @@
 #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>
 
 #include <gtest/gtest.h>
 

src/lib/datasrc/memory/zone_table.cc

@@ -29,106 +29,10 @@ 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 DomainTree<ZoneData, ZoneDataDeleter> ZoneTableTree;
-    typedef DomainTreeNode<ZoneData, ZoneDataDeleter> ZoneTableNode;
-
-    // The actual storage
-    ZoneTableTree* zones_;
-
-    // Constructor
-    ZoneTableImpl(util::MemorySegment& mem_sgmt) :
-        zones_(ZoneTableTree::create(mem_sgmt))
-    {}
-
-    /*
-     * The implementation methods are here and just wrap-called in the
-     * ZoneTable. We have variables locally (without impl_->), have
-     * type aliases, etc. And they will get inlined anyway.
-     */
-
-    // Implementation of ZoneTable::addZone
-    result::Result addZone(util::MemorySegment& mem_sgmt,
-                           const Name& zone_name, ZoneData* zone_data)
-    {
-        // Sanity check
-        if (zone_data == NULL) {
-            isc_throw(InvalidParameter,
-                      "Null pointer is passed to ZoneTable::addZone()");
-        }
-
-        // Get the node where we put the zone
-        ZoneTableNode* node(NULL);
-        switch (zones_->insert(mem_sgmt, zone_name, &node)) {
-            // This is OK
-            case ZoneTableTree::SUCCESS:
-            case ZoneTableTree::ALREADYEXISTS:
-                break;
-            // Can Not Happen
-            default:
-                assert(0);
-        }
-        // Can Not Happen
-        assert(node != NULL);
-
-        // Is it empty? We either just created it or it might be nonterminal
-        if (node->isEmpty()) {
-            node->setData(mem_sgmt, zone_data);
-            return (result::SUCCESS);
-        } else { // There's something there already
-            return (result::EXIST);
-        }
-    }
-
-    // Implementation of ZoneTable::findZone
-    ZoneTable::FindResult findZone(const Name& name) const {
-        ZoneTableNode* node(NULL);
-        result::Result my_result;
-
-        // Translate the return codes
-        switch (zones_->find(name, &node)) {
-            case ZoneTableTree::EXACTMATCH:
-                my_result = result::SUCCESS;
-                break;
-            case ZoneTableTree::PARTIALMATCH:
-                my_result = result::PARTIALMATCH;
-                break;
-            // We have no data there, so translate the pointer to NULL as well
-            case ZoneTableTree::NOTFOUND:
-                return (FindResult(result::NOTFOUND, ZoneFinderPtr()));
-            // Can Not Happen
-            default:
-                assert(0);
-                // Because of warning
-                return (FindResult(result::NOTFOUND, ZoneFinderPtr()));
-        }
-
-        // Can Not Happen (remember, NOTFOUND is handled)
-        assert(node != NULL);
-
-        // Temporarily return an easy fake value
-        return (FindResult(result::NOTFOUND, ZoneFinderPtr()));
-        //return (FindResult(my_result, node->getData()));
-    }
-};
-
 ZoneTable::ZoneTable(util::MemorySegment& mem_sgmt) :
-    impl_(new ZoneTableImpl(mem_sgmt))
+    zones_(ZoneTableTree::create(mem_sgmt))
 {}
 
-ZoneTable::~ZoneTable() {
-    delete impl_;
-}
-
 ZoneTable*
 ZoneTable::create(util::MemorySegment& mem_sgmt) {
     // The ZoneTable constructor can throw, so we need to prevent memory leak.
@@ -146,8 +50,7 @@ ZoneTable::create(util::MemorySegment& mem_sgmt) {
 
 void
 ZoneTable::destroy(util::MemorySegment& mem_sgmt, ZoneTable* ztable) {
-    ZoneTableImpl::ZoneTableTree::destroy(mem_sgmt, ztable->impl_->zones_);
-    ztable->~ZoneTable();
+    ZoneTableTree::destroy(mem_sgmt, ztable->zones_);
     mem_sgmt.deallocate(ztable, sizeof(ZoneTable));
 }
 
@@ -155,7 +58,33 @@ result::Result
 ZoneTable::addZone(util::MemorySegment& mem_sgmt, const Name& zone_name,
                    ZoneData* zone_data)
 {
-    return (impl_->addZone(mem_sgmt, zone_name, zone_data));
+    // Sanity check
+    if (zone_data == NULL) {
+        isc_throw(InvalidParameter,
+                  "Null pointer is passed to ZoneTable::addZone()");
+    }
+
+    // Get the node where we put the zone
+    ZoneTableNode* node(NULL);
+    switch (zones_->insert(mem_sgmt, zone_name, &node)) {
+        // This is OK
+    case ZoneTableTree::SUCCESS:
+    case ZoneTableTree::ALREADYEXISTS:
+        break;
+        // Can Not Happen
+    default:
+        assert(0);
+    }
+    // Can Not Happen
+    assert(node != NULL);
+
+    // Is it empty? We either just created it or it might be nonterminal
+    if (node->isEmpty()) {
+        node->setData(mem_sgmt, zone_data);
+        return (result::SUCCESS);
+    } else { // There's something there already
+        return (result::EXIST);
+    }
 }
 
 result::Result
@@ -168,7 +97,33 @@ ZoneTable::removeZone(const Name&) {
 
 ZoneTable::FindResult
 ZoneTable::findZone(const Name& name) const {
-    return (impl_->findZone(name));
+    ZoneTableNode* node(NULL);
+    result::Result my_result;
+
+    // Translate the return codes
+    switch (zones_->find(name, &node)) {
+    case ZoneTableTree::EXACTMATCH:
+        my_result = result::SUCCESS;
+        break;
+    case ZoneTableTree::PARTIALMATCH:
+        my_result = result::PARTIALMATCH;
+        break;
+        // We have no data there, so translate the pointer to NULL as well
+    case ZoneTableTree::NOTFOUND:
+        return (FindResult(result::NOTFOUND, ZoneFinderPtr()));
+        // Can Not Happen
+    default:
+        assert(0);
+        // Because of warning
+        return (FindResult(result::NOTFOUND, ZoneFinderPtr()));
+    }
+
+    // Can Not Happen (remember, NOTFOUND is handled)
+    assert(node != NULL);
+
+    // Temporarily return an easy fake value
+    return (FindResult(result::NOTFOUND, ZoneFinderPtr()));
+    //return (FindResult(my_result, node->getData()));
 }
 
 } // end of namespace memory

src/lib/datasrc/memory/zone_table.h

@@ -12,14 +12,16 @@
 // OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 // PERFORMANCE OF THIS SOFTWARE.
 
-#ifndef __ZONETABLE_H
-#define __ZONETABLE_H 1
+#ifndef __DATASRC_MEMORY_ZONE_TABLE_H
+#define __DATASRC_MEMORY_ZONE_TABLE_H 1
 
 #include <util/memory_segment.h>
 
 #include <dns/rrset.h>
 
 #include <datasrc/zone.h>
+#include <datasrc/memory/domaintree.h>
+#include <datasrc/memory/zone_table.h>
 
 #include <boost/shared_ptr.hpp>
 
@@ -71,12 +73,6 @@ private:
     /// it fails, a corresponding standard exception will be thrown.
     /// It never throws an exception otherwise.
     ZoneTable(util::MemorySegment& mem_sgmt);
-
-    /// The destructor.
-    ///
-    /// An object of this class is always expected to be destroyed explicitly
-    /// by \c destroy(), so the constructor is hidden as private.
-    ~ZoneTable();
     //@}
 
 public:
@@ -151,13 +147,21 @@ public:
     FindResult findZone(const isc::dns::Name& name) const;
 
 private:
-    struct ZoneTableImpl;
-    ZoneTableImpl* impl_;
+    struct ZoneDataDeleter {
+        ZoneDataDeleter() {}
+        void operator()(util::MemorySegment&, ZoneData*) const {}
+    };
+
+    // Type aliases to make it shorter
+    typedef DomainTree<ZoneData, ZoneDataDeleter> ZoneTableTree;
+    typedef DomainTreeNode<ZoneData, ZoneDataDeleter> ZoneTableNode;
+
+    ZoneTableTree* zones_;
 };
 }
 }
 }
-#endif  // __ZONETABLE_H
+#endif  // __DATASRC_MEMORY_ZONE_TABLE_H
 
 // Local Variables:
 // mode: c++