BIND 10 trac1807, updated. 8b64be78db91e57c4b9b380150d110ef1c566bcf [1807] Add two more easier ways to call rbtree::find
BIND 10 source code commits
bind10-changes at lists.isc.org
Thu May 10 13:32:59 UTC 2012
The branch, trac1807 has been updated
via 8b64be78db91e57c4b9b380150d110ef1c566bcf (commit)
from 85a727dcbf99b3af919623e87b526e5eba12c300 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 8b64be78db91e57c4b9b380150d110ef1c566bcf
Author: Jelte Jansen <jelte at isc.org>
Date: Thu May 10 15:32:21 2012 +0200
[1807] Add two more easier ways to call rbtree::find
-----------------------------------------------------------------------
Summary of changes:
src/lib/datasrc/memory_datasrc.cc | 8 +--
src/lib/datasrc/rbtree.h | 24 ++++++++++
src/lib/datasrc/tests/rbtree_unittest.cc | 69 +++++++++++------------------
3 files changed, 53 insertions(+), 48 deletions(-)
-----------------------------------------------------------------------
diff --git a/src/lib/datasrc/memory_datasrc.cc b/src/lib/datasrc/memory_datasrc.cc
index 4fb328c..2b981ab 100644
--- a/src/lib/datasrc/memory_datasrc.cc
+++ b/src/lib/datasrc/memory_datasrc.cc
@@ -464,9 +464,8 @@ ZoneData::findNode(const Name& name, RBTreeNodeChain<Domain>& node_path,
// Clear the node_path so that we don't keep incorrect (NSEC)
// context
node_path.clear();
- DomainTree::Result result(domains_.find<void*>(wildcard, &node,
- node_path, NULL,
- NULL));
+ DomainTree::Result result(domains_.find(wildcard, &node,
+ node_path));
// Otherwise, why would the domain_flag::WILD be there if
// there was no wildcard under it?
assert(result == DomainTree::EXACTMATCH);
@@ -1828,8 +1827,7 @@ public:
{
// Find the first node (origin) and preserve the node chain for future
// searches
- DomainTree::Result result(tree_.find<void*>(origin, &node_, chain_,
- NULL, NULL));
+ DomainTree::Result result(tree_.find(origin, &node_, chain_));
// It can't happen that the origin is not in there
if (result != DomainTree::EXACTMATCH) {
isc_throw(Unexpected,
diff --git a/src/lib/datasrc/rbtree.h b/src/lib/datasrc/rbtree.h
index 0a229fb..b903094 100644
--- a/src/lib/datasrc/rbtree.h
+++ b/src/lib/datasrc/rbtree.h
@@ -759,6 +759,30 @@ public:
return (ret);
}
+ /// \brief Simple find, with node_path tracking
+ ///
+ /// Acts as described in the \ref find section.
+ Result find(const isc::dns::Name& name, RBNode<T>** node,
+ RBTreeNodeChain<T>& node_path) const
+ {
+ return (find<void*>(name, node, node_path, NULL, NULL));
+ }
+
+ /// \brief Simple find returning immutable node, with node_path tracking
+ ///
+ /// Acts as described in the \ref find section, but returns immutable node
+ /// pointer.
+ Result find(const isc::dns::Name& name, const RBNode<T>** node,
+ RBTreeNodeChain<T>& node_path) const
+ {
+ RBNode<T> *target_node = NULL;
+ Result ret = (find<void*>(name, &target_node, node_path, NULL, NULL));
+ if (ret != NOTFOUND) {
+ *node = target_node;
+ }
+ return (ret);
+ }
+
/// \brief Find with callback and node chain.
/// \anchor callback
///
diff --git a/src/lib/datasrc/tests/rbtree_unittest.cc b/src/lib/datasrc/tests/rbtree_unittest.cc
index f7f59e4..c8858f7 100644
--- a/src/lib/datasrc/tests/rbtree_unittest.cc
+++ b/src/lib/datasrc/tests/rbtree_unittest.cc
@@ -180,10 +180,10 @@ TEST_F(RBTreeTest, findName) {
TEST_F(RBTreeTest, findError) {
// For the version that takes a node chain, the chain must be empty.
RBTreeNodeChain<int> chain;
- EXPECT_EQ(RBTree<int>::EXACTMATCH, rbtree.find<void*>(Name("a"), &crbtnode,
- chain, NULL, NULL));
+ EXPECT_EQ(RBTree<int>::EXACTMATCH, rbtree.find(Name("a"), &crbtnode,
+ chain));
// trying to reuse the same chain. it should result in an exception.
- EXPECT_THROW(rbtree.find<void*>(Name("a"), &crbtnode, chain, NULL, NULL),
+ EXPECT_THROW(rbtree.find(Name("a"), &crbtnode, chain),
BadValue);
}
@@ -280,7 +280,7 @@ TEST_F(RBTreeTest, chainLevel) {
Name node_name(Name::ROOT_NAME());
EXPECT_EQ(RBTree<int>::SUCCESS, tree.insert(node_name, &rbtnode));
EXPECT_EQ(RBTree<int>::EXACTMATCH,
- tree.find<void*>(node_name, &crbtnode, chain, NULL, NULL));
+ tree.find(node_name, &crbtnode, chain));
EXPECT_EQ(1, chain.getLevelCount());
/*
@@ -303,8 +303,7 @@ TEST_F(RBTreeTest, chainLevel) {
EXPECT_EQ(RBTree<int>::SUCCESS, tree.insert(node_name, &rbtnode));
RBTreeNodeChain<int> found_chain;
EXPECT_EQ(RBTree<int>::EXACTMATCH,
- tree.find<void*>(node_name, &crbtnode, found_chain,
- NULL, NULL));
+ tree.find(node_name, &crbtnode, found_chain));
EXPECT_EQ(i, found_chain.getLevelCount());
}
@@ -352,8 +351,7 @@ TEST_F(RBTreeTest, nextNode) {
RBTreeNodeChain<int> node_path;
const RBNode<int>* node = NULL;
EXPECT_EQ(RBTree<int>::EXACTMATCH,
- rbtree.find<void*>(Name(names[0]), &node, node_path, NULL,
- NULL));
+ rbtree.find(Name(names[0]), &node, node_path));
for (int i = 0; i < name_count; ++i) {
EXPECT_NE(static_cast<void*>(NULL), node);
EXPECT_EQ(Name(names[i]), node_path.getAbsoluteName());
@@ -399,8 +397,7 @@ previousWalk(RBTree<int>& rbtree, const RBNode<int>* node,
const RBNode<int>* node2(NULL);
RBTreeNodeChain<int> node_path2;
EXPECT_EQ(RBTree<int>::EXACTMATCH,
- rbtree.find<void*>(Name(names[i - 1]), &node2,
- node_path2, NULL, NULL));
+ rbtree.find(Name(names[i - 1]), &node2, node_path2));
EXPECT_EQ(node, node2);
}
node = rbtree.previousNode(node_path);
@@ -422,8 +419,7 @@ TEST_F(RBTreeTest, previousNode) {
{
SCOPED_TRACE("Iterate through");
EXPECT_EQ(RBTree<int>::EXACTMATCH,
- rbtree.find<void*>(Name(names[name_count - 1]), &node,
- node_path, NULL, NULL));
+ rbtree.find(Name(names[name_count - 1]), &node, node_path));
previousWalk(rbtree, node, node_path, name_count, false);
node = NULL;
node_path.clear();
@@ -433,8 +429,7 @@ TEST_F(RBTreeTest, previousNode) {
SCOPED_TRACE("Iterate from the middle");
// Now, start somewhere in the middle, but within the real node.
EXPECT_EQ(RBTree<int>::EXACTMATCH,
- rbtree.find<void*>(Name(names[4]), &node, node_path,
- NULL, NULL));
+ rbtree.find(Name(names[4]), &node, node_path));
previousWalk(rbtree, node, node_path, 5, false);
node = NULL;
node_path.clear();
@@ -445,8 +440,7 @@ TEST_F(RBTreeTest, previousNode) {
// If we start at the lowest (which is "a"), we get to the beginning
// right away.
EXPECT_EQ(RBTree<int>::EXACTMATCH,
- rbtree.find<void*>(Name(names[0]), &node, node_path, NULL,
- NULL));
+ rbtree.find(Name(names[0]), &node, node_path));
EXPECT_NE(static_cast<void*>(NULL), node);
EXPECT_EQ(NULL, rbtree.previousNode(node_path));
node = NULL;
@@ -457,7 +451,7 @@ TEST_F(RBTreeTest, previousNode) {
SCOPED_TRACE("Start before the first");
// If we start before the lowest (0 < a), we should not get a node nor
EXPECT_EQ(RBTree<int>::NOTFOUND,
- rbtree.find<void*>(Name("0"), &node, node_path, NULL, NULL));
+ rbtree.find(Name("0"), &node, node_path));
EXPECT_EQ(NULL, node);
EXPECT_EQ(NULL, rbtree.previousNode(node_path));
node = NULL;
@@ -467,7 +461,7 @@ TEST_F(RBTreeTest, previousNode) {
{
SCOPED_TRACE("Start after the last");
EXPECT_EQ(RBTree<int>::NOTFOUND,
- rbtree.find<void*>(Name("z"), &node, node_path, NULL, NULL));
+ rbtree.find(Name("z"), &node, node_path));
previousWalk(rbtree, node, node_path, name_count, true);
node = NULL;
node_path.clear();
@@ -479,8 +473,7 @@ TEST_F(RBTreeTest, previousNode) {
// we exited - 'c' (actually, we should get it by the find, as partial
// match).
EXPECT_EQ(RBTree<int>::PARTIALMATCH,
- rbtree.find<void*>(Name("b.c"), &node, node_path, NULL,
- NULL));
+ rbtree.find(Name("b.c"), &node, node_path));
previousWalk(rbtree, node, node_path, 3, false);
node = NULL;
node_path.clear();
@@ -494,8 +487,7 @@ TEST_F(RBTreeTest, previousNode) {
// The d.e.f is empty node, so it is hidden by find. Therefore NOTFOUND
// and not PARTIALMATCH.
EXPECT_EQ(RBTree<int>::NOTFOUND,
- rbtree.find<void*>(Name("xy.d.e.f"), &node, node_path,
- NULL, NULL));
+ rbtree.find(Name("xy.d.e.f"), &node, node_path));
previousWalk(rbtree, node, node_path, 5, true);
node = NULL;
node_path.clear();
@@ -509,8 +501,7 @@ TEST_F(RBTreeTest, previousNode) {
// The d.e.f is empty node, so it is hidden by find. Therefore NOTFOUND
// and not PARTIALMATCH.
EXPECT_EQ(RBTree<int>::NOTFOUND,
- rbtree.find<void*>(Name("yz.d.e.f"), &node, node_path,
- NULL, NULL));
+ rbtree.find(Name("yz.d.e.f"), &node, node_path));
previousWalk(rbtree, node, node_path, 9, true);
node = NULL;
node_path.clear();
@@ -521,8 +512,7 @@ TEST_F(RBTreeTest, previousNode) {
// The d.e.f is a single node, but we want only part of it. We
// should start iterating before it.
EXPECT_EQ(RBTree<int>::NOTFOUND,
- rbtree.find<void*>(Name("e.f"), &node, node_path,
- NULL, NULL));
+ rbtree.find(Name("e.f"), &node, node_path));
previousWalk(rbtree, node, node_path, 3, true);
node = NULL;
node_path.clear();
@@ -533,8 +523,7 @@ TEST_F(RBTreeTest, previousNode) {
// Just check it doesn't crash, etc.
RBTree<int> empty_tree;
EXPECT_EQ(RBTree<int>::NOTFOUND,
- empty_tree.find<void*>(Name("x"), &node, node_path,
- NULL, NULL));
+ empty_tree.find(Name("x"), &node, node_path));
EXPECT_EQ(static_cast<void*>(NULL), node);
EXPECT_EQ(static_cast<void*>(NULL),
empty_tree.previousNode(node_path));
@@ -578,7 +567,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
// A search for an empty tree should result in no 'last compared', too.
RBTree<int> empty_tree;
EXPECT_EQ(RBTree<int>::NOTFOUND,
- empty_tree.find<void*>(Name("a"), &crbtnode, chain, NULL, NULL));
+ empty_tree.find(Name("a"), &crbtnode, chain));
EXPECT_EQ(static_cast<void*>(NULL), chain.getLastComparedNode());
chain.clear();
@@ -586,8 +575,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
// Exact match case. The returned node should be last compared.
EXPECT_EQ(RBTree<int>::EXACTMATCH,
- tree.find<void*>(Name("x.d.e.f"), &expected_node, chain,
- NULL, NULL));
+ tree.find(Name("x.d.e.f"), &expected_node, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// 2 = # labels of "x."
comparisonChecks(chain, 0, 2, NameComparisonResult::EQUAL);
@@ -598,8 +586,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
EXPECT_EQ(RBTree<int>::EXACTMATCH,
tree.find(Name("i.g.h"), &expected_node));
EXPECT_EQ(RBTree<int>::PARTIALMATCH,
- tree.find<void*>(Name("x.i.g.h"), &crbtnode, chain,
- NULL, NULL));
+ tree.find(Name("x.i.g.h"), &crbtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// i.g.h < x.i.g.h, 2 = # labels of "i."
comparisonChecks(chain, 1, 2, NameComparisonResult::SUBDOMAIN);
@@ -610,8 +597,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
EXPECT_EQ(RBTree<int>::EXACTMATCH,
tree.find(Name("x.d.e.f"), &expected_node));
EXPECT_EQ(RBTree<int>::PARTIALMATCH,
- tree.find<void*>(Name("a.d.e.f"), &crbtnode, chain,
- NULL, NULL));
+ tree.find(Name("a.d.e.f"), &crbtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// a < x, 1 = # labels of "." (trailing dot)
comparisonChecks(chain, -1, 1, NameComparisonResult::COMMONANCESTOR);
@@ -622,8 +608,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
EXPECT_EQ(RBTree<int>::EXACTMATCH,
tree.find(Name("z.d.e.f"), &expected_node));
EXPECT_EQ(RBTree<int>::PARTIALMATCH,
- tree.find<void*>(Name("zz.d.e.f"), &crbtnode, chain,
- NULL, NULL));
+ tree.find(Name("zz.d.e.f"), &crbtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// zz > z, 1 = # labels of "." (trailing dot)
comparisonChecks(chain, 1, 1, NameComparisonResult::COMMONANCESTOR);
@@ -634,8 +619,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
EXPECT_EQ(RBTree<int>::EXACTMATCH,
tree.find(Name("w.y.d.e.f"), &expected_node));
EXPECT_EQ(RBTree<int>::PARTIALMATCH,
- tree.find<void*>(Name("y.d.e.f"), &crbtnode, chain,
- NULL, NULL));
+ tree.find(Name("y.d.e.f"), &crbtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// y < w.y, 2 = # labels of "y."
comparisonChecks(chain, -1, 2, NameComparisonResult::SUPERDOMAIN);
@@ -645,8 +629,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
// with the search name in the subtree below the matching node.
// (the expected node is the same as the previous case)
EXPECT_EQ(RBTree<int>::PARTIALMATCH,
- tree.find<void*>(Name("z.y.d.e.f"), &crbtnode, chain,
- NULL, NULL));
+ tree.find(Name("z.y.d.e.f"), &crbtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// z.y > w.y, 2 = # labels of "y."
comparisonChecks(chain, 1, 2, NameComparisonResult::COMMONANCESTOR);
@@ -655,7 +638,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
// Search stops in the highest level after following a left branch.
EXPECT_EQ(RBTree<int>::EXACTMATCH, tree.find(Name("c"), &expected_node));
EXPECT_EQ(RBTree<int>::NOTFOUND,
- tree.find<void*>(Name("bb"), &crbtnode, chain, NULL, NULL));
+ tree.find(Name("bb"), &crbtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// bb < c, 1 = # labels of "." (trailing dot)
comparisonChecks(chain, -1, 1, NameComparisonResult::COMMONANCESTOR);
@@ -664,7 +647,7 @@ TEST_F(RBTreeTest, getLastComparedNode) {
// Search stops in the highest level after following a right branch.
// (the expected node is the same as the previous case)
EXPECT_EQ(RBTree<int>::NOTFOUND,
- tree.find<void*>(Name("d"), &crbtnode, chain, NULL, NULL));
+ tree.find(Name("d"), &crbtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// d > c, 1 = # labels of "." (trailing dot)
comparisonChecks(chain, 1, 1, NameComparisonResult::COMMONANCESTOR);
More information about the bind10-changes
mailing list