[2208] Use consistent naming for ZoneTableSegment variables

src/bin/auth/tests/auth_srv_unittest.cc

@@ -73,6 +73,7 @@ using namespace isc::asiodns;
 using namespace isc::asiolink;
 using namespace isc::testutils;
 using namespace isc::server_common::portconfig;
+using isc::datasrc::memory::ZoneTableSegment;
 using isc::UnitTestUtil;
 using boost::scoped_ptr;
 
@@ -1402,7 +1403,7 @@ public:
         ConfigurableClientList(RRClass::IN()),
         real_(real_list),
         config_(Element::fromJSON("{}")),
-        segment_(isc::datasrc::memory::ZoneTableSegment::create(*config_))
+        ztable_segment_(ZoneTableSegment::create(*config_))
     {
         BOOST_FOREACH(const DataSourceInfo& info, real_->getDataSources()) {
              const isc::datasrc::DataSourceClientPtr
@@ -1414,13 +1415,13 @@ public:
              data_sources_.push_back(
                  DataSourceInfo(client.get(),
                                 isc::datasrc::DataSourceClientContainerPtr(),
-                                false, RRClass::IN(), segment_));
+                                false, RRClass::IN(), ztable_segment_));
         }
     }
 private:
     const boost::shared_ptr<isc::datasrc::ConfigurableClientList> real_;
     const ConstElementPtr config_;
-    boost::shared_ptr<isc::datasrc::memory::ZoneTableSegment> segment_;
+    boost::shared_ptr<ZoneTableSegment> ztable_segment_;
     vector<isc::datasrc::DataSourceClientPtr> clients_;
 };
 

src/lib/datasrc/client_list.h

@@ -300,14 +300,17 @@ public:
     /// \todo The content yet to be defined.
     struct DataSourceInfo {
         // Plays a role of default constructor too (for vector)
-        DataSourceInfo(const dns::RRClass& rrclass, boost::shared_ptr
-                           <isc::datasrc::memory::ZoneTableSegment>& segment,
+        DataSourceInfo(const dns::RRClass& rrclass,
+                       boost::shared_ptr
+                           <isc::datasrc::memory::ZoneTableSegment>&
+                               ztable_segment,
                        bool has_cache = false);
         DataSourceInfo(DataSourceClient* data_src_client,
                        const DataSourceClientContainerPtr& container,
                        bool has_cache, const dns::RRClass& rrclass,
                        boost::shared_ptr
-                           <isc::datasrc::memory::ZoneTableSegment>& segment);
+                           <isc::datasrc::memory::ZoneTableSegment>&
+                               ztable_segment);
         DataSourceClient* data_src_client_;
         DataSourceClientContainerPtr container_;
 

src/lib/datasrc/memory/memory_client.cc

@@ -66,18 +66,18 @@ public:
 
 } // end of unnamed namespace
 
-InMemoryClient::InMemoryClient(shared_ptr<ZoneTableSegment> zone_table_segment,
+InMemoryClient::InMemoryClient(shared_ptr<ZoneTableSegment> ztable_segment,
                                RRClass rrclass) :
-    zone_table_segment_(zone_table_segment),
+    ztable_segment_(ztable_segment),
     rrclass_(rrclass),
     zone_count_(0),
     file_name_tree_(FileNameTree::create(
-        zone_table_segment_->getMemorySegment(), false))
+        ztable_segment_->getMemorySegment(), false))
 {
 }
 
 InMemoryClient::~InMemoryClient() {
-    MemorySegment& mem_sgmt = zone_table_segment_->getMemorySegment();
+    MemorySegment& mem_sgmt = ztable_segment_->getMemorySegment();
     FileNameDeleter deleter;
     FileNameTree::destroy(mem_sgmt, file_name_tree_, deleter);
 }
@@ -87,7 +87,7 @@ InMemoryClient::loadInternal(const isc::dns::Name& zone_name,
                              const std::string& filename,
                              ZoneData* zone_data)
 {
-    MemorySegment& mem_sgmt = zone_table_segment_->getMemorySegment();
+    MemorySegment& mem_sgmt = ztable_segment_->getMemorySegment();
     SegmentObjectHolder<ZoneData, RRClass> holder(
         mem_sgmt, zone_data, rrclass_);
 
@@ -112,7 +112,7 @@ InMemoryClient::loadInternal(const isc::dns::Name& zone_name,
     const std::string* tstr = node->setData(new std::string(filename));
     delete tstr;
 
-    ZoneTable* zone_table = zone_table_segment_->getHeader().getTable();
+    ZoneTable* zone_table = ztable_segment_->getHeader().getTable();
     const ZoneTable::AddResult result(zone_table->addZone(mem_sgmt, rrclass_,
                                                           zone_name,
                                                           holder.release()));
@@ -144,7 +144,7 @@ InMemoryClient::findZone(const isc::dns::Name& zone_name) const {
     LOG_DEBUG(logger, DBG_TRACE_DATA,
               DATASRC_MEMORY_MEM_FIND_ZONE).arg(zone_name);
 
-    const ZoneTable* zone_table = zone_table_segment_->getHeader().getTable();
+    const ZoneTable* zone_table = ztable_segment_->getHeader().getTable();
     ZoneTable::FindResult result(zone_table->findZone(zone_name));
 
     ZoneFinderPtr finder;
@@ -157,7 +157,7 @@ InMemoryClient::findZone(const isc::dns::Name& zone_name) const {
 
 const ZoneData*
 InMemoryClient::findZoneData(const isc::dns::Name& zone_name) {
-    const ZoneTable* zone_table = zone_table_segment_->getHeader().getTable();
+    const ZoneTable* zone_table = ztable_segment_->getHeader().getTable();
     ZoneTable::FindResult result(zone_table->findZone(zone_name));
     return (result.zone_data);
 }
@@ -169,7 +169,7 @@ InMemoryClient::load(const isc::dns::Name& zone_name,
     LOG_DEBUG(logger, DBG_TRACE_BASIC, DATASRC_MEMORY_MEM_LOAD).arg(zone_name).
         arg(filename);
 
-    MemorySegment& mem_sgmt = zone_table_segment_->getMemorySegment();
+    MemorySegment& mem_sgmt = ztable_segment_->getMemorySegment();
     ZoneData* zone_data = loadZoneData(mem_sgmt, rrclass_, zone_name,
                                        filename);
     return (loadInternal(zone_name, filename, zone_data));
@@ -177,7 +177,7 @@ InMemoryClient::load(const isc::dns::Name& zone_name,
 
 result::Result
 InMemoryClient::load(const isc::dns::Name& zone_name, ZoneIterator& iterator) {
-    MemorySegment& mem_sgmt = zone_table_segment_->getMemorySegment();
+    MemorySegment& mem_sgmt = ztable_segment_->getMemorySegment();
     ZoneData* zone_data = loadZoneData(mem_sgmt, rrclass_, zone_name,
                                        iterator);
     return (loadInternal(zone_name, string(), zone_data));
@@ -309,7 +309,7 @@ public:
 
 ZoneIteratorPtr
 InMemoryClient::getIterator(const Name& name, bool separate_rrs) const {
-    const ZoneTable* zone_table = zone_table_segment_->getHeader().getTable();
+    const ZoneTable* zone_table = ztable_segment_->getHeader().getTable();
     ZoneTable::FindResult result(zone_table->findZone(name));
     if (result.code != result::SUCCESS) {
         isc_throw(DataSourceError, "No such zone: " + name.toText());

src/lib/datasrc/memory/memory_client.h

@@ -63,7 +63,7 @@ public:
     /// This constructor internally involves resource allocation, and if
     /// it fails, a corresponding standard exception will be thrown.
     /// It never throws an exception otherwise.
-    InMemoryClient(boost::shared_ptr<ZoneTableSegment> zone_table_segment,
+    InMemoryClient(boost::shared_ptr<ZoneTableSegment> ztable_segment,
                    isc::dns::RRClass rrclass);
 
     /// The destructor.
@@ -189,7 +189,7 @@ private:
                                 const std::string& filename,
                                 ZoneData* zone_data);
 
-    boost::shared_ptr<ZoneTableSegment> zone_table_segment_;
+    boost::shared_ptr<ZoneTableSegment> ztable_segment_;
     const isc::dns::RRClass rrclass_;
     unsigned int zone_count_;
     FileNameTree* file_name_tree_;

src/lib/datasrc/tests/client_list_unittest.cc

@@ -257,7 +257,7 @@ public:
             "                \"noiter.org\", \"null.org\"]"
             "}]")),
         config_(Element::fromJSON("{}")),
-        segment_(ZoneTableSegment::create(*config_))
+        ztable_segment_(ZoneTableSegment::create(*config_))
     {
         for (size_t i(0); i < ds_count; ++ i) {
             shared_ptr<MockDataSourceClient>
@@ -265,7 +265,7 @@ public:
             ds_.push_back(ds);
             ds_info_.push_back(ConfigurableClientList::DataSourceInfo(
                                    ds.get(), DataSourceClientContainerPtr(),
-                                   false, rrclass_, segment_));
+                                   false, rrclass_, ztable_segment_));
         }
     }
 
@@ -285,8 +285,8 @@ public:
 
         // Create cache from the temporary data source, and push it to the
         // client list.
-        const shared_ptr<InMemoryClient> cache(new InMemoryClient(segment_,
-                                                                  rrclass_));
+        const shared_ptr<InMemoryClient> cache(
+            new InMemoryClient(ztable_segment_, rrclass_));
         cache->load(zone, *mock_client.getIterator(zone, false));
 
         ConfigurableClientList::DataSourceInfo& dsrc_info =
@@ -369,7 +369,7 @@ public:
     vector<shared_ptr<MockDataSourceClient> > ds_;
     vector<ConfigurableClientList::DataSourceInfo> ds_info_;
     const ConstElementPtr config_elem_, config_elem_zones_, config_;
-    shared_ptr<ZoneTableSegment> segment_;
+    shared_ptr<ZoneTableSegment> ztable_segment_;
 };
 
 // Test the test itself

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

@@ -161,9 +161,9 @@ public:
 class MemoryClientTest : public ::testing::Test {
 protected:
     MemoryClientTest() : zclass_(RRClass::IN()),
-                         segment_(new test::ZoneTableSegmentTest(
+                         ztable_segment_(new test::ZoneTableSegmentTest(
                              zclass_, mem_sgmt_)),
-                         client_(new InMemoryClient(segment_, zclass_))
+                         client_(new InMemoryClient(ztable_segment_, zclass_))
     {}
     ~MemoryClientTest() {
         delete client_;
@@ -171,12 +171,12 @@ protected:
     void TearDown() {
         delete client_;
         client_ = NULL;
-        segment_.reset();
+        ztable_segment_.reset();
         EXPECT_TRUE(mem_sgmt_.allMemoryDeallocated()); // catch any leak here.
     }
     const RRClass zclass_;
     test::MemorySegmentTest mem_sgmt_;
-    shared_ptr<ZoneTableSegment> segment_;
+    shared_ptr<ZoneTableSegment> ztable_segment_;
     InMemoryClient* client_;
 };
 

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

@@ -30,36 +30,37 @@ namespace {
 class ZoneTableSegmentTest : public ::testing::Test {
 protected:
     ZoneTableSegmentTest() :
-        segment_(new test::ZoneTableSegmentTest(RRClass::IN(), mem_sgmt_))
+        ztable_segment_(new test::ZoneTableSegmentTest(RRClass::IN(),
+                                                       mem_sgmt_))
     {}
 
     ~ZoneTableSegmentTest() {
-        delete segment_;
+        delete ztable_segment_;
     }
 
     void TearDown() {
-        ZoneTableSegment::destroy(segment_);
-        segment_ = NULL;
+        ZoneTableSegment::destroy(ztable_segment_);
+        ztable_segment_ = NULL;
 
         // Catch any future leaks here.
         EXPECT_TRUE(mem_sgmt_.allMemoryDeallocated());
     }
 
     MemorySegmentLocal mem_sgmt_;
-    ZoneTableSegment* segment_;
+    ZoneTableSegment* ztable_segment_;
 };
 
 
 TEST_F(ZoneTableSegmentTest, create) {
     // By default, a local zone table segment is created.
-    EXPECT_NE(static_cast<void*>(NULL), segment_);
+    EXPECT_NE(static_cast<void*>(NULL), ztable_segment_);
 }
 
 // Helper function to check const and non-const methods.
 template <typename TS, typename TH, typename TT>
 void
-testGetHeader(ZoneTableSegment* segment) {
-    TH& header = static_cast<TS*>(segment)->getHeader();
+testGetHeader(ZoneTableSegment* ztable_segment) {
+    TH& header = static_cast<TS*>(ztable_segment)->getHeader();
 
     // The zone table must be set.
     TT* table = header.getTable();
@@ -68,16 +69,17 @@ testGetHeader(ZoneTableSegment* segment) {
 
 TEST_F(ZoneTableSegmentTest, getHeader) {
     // non-const version.
-    testGetHeader<ZoneTableSegment, ZoneTableHeader, ZoneTable>(segment_);
+    testGetHeader<ZoneTableSegment, ZoneTableHeader, ZoneTable>
+        (ztable_segment_);
 
     // const version.
     testGetHeader<const ZoneTableSegment, const ZoneTableHeader,
-                  const ZoneTable>(segment_);
+                  const ZoneTable>(ztable_segment_);
 }
 
 TEST_F(ZoneTableSegmentTest, getMemorySegment) {
     // This doesn't do anything fun except test the API.
-    MemorySegment& mem_sgmt = segment_->getMemorySegment();
+    MemorySegment& mem_sgmt = ztable_segment_->getMemorySegment();
     mem_sgmt.allMemoryDeallocated(); // use mem_sgmt
 }