BIND 10 trac2105, updated. 9d416b80baba0fd5f44a8944fe219be49b4726ae [2105] Document DT template parameter
BIND 10 source code commits
bind10-changes at lists.isc.org
Tue Jul 31 18:29:50 UTC 2012
The branch, trac2105 has been updated
via 9d416b80baba0fd5f44a8944fe219be49b4726ae (commit)
via 1319a26ec4a087dd154ee18270b708a12a205b15 (commit)
via 5eb12ef1deafb9fd9fd9ebfa722b5cd2b3b1d8ba (commit)
via ce3394fbd4d882fede52165151bad75459f1b7b1 (commit)
via 1fdb15bd59af353bf113ec3edafa5e372c740c3e (commit)
from ad0d2ac48fbafbf2f887a1144eab043c68eea52b (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 9d416b80baba0fd5f44a8944fe219be49b4726ae
Author: Mukund Sivaraman <muks at isc.org>
Date: Tue Jul 31 23:49:11 2012 +0530
[2105] Document DT template parameter
commit 1319a26ec4a087dd154ee18270b708a12a205b15
Author: Mukund Sivaraman <muks at isc.org>
Date: Tue Jul 31 23:36:44 2012 +0530
[2105] Rename other instances of rbtree/rbnode
commit 5eb12ef1deafb9fd9fd9ebfa722b5cd2b3b1d8ba
Author: Mukund Sivaraman <muks at isc.org>
Date: Tue Jul 31 23:31:40 2012 +0530
[2105] Add space between template parameters
commit ce3394fbd4d882fede52165151bad75459f1b7b1
Author: Mukund Sivaraman <muks at isc.org>
Date: Tue Jul 31 23:30:29 2012 +0530
[2105] Set data_ in the initializer list
commit 1fdb15bd59af353bf113ec3edafa5e372c740c3e
Author: Mukund Sivaraman <muks at isc.org>
Date: Tue Jul 31 23:24:51 2012 +0530
[2105] Add explicit default constructor for the DeleterType class
Some compilers seem to expect it to be present.
-----------------------------------------------------------------------
Summary of changes:
src/lib/datasrc/memory/domaintree.h | 427 +++++++++---------
.../datasrc/memory/tests/domaintree_unittest.cc | 474 ++++++++++----------
2 files changed, 455 insertions(+), 446 deletions(-)
-----------------------------------------------------------------------
diff --git a/src/lib/datasrc/memory/domaintree.h b/src/lib/datasrc/memory/domaintree.h
index 2ffc799..51d765c 100644
--- a/src/lib/datasrc/memory/domaintree.h
+++ b/src/lib/datasrc/memory/domaintree.h
@@ -84,13 +84,13 @@ class DomainTreeNode : public boost::noncopyable {
private:
/// The DomainTreeNode is meant for use from within DomainTree, so
/// it has access to it.
- friend class DomainTree<T,DT>;
+ friend class DomainTree<T, DT>;
/// \brief Just a type alias
///
/// We are going to use a lot of these offset pointers here and they
/// have a long name.
- typedef boost::interprocess::offset_ptr<DomainTreeNode<T,DT> >
+ typedef boost::interprocess::offset_ptr<DomainTreeNode<T, DT> >
DomainTreeNodePtr;
/// \name Constructors
@@ -131,12 +131,12 @@ private:
///
/// \param mem_sgmt A \c MemorySegment from which memory for the new
/// \c DomainTreeNode is allocated.
- static DomainTreeNode<T,DT>* create(util::MemorySegment& mem_sgmt,
+ static DomainTreeNode<T, DT>* create(util::MemorySegment& mem_sgmt,
const dns::LabelSequence& labels)
{
const size_t labels_len = labels.getSerializedLength();
- void* p = mem_sgmt.allocate(sizeof(DomainTreeNode<T,DT>) + labels_len);
- DomainTreeNode<T,DT>* node = new(p) DomainTreeNode<T,DT>(labels_len);
+ void* p = mem_sgmt.allocate(sizeof(DomainTreeNode<T, DT>) + labels_len);
+ DomainTreeNode<T, DT>* node = new(p) DomainTreeNode<T, DT>(labels_len);
labels.serialize(node->getLabelsData(), labels_len);
return (node);
}
@@ -146,16 +146,16 @@ private:
/// \throw none
///
/// \param mem_sgmt The \c MemorySegment that allocated memory for
- /// \c rbnode.
- /// \param rbnode A non NULL pointer to a valid \c DomainTreeNode object
+ /// \c node.
+ /// \param node A non NULL pointer to a valid \c DomainTreeNode object
/// that was originally created by the \c create() method (the behavior
/// is undefined if this condition isn't met).
static void destroy(util::MemorySegment& mem_sgmt,
- DomainTreeNode<T,DT>* rbnode) {
- const size_t labels_capacity = rbnode->labels_capacity_;
- rbnode->~DomainTreeNode<T,DT>();
- mem_sgmt.deallocate(rbnode,
- sizeof(DomainTreeNode<T,DT>) + labels_capacity);
+ DomainTreeNode<T, DT>* node) {
+ const size_t labels_capacity = node->labels_capacity_;
+ node->~DomainTreeNode<T, DT>();
+ mem_sgmt.deallocate(node,
+ sizeof(DomainTreeNode<T, DT>) + labels_capacity);
}
/// \brief Reset node's label sequence to a new one.
@@ -302,7 +302,7 @@ public:
private:
/// \name Callback related methods
///
- /// See the description of \c DomainTree<T,DT>::find() at \ref callback
+ /// See the description of \c DomainTree<T, DT>::find() at \ref callback
/// about callbacks.
///
/// These methods never throw an exception.
@@ -311,7 +311,7 @@ private:
//@}
- /// \brief Define rbnode color
+ /// \brief Define node color
enum DomainTreeNodeColor {BLACK, RED};
/// \brief Returns the color of this node
@@ -353,7 +353,7 @@ public:
/// (which should be absolute), it will return \c NULL.
///
/// This method never throws an exception.
- const DomainTreeNode<T,DT>* getUpperNode() const;
+ const DomainTreeNode<T, DT>* getUpperNode() const;
private:
/// \brief return the next node which is bigger than current node
@@ -371,7 +371,7 @@ private:
/// returns \c NULL.
///
/// This method never throws an exception.
- const DomainTreeNode<T,DT>* successor() const;
+ const DomainTreeNode<T, DT>* successor() const;
/// \brief return the next node which is smaller than current node
/// in the same subtree
@@ -388,7 +388,7 @@ private:
/// returns \c NULL.
///
/// This method never throws an exception.
- const DomainTreeNode<T,DT>* predecessor() const;
+ const DomainTreeNode<T, DT>* predecessor() const;
/// \brief private shared implementation of successor and predecessor
///
@@ -401,11 +401,11 @@ private:
/// The overhead of the member pointers should be optimised out, as this
/// will probably get completely inlined into predecessor and successor
/// methods.
- const DomainTreeNode<T,DT>*
- abstractSuccessor(typename DomainTreeNode<T,DT>::DomainTreeNodePtr
- DomainTreeNode<T,DT>::*left,
- typename DomainTreeNode<T,DT>::DomainTreeNodePtr
- DomainTreeNode<T,DT>::*right)
+ const DomainTreeNode<T, DT>*
+ abstractSuccessor(typename DomainTreeNode<T, DT>::DomainTreeNodePtr
+ DomainTreeNode<T, DT>::*left,
+ typename DomainTreeNode<T, DT>::DomainTreeNodePtr
+ DomainTreeNode<T, DT>::*right)
const;
/// \name Data to maintain the rbtree structure.
@@ -418,36 +418,33 @@ private:
//@{
DomainTreeNodePtr parent_;
/// \brief Access the parent_ as bare pointer.
- DomainTreeNode<T,DT>* getParent() {
+ DomainTreeNode<T, DT>* getParent() {
return (parent_.get());
}
/// \brief Access the parent_ as bare pointer, const.
- const DomainTreeNode<T,DT>* getParent() const {
+ const DomainTreeNode<T, DT>* getParent() const {
return (parent_.get());
}
DomainTreeNodePtr left_;
/// \brief Access the left_ as bare pointer.
- DomainTreeNode<T,DT>* getLeft() {
+ DomainTreeNode<T, DT>* getLeft() {
return (left_.get());
}
/// \brief Access the left_ as bare pointer, const.
- const DomainTreeNode<T,DT>* getLeft() const {
+ const DomainTreeNode<T, DT>* getLeft() const {
return (left_.get());
}
DomainTreeNodePtr right_;
/// \brief Access the right_ as bare pointer.
- DomainTreeNode<T,DT>* getRight() {
+ DomainTreeNode<T, DT>* getRight() {
return (right_.get());
}
/// \brief Access the right_ as bare pointer, const.
- const DomainTreeNode<T,DT>* getRight() const {
+ const DomainTreeNode<T, DT>* getRight() const {
return (right_.get());
}
//@}
- /// \brief Data stored here.
- T* data_;
-
/// \brief The subdomain tree.
///
/// This points to the root node of trees of subdomains of this domain.
@@ -459,14 +456,17 @@ private:
/// avoiding storage of the same domain labels multiple times.
DomainTreeNodePtr down_;
/// \brief Access the down_ as bare pointer.
- DomainTreeNode<T,DT>* getDown() {
+ DomainTreeNode<T, DT>* getDown() {
return (down_.get());
}
/// \brief Access the down_ as bare pointer, const.
- const DomainTreeNode<T,DT>* getDown() const {
+ const DomainTreeNode<T, DT>* getDown() const {
return (down_.get());
}
+ /// \brief Data stored here.
+ T* data_;
+
/// \brief Internal or user-configurable flags of node's properties.
///
/// See the \c Flags enum for available flags.
@@ -488,25 +488,25 @@ private:
};
template <typename T, typename DT>
-DomainTreeNode<T,DT>::DomainTreeNode(size_t labels_capacity) :
+DomainTreeNode<T, DT>::DomainTreeNode(size_t labels_capacity) :
parent_(NULL),
left_(NULL),
right_(NULL),
down_(NULL),
+ data_(NULL),
flags_(FLAG_RED | FLAG_SUBTREE_ROOT),
labels_capacity_(labels_capacity)
{
- data_ = NULL;
}
template <typename T, typename DT>
-DomainTreeNode<T,DT>::~DomainTreeNode() {
+DomainTreeNode<T, DT>::~DomainTreeNode() {
}
template <typename T, typename DT>
-const DomainTreeNode<T,DT>*
-DomainTreeNode<T,DT>::getUpperNode() const {
- const DomainTreeNode<T,DT>* current = this;
+const DomainTreeNode<T, DT>*
+DomainTreeNode<T, DT>::getUpperNode() const {
+ const DomainTreeNode<T, DT>* current = this;
// current would never be equal to NULL here (in a correct tree
// implementation)
@@ -518,11 +518,11 @@ DomainTreeNode<T,DT>::getUpperNode() const {
}
template <typename T, typename DT>
-const DomainTreeNode<T,DT>*
-DomainTreeNode<T,DT>::abstractSuccessor(typename DomainTreeNode<T,DT>::DomainTreeNodePtr
- DomainTreeNode<T,DT>::*left,
- typename DomainTreeNode<T,DT>::DomainTreeNodePtr
- DomainTreeNode<T,DT>::*right)
+const DomainTreeNode<T, DT>*
+DomainTreeNode<T, DT>::abstractSuccessor(typename DomainTreeNode<T, DT>::DomainTreeNodePtr
+ DomainTreeNode<T, DT>::*left,
+ typename DomainTreeNode<T, DT>::DomainTreeNodePtr
+ DomainTreeNode<T, DT>::*right)
const
{
// This function is written as a successor. It becomes predecessor if
@@ -530,12 +530,12 @@ DomainTreeNode<T,DT>::abstractSuccessor(typename DomainTreeNode<T,DT>::DomainTre
// the left pointer points to right and vice versa. Don't get confused
// by the idea, just imagine the pointers look into a mirror.
- const DomainTreeNode<T,DT>* current = this;
+ const DomainTreeNode<T, DT>* current = this;
// If it has right node, the successor is the left-most node of the right
// subtree.
if ((current->*right).get() != NULL) {
current = (current->*right).get();
- const DomainTreeNode<T,DT>* left_n;
+ const DomainTreeNode<T, DT>* left_n;
while ((left_n = (current->*left).get()) != NULL) {
current = left_n;
}
@@ -545,7 +545,7 @@ DomainTreeNode<T,DT>::abstractSuccessor(typename DomainTreeNode<T,DT>::DomainTre
// Otherwise go up until we find the first left branch on our path to
// root. If found, the parent of the branch is the successor.
// Otherwise, we return the null node
- const DomainTreeNode<T,DT>* parent = current->getParent();
+ const DomainTreeNode<T, DT>* parent = current->getParent();
while ((!current->isSubTreeRoot()) &&
(current == (parent->*right).get())) {
current = parent;
@@ -560,18 +560,18 @@ DomainTreeNode<T,DT>::abstractSuccessor(typename DomainTreeNode<T,DT>::DomainTre
}
template <typename T, typename DT>
-const DomainTreeNode<T,DT>*
-DomainTreeNode<T,DT>::successor() const {
- return (abstractSuccessor(&DomainTreeNode<T,DT>::left_,
- &DomainTreeNode<T,DT>::right_));
+const DomainTreeNode<T, DT>*
+DomainTreeNode<T, DT>::successor() const {
+ return (abstractSuccessor(&DomainTreeNode<T, DT>::left_,
+ &DomainTreeNode<T, DT>::right_));
}
template <typename T, typename DT>
-const DomainTreeNode<T,DT>*
-DomainTreeNode<T,DT>::predecessor() const {
+const DomainTreeNode<T, DT>*
+DomainTreeNode<T, DT>::predecessor() const {
// Swap the left and right pointers for the abstractSuccessor
- return (abstractSuccessor(&DomainTreeNode<T,DT>::right_,
- &DomainTreeNode<T,DT>::left_));
+ return (abstractSuccessor(&DomainTreeNode<T, DT>::right_,
+ &DomainTreeNode<T, DT>::left_));
}
/// \brief DomainTreeNodeChain stores detailed information of \c
@@ -612,7 +612,7 @@ template <typename T, typename DT>
class DomainTreeNodeChain {
/// DomainTreeNodeChain is initialized by DomainTree, only DomainTree has
/// knowledge to manipulate it.
- friend class DomainTree<T,DT>;
+ friend class DomainTree<T, DT>;
public:
/// \name Constructors and Assignment Operator.
///
@@ -632,8 +632,8 @@ public:
{}
private:
- DomainTreeNodeChain(const DomainTreeNodeChain<T,DT>&);
- DomainTreeNodeChain<T,DT>& operator=(const DomainTreeNodeChain<T,DT>&);
+ DomainTreeNodeChain(const DomainTreeNodeChain<T, DT>&);
+ DomainTreeNodeChain<T, DT>& operator=(const DomainTreeNodeChain<T, DT>&);
//@}
public:
@@ -661,7 +661,7 @@ public:
/// tree is empty), this method returns \c NULL.
///
/// \exception None
- const DomainTreeNode<T,DT>* getLastComparedNode() const {
+ const DomainTreeNode<T, DT>* getLastComparedNode() const {
return (last_compared_);
}
@@ -701,7 +701,7 @@ public:
"called on an empty chain");
}
- const DomainTreeNode<T,DT>* top_node = top();
+ const DomainTreeNode<T, DT>* top_node = top();
isc::dns::Name absolute_name = top_node->getName();
int node_count = node_count_ - 1;
while (node_count > 0) {
@@ -729,7 +729,7 @@ private:
/// root node of DomainTree
///
/// \exception None
- const DomainTreeNode<T,DT>* top() const {
+ const DomainTreeNode<T, DT>* top() const {
assert(!isEmpty());
return (nodes_[node_count_ - 1]);
}
@@ -752,20 +752,20 @@ private:
/// otherwise the node should be the root node of DomainTree.
///
/// \exception None
- void push(const DomainTreeNode<T,DT>* node) {
+ void push(const DomainTreeNode<T, DT>* node) {
assert(node_count_ < RBT_MAX_LEVEL);
nodes_[node_count_++] = node;
}
private:
- // The max label count for one domain name is Name::MAX_LABELS (128).
- // Since each node in rbtree stores at least one label, it's also equal
- // to the possible maximum level.
+ // The max label count for one domain name is Name::MAX_LABELS
+ // (128). Since each node in domaintree stores at least one label,
+ // it's also equal to the possible maximum level.
const static int RBT_MAX_LEVEL = isc::dns::Name::MAX_LABELS;
int node_count_;
- const DomainTreeNode<T,DT>* nodes_[RBT_MAX_LEVEL];
- const DomainTreeNode<T,DT>* last_compared_;
+ const DomainTreeNode<T, DT>* nodes_[RBT_MAX_LEVEL];
+ const DomainTreeNode<T, DT>* last_compared_;
isc::dns::NameComparisonResult last_comparison_;
};
@@ -785,21 +785,28 @@ private:
*
* \c DomainTree splits the domain space into hierarchy red black trees; nodes
* in one tree has the same base name. The benefit of this struct is that:
- * - Enhances the query performace compared with one big flat red black tree.
+ * - Enhances the query performance compared with one big flat red black tree.
* - Decreases the memory footprint, as it doesn't store the suffix labels
* multiple times.
*
- * Depending on different usage, rbtree will support different search policies.
- * Whether to return an empty node to end user is one policy among them.
- * The default policy is to NOT return an empty node to end user;
- * to change the behavior, specify \c true for the constructor parameter
- * \c returnEmptyNode.
+ * Depending on different usage, domaintree will support different
+ * search policies. Whether to return an empty node to end user is one
+ * policy among them. The default policy is to NOT return an empty node
+ * to end user; to change the behavior, specify \c true for the
+ * constructor parameter \c returnEmptyNode.
* \note The search policy only affects the \c find() behavior of DomainTree.
* When inserting one name into DomainTree, if the node with the name already
* exists in the DomainTree and it's an empty node which doesn't have any data,
* the \c insert() method will still return \c ALREADYEXISTS regardless of
* the search policy.
*
+ * The template parameters taken by \c DomainTree are \c T (the type of
+ * data which is stored by the tree) and \c DT (a type whose instance is
+ * used to destroy data stored in the tree). <code>operator()</code> is
+ * called on a \c DT instance and passed a pointer to the data
+ * (<code>T*</code>) to be destroyed. This method should be written to
+ * accept \c NULL arguments.
+ *
* \anchor diagram
*
* with the following names:
@@ -836,7 +843,7 @@ private:
*/
template <typename T, typename DT>
class DomainTree : public boost::noncopyable {
- friend class DomainTreeNode<T,DT>;
+ friend class DomainTreeNode<T, DT>;
public:
/// \brief The return value for the \c find() and insert() methods
enum Result {
@@ -862,8 +869,8 @@ public:
static DomainTree* create(util::MemorySegment& mem_sgmt,
bool return_empty_node = false)
{
- void* p = mem_sgmt.allocate(sizeof(DomainTree<T,DT>));
- return (new(p) DomainTree<T,DT>(return_empty_node));
+ void* p = mem_sgmt.allocate(sizeof(DomainTree<T, DT>));
+ return (new(p) DomainTree<T, DT>(return_empty_node));
}
/// \brief Destruct and deallocate \c DomainTree
@@ -887,15 +894,15 @@ public:
/// \throw none
///
/// \param mem_sgmt The \c MemorySegment that allocated memory for
- /// \c rbtree and for all nodes inserted to the tree.
- /// \param rbtree A non NULL pointer to a valid \c DomainTree object
+ /// \c tree and for all nodes inserted to the tree.
+ /// \param tree A non NULL pointer to a valid \c DomainTree object
/// that was originally created by the \c create() method (the behavior
/// is undefined if this condition isn't met).
static void destroy(util::MemorySegment& mem_sgmt,
- DomainTree<T,DT>* rbtree) {
- rbtree->deleteAllNodes(mem_sgmt);
- rbtree->~DomainTree<T,DT>();
- mem_sgmt.deallocate(rbtree, sizeof(DomainTree<T,DT>));
+ DomainTree<T, DT>* tree) {
+ tree->deleteAllNodes(mem_sgmt);
+ tree->~DomainTree<T, DT>();
+ mem_sgmt.deallocate(tree, sizeof(DomainTree<T, DT>));
}
private:
@@ -973,8 +980,8 @@ public:
///
/// Acts as described in the \ref find section.
Result find(const isc::dns::Name& name,
- DomainTreeNode<T,DT>** node) const {
- DomainTreeNodeChain<T,DT> node_path;
+ DomainTreeNode<T, DT>** node) const {
+ DomainTreeNodeChain<T, DT> node_path;
const isc::dns::LabelSequence ls(name);
return (find<void*>(ls, node, node_path, NULL, NULL));
}
@@ -984,9 +991,9 @@ public:
/// Acts as described in the \ref find section, but returns immutable node
/// pointer.
Result find(const isc::dns::Name& name,
- const DomainTreeNode<T,DT>** node) const {
- DomainTreeNodeChain<T,DT> node_path;
- DomainTreeNode<T,DT> *target_node = NULL;
+ const DomainTreeNode<T, DT>** node) const {
+ DomainTreeNodeChain<T, DT> node_path;
+ DomainTreeNode<T, DT> *target_node = NULL;
const isc::dns::LabelSequence ls(name);
Result ret = (find<void*>(ls, &target_node, node_path, NULL, NULL));
if (ret != NOTFOUND) {
@@ -998,8 +1005,8 @@ public:
/// \brief Simple find, with node_path tracking
///
/// Acts as described in the \ref find section.
- Result find(const isc::dns::Name& name, DomainTreeNode<T,DT>** node,
- DomainTreeNodeChain<T,DT>& node_path) const
+ Result find(const isc::dns::Name& name, DomainTreeNode<T, DT>** node,
+ DomainTreeNodeChain<T, DT>& node_path) const
{
const isc::dns::LabelSequence ls(name);
return (find<void*>(ls, node, node_path, NULL, NULL));
@@ -1009,10 +1016,10 @@ public:
///
/// Acts as described in the \ref find section, but returns immutable node
/// pointer.
- Result find(const isc::dns::Name& name, const DomainTreeNode<T,DT>** node,
- DomainTreeNodeChain<T,DT>& node_path) const
+ Result find(const isc::dns::Name& name, const DomainTreeNode<T, DT>** node,
+ DomainTreeNodeChain<T, DT>& node_path) const
{
- DomainTreeNode<T,DT> *target_node = NULL;
+ DomainTreeNode<T, DT> *target_node = NULL;
const isc::dns::LabelSequence ls(name);
Result ret = (find<void*>(ls, &target_node, node_path, NULL, NULL));
if (ret != NOTFOUND) {
@@ -1027,12 +1034,12 @@ public:
/// node pointer.
template <typename CBARG>
Result find(const isc::dns::Name& name,
- const DomainTreeNode<T,DT>** node,
- DomainTreeNodeChain<T,DT>& node_path,
- bool (*callback)(const DomainTreeNode<T,DT>&, CBARG),
+ const DomainTreeNode<T, DT>** node,
+ DomainTreeNodeChain<T, DT>& node_path,
+ bool (*callback)(const DomainTreeNode<T, DT>&, CBARG),
CBARG callback_arg) const
{
- DomainTreeNode<T,DT>* target_node = NULL;
+ DomainTreeNode<T, DT>* target_node = NULL;
const isc::dns::LabelSequence ls(name);
Result ret = find(ls, &target_node, node_path, callback,
callback_arg);
@@ -1116,9 +1123,9 @@ public:
/// \c true, it returns immediately with the current node.
template <typename CBARG>
Result find(const isc::dns::LabelSequence& target_labels_orig,
- DomainTreeNode<T,DT>** node,
- DomainTreeNodeChain<T,DT>& node_path,
- bool (*callback)(const DomainTreeNode<T,DT>&, CBARG),
+ DomainTreeNode<T, DT>** node,
+ DomainTreeNodeChain<T, DT>& node_path,
+ bool (*callback)(const DomainTreeNode<T, DT>&, CBARG),
CBARG callback_arg) const;
/// \brief Simple find returning immutable node.
@@ -1127,12 +1134,12 @@ public:
/// node pointer.
template <typename CBARG>
Result find(const isc::dns::LabelSequence& target_labels,
- const DomainTreeNode<T,DT>** node,
- DomainTreeNodeChain<T,DT>& node_path,
- bool (*callback)(const DomainTreeNode<T,DT>&, CBARG),
+ const DomainTreeNode<T, DT>** node,
+ DomainTreeNodeChain<T, DT>& node_path,
+ bool (*callback)(const DomainTreeNode<T, DT>&, CBARG),
CBARG callback_arg) const
{
- DomainTreeNode<T,DT>* target_node = NULL;
+ DomainTreeNode<T, DT>* target_node = NULL;
Result ret = find(target_labels, &target_node, node_path,
callback, callback_arg);
if (ret != NOTFOUND) {
@@ -1165,8 +1172,8 @@ public:
///
/// \return An \c DomainTreeNode that is next bigger than \c node;
/// if \c node is the largest, \c NULL will be returned.
- const DomainTreeNode<T,DT>*
- nextNode(DomainTreeNodeChain<T,DT>& node_path) const;
+ const DomainTreeNode<T, DT>*
+ nextNode(DomainTreeNodeChain<T, DT>& node_path) const;
/// \brief return the next smaller node in DNSSEC order from a node
/// searched by DomainTree::find().
@@ -1190,8 +1197,8 @@ public:
///
/// \return An \c DomainTreeNode that is next smaller than \c node;
/// if \c node is the smallest, \c NULL will be returned.
- const DomainTreeNode<T,DT>*
- previousNode(DomainTreeNodeChain<T,DT>& node_path) const;
+ const DomainTreeNode<T, DT>*
+ previousNode(DomainTreeNodeChain<T, DT>& node_path) const;
/// \brief Get the total number of nodes in the tree
///
@@ -1256,7 +1263,7 @@ public:
/// - ALREADYEXISTS There was already a node of that name, so it was not
/// added.
Result insert(util::MemorySegment& mem_sgmt, const isc::dns::Name& name,
- DomainTreeNode<T,DT>** inserted_node);
+ DomainTreeNode<T, DT>** inserted_node);
/// \brief Delete all tree nodes.
///
@@ -1275,7 +1282,7 @@ public:
///
/// This acts the same as many std::*.swap functions, exchanges the
/// contents. This doesn't throw anything.
- void swap(DomainTree<T,DT>& other) {
+ void swap(DomainTree<T, DT>& other) {
std::swap(root_, other.root_);
std::swap(node_count_, other.node_count_);
}
@@ -1285,31 +1292,31 @@ private:
/// \name DomainTree balance functions
//@{
void
- insertRebalance(typename DomainTreeNode<T,DT>::DomainTreeNodePtr* root,
- DomainTreeNode<T,DT>* node);
+ insertRebalance(typename DomainTreeNode<T, DT>::DomainTreeNodePtr* root,
+ DomainTreeNode<T, DT>* node);
- DomainTreeNode<T,DT>*
- rightRotate(typename DomainTreeNode<T,DT>::DomainTreeNodePtr* root,
- DomainTreeNode<T,DT>* node);
+ DomainTreeNode<T, DT>*
+ rightRotate(typename DomainTreeNode<T, DT>::DomainTreeNodePtr* root,
+ DomainTreeNode<T, DT>* node);
- DomainTreeNode<T,DT>*
- leftRotate(typename DomainTreeNode<T,DT>::DomainTreeNodePtr* root,
- DomainTreeNode<T,DT>* node);
+ DomainTreeNode<T, DT>*
+ leftRotate(typename DomainTreeNode<T, DT>::DomainTreeNodePtr* root,
+ DomainTreeNode<T, DT>* node);
//@}
/// \name Helper functions
//@{
/// \brief delete tree whose root is equal to node
void deleteHelper(util::MemorySegment& mem_sgmt,
- DomainTreeNode<T,DT> *node,
+ DomainTreeNode<T, DT> *node,
const DT& deleter);
/// \brief Print the information of given DomainTreeNode.
- void dumpTreeHelper(std::ostream& os, const DomainTreeNode<T,DT>* node,
+ void dumpTreeHelper(std::ostream& os, const DomainTreeNode<T, DT>* node,
unsigned int depth) const;
/// \brief Print the information of given DomainTreeNode for dot.
- int dumpDotHelper(std::ostream& os, const DomainTreeNode<T,DT>* node,
+ int dumpDotHelper(std::ostream& os, const DomainTreeNode<T, DT>* node,
int* nodecount, bool show_pointers) const;
/// \brief Indentation helper function for dumpTree
@@ -1321,20 +1328,20 @@ private:
/// The newly created node represents the labels that the original node
/// did, so necessary data are swapped.
/// (Note: as commented in the code, this behavior should be changed).
- void nodeFission(util::MemorySegment& mem_sgmt, DomainTreeNode<T,DT>& node,
+ void nodeFission(util::MemorySegment& mem_sgmt, DomainTreeNode<T, DT>& node,
const isc::dns::LabelSequence& new_prefix,
const isc::dns::LabelSequence& new_suffix);
//@}
- typename DomainTreeNode<T,DT>::DomainTreeNodePtr root_;
+ typename DomainTreeNode<T, DT>::DomainTreeNodePtr root_;
/// the node count of current tree
unsigned int node_count_;
- /// search policy for rbtree
+ /// search policy for domaintree
const bool needsReturnEmptyNode_;
};
template <typename T, typename DT>
-DomainTree<T,DT>::DomainTree(bool returnEmptyNode) :
+DomainTree<T, DT>::DomainTree(bool returnEmptyNode) :
root_(NULL),
node_count_(0),
needsReturnEmptyNode_(returnEmptyNode)
@@ -1342,29 +1349,29 @@ DomainTree<T,DT>::DomainTree(bool returnEmptyNode) :
}
template <typename T, typename DT>
-DomainTree<T,DT>::~DomainTree() {
+DomainTree<T, DT>::~DomainTree() {
assert(node_count_ == 0);
}
template <typename T, typename DT>
void
-DomainTree<T,DT>::deleteHelper(util::MemorySegment& mem_sgmt,
- DomainTreeNode<T,DT>* root,
+DomainTree<T, DT>::deleteHelper(util::MemorySegment& mem_sgmt,
+ DomainTreeNode<T, DT>* root,
const DT& deleter) {
if (root == NULL) {
return;
}
- DomainTreeNode<T,DT>* node = root;
+ DomainTreeNode<T, DT>* node = root;
while (root->getLeft() != NULL || root->getRight() != NULL) {
- DomainTreeNode<T,DT>* left(NULL);
- DomainTreeNode<T,DT>* right(NULL);
+ DomainTreeNode<T, DT>* left(NULL);
+ DomainTreeNode<T, DT>* right(NULL);
while ((left = node->getLeft()) != NULL ||
(right = node->getRight()) != NULL) {
node = (left != NULL) ? left : right;
}
- DomainTreeNode<T,DT>* parent = node->getParent();
+ DomainTreeNode<T, DT>* parent = node->getParent();
if (parent->getLeft() == node) {
parent->left_ = NULL;
} else {
@@ -1373,24 +1380,24 @@ DomainTree<T,DT>::deleteHelper(util::MemorySegment& mem_sgmt,
deleteHelper(mem_sgmt, node->getDown(), deleter);
deleter(node->data_);
- DomainTreeNode<T,DT>::destroy(mem_sgmt, node);
+ DomainTreeNode<T, DT>::destroy(mem_sgmt, node);
--node_count_;
node = parent;
}
deleteHelper(mem_sgmt, root->getDown(), deleter);
deleter(root->data_);
- DomainTreeNode<T,DT>::destroy(mem_sgmt, root);
+ DomainTreeNode<T, DT>::destroy(mem_sgmt, root);
--node_count_;
}
template <typename T, typename DT>
template <typename CBARG>
-typename DomainTree<T,DT>::Result
-DomainTree<T,DT>::find(const isc::dns::LabelSequence& target_labels_orig,
- DomainTreeNode<T,DT>** target,
- DomainTreeNodeChain<T,DT>& node_path,
- bool (*callback)(const DomainTreeNode<T,DT>&, CBARG),
+typename DomainTree<T, DT>::Result
+DomainTree<T, DT>::find(const isc::dns::LabelSequence& target_labels_orig,
+ DomainTreeNode<T, DT>** target,
+ DomainTreeNodeChain<T, DT>& node_path,
+ bool (*callback)(const DomainTreeNode<T, DT>&, CBARG),
CBARG callback_arg) const
{
if (!node_path.isEmpty()) {
@@ -1398,7 +1405,7 @@ DomainTree<T,DT>::find(const isc::dns::LabelSequence& target_labels_orig,
"DomainTree::find is given a non empty chain");
}
- DomainTreeNode<T,DT>* node = root_.get();
+ DomainTreeNode<T, DT>* node = root_.get();
Result ret = NOTFOUND;
dns::LabelSequence target_labels(target_labels_orig);
@@ -1426,7 +1433,7 @@ DomainTree<T,DT>::find(const isc::dns::LabelSequence& target_labels_orig,
ret = PARTIALMATCH;
*target = node;
if (callback != NULL &&
- node->getFlag(DomainTreeNode<T,DT>::FLAG_CALLBACK)) {
+ node->getFlag(DomainTreeNode<T, DT>::FLAG_CALLBACK)) {
if ((callback)(*node, callback_arg)) {
break;
}
@@ -1446,19 +1453,19 @@ DomainTree<T,DT>::find(const isc::dns::LabelSequence& target_labels_orig,
}
template <typename T, typename DT>
-const DomainTreeNode<T,DT>*
-DomainTree<T,DT>::nextNode(DomainTreeNodeChain<T,DT>& node_path) const {
+const DomainTreeNode<T, DT>*
+DomainTree<T, DT>::nextNode(DomainTreeNodeChain<T, DT>& node_path) const {
if (node_path.isEmpty()) {
isc_throw(isc::BadValue,
"DomainTree::nextNode is given an empty chain");
}
- const DomainTreeNode<T,DT>* node = node_path.top();
+ const DomainTreeNode<T, DT>* node = node_path.top();
// if node has sub domain, the next domain is the smallest
// domain in sub domain tree
- const DomainTreeNode<T,DT>* down = node->getDown();
+ const DomainTreeNode<T, DT>* down = node->getDown();
if (down != NULL) {
- const DomainTreeNode<T,DT>* left_most = down;
+ const DomainTreeNode<T, DT>* left_most = down;
while (left_most->getLeft() != NULL) {
left_most = left_most->getLeft();
}
@@ -1472,7 +1479,7 @@ DomainTree<T,DT>::nextNode(DomainTreeNodeChain<T,DT>& node_path) const {
// up node doesn't have successor we gonna keep moving to up
// level
while (!node_path.isEmpty()) {
- const DomainTreeNode<T,DT>* up_node_successor =
+ const DomainTreeNode<T, DT>* up_node_successor =
node_path.top()->successor();
node_path.pop();
if (up_node_successor != NULL) {
@@ -1485,8 +1492,8 @@ DomainTree<T,DT>::nextNode(DomainTreeNodeChain<T,DT>& node_path) const {
}
template <typename T, typename DT>
-const DomainTreeNode<T,DT>*
-DomainTree<T,DT>::previousNode(DomainTreeNodeChain<T,DT>& node_path) const {
+const DomainTreeNode<T, DT>*
+DomainTree<T, DT>::previousNode(DomainTreeNodeChain<T, DT>& node_path) const {
if (getNodeCount() == 0) {
// Special case for empty trees. It would look every time like
// we didn't search, because the last compared is empty. This is
@@ -1526,13 +1533,13 @@ DomainTree<T,DT>::previousNode(DomainTreeNodeChain<T,DT>& node_path) const {
// compared one (it is either the compared one, or some
// subdomain of it). There probably is not an easy trick
// for this, so we just find the correct place.
- const DomainTreeNode<T,DT>* current(node_path.last_compared_);
+ const DomainTreeNode<T, DT>* current(node_path.last_compared_);
while (current != NULL) {
node_path.push(current);
// Go a level down and as much right there as possible
current = current->getDown();
if (current != NULL) {
- const DomainTreeNode<T,DT>* right;
+ const DomainTreeNode<T, DT>* right;
while ((right = current->getRight()) != NULL) {
current = right;
}
@@ -1583,7 +1590,7 @@ DomainTree<T,DT>::previousNode(DomainTreeNodeChain<T,DT>& node_path) const {
return (NULL);
}
- const DomainTreeNode<T,DT>* node(node_path.top());
+ const DomainTreeNode<T, DT>* node(node_path.top());
// Try going left in this tree
node = node->predecessor();
@@ -1606,13 +1613,13 @@ DomainTree<T,DT>::previousNode(DomainTreeNodeChain<T,DT>& node_path) const {
node_path.push(node);
// Try going as deep as possible, keeping on the right side of the trees
- const DomainTreeNode<T,DT>* down;
+ const DomainTreeNode<T, DT>* down;
while ((down = node->getDown()) != NULL) {
// Move to the tree below
node = down;
if (node != NULL) {
// And get as much to the right of the tree as possible
- const DomainTreeNode<T,DT>* right;
+ const DomainTreeNode<T, DT>* right;
while ((right = node->getRight()) != NULL) {
node = right;
}
@@ -1628,14 +1635,14 @@ DomainTree<T,DT>::previousNode(DomainTreeNodeChain<T,DT>& node_path) const {
}
template <typename T, typename DT>
-typename DomainTree<T,DT>::Result
-DomainTree<T,DT>::insert(util::MemorySegment& mem_sgmt,
+typename DomainTree<T, DT>::Result
+DomainTree<T, DT>::insert(util::MemorySegment& mem_sgmt,
const isc::dns::Name& target_name,
- DomainTreeNode<T,DT>** new_node)
+ DomainTreeNode<T, DT>** new_node)
{
- DomainTreeNode<T,DT>* parent = NULL;
- DomainTreeNode<T,DT>* current = root_.get();
- DomainTreeNode<T,DT>* up_node = NULL;
+ DomainTreeNode<T, DT>* parent = NULL;
+ DomainTreeNode<T, DT>* current = root_.get();
+ DomainTreeNode<T, DT>* up_node = NULL;
isc::dns::LabelSequence target_labels(target_name);
int order = -1;
@@ -1674,17 +1681,17 @@ DomainTree<T,DT>::insert(util::MemorySegment& mem_sgmt,
}
}
- typename DomainTreeNode<T,DT>::DomainTreeNodePtr* current_root =
+ typename DomainTreeNode<T, DT>::DomainTreeNodePtr* current_root =
(up_node != NULL) ? &(up_node->down_) : &root_;
// Once a new node is created, no exception will be thrown until the end
// of the function, so we can simply create and hold a new node pointer.
- DomainTreeNode<T,DT>* node = DomainTreeNode<T,DT>::create(mem_sgmt,
+ DomainTreeNode<T, DT>* node = DomainTreeNode<T, DT>::create(mem_sgmt,
target_labels);
node->parent_ = parent;
if (parent == NULL) {
*current_root = node;
// node is the new root of sub tree, so its init color is BLACK
- node->setColor(DomainTreeNode<T,DT>::BLACK);
+ node->setColor(DomainTreeNode<T, DT>::BLACK);
node->setSubTreeRoot(true);
node->parent_ = up_node;
} else if (order < 0) {
@@ -1705,7 +1712,7 @@ DomainTree<T,DT>::insert(util::MemorySegment& mem_sgmt,
template <typename T, typename DT>
void
-DomainTree<T,DT>::deleteAllNodes(util::MemorySegment& mem_sgmt) {
+DomainTree<T, DT>::deleteAllNodes(util::MemorySegment& mem_sgmt) {
const DT deleter;
deleteHelper(mem_sgmt, root_.get(), deleter);
root_ = NULL;
@@ -1718,8 +1725,8 @@ DomainTree<T,DT>::deleteAllNodes(util::MemorySegment& mem_sgmt) {
// See Trac #2054.
template <typename T, typename DT>
void
-DomainTree<T,DT>::nodeFission(util::MemorySegment& mem_sgmt,
- DomainTreeNode<T,DT>& node,
+DomainTree<T, DT>::nodeFission(util::MemorySegment& mem_sgmt,
+ DomainTreeNode<T, DT>& node,
const isc::dns::LabelSequence& new_prefix,
const isc::dns::LabelSequence& new_suffix)
{
@@ -1728,7 +1735,7 @@ DomainTree<T,DT>::nodeFission(util::MemorySegment& mem_sgmt,
// the end of the function, and it will keep consistent behavior
// (i.e., a weak form of strong exception guarantee) even if code
// after the call to this function throws an exception.
- DomainTreeNode<T,DT>* down_node = DomainTreeNode<T,DT>::create(mem_sgmt,
+ DomainTreeNode<T, DT>* down_node = DomainTreeNode<T, DT>::create(mem_sgmt,
new_prefix);
node.resetLabels(new_suffix);
@@ -1757,7 +1764,7 @@ DomainTree<T,DT>::nodeFission(util::MemorySegment& mem_sgmt,
node.setColor(down_node->getColor());
// root node of sub tree, the initial color is BLACK
- down_node->setColor(DomainTreeNode<T,DT>::BLACK);
+ down_node->setColor(DomainTreeNode<T, DT>::BLACK);
// mark it as the root of a subtree
down_node->setSubTreeRoot(true);
@@ -1768,25 +1775,25 @@ DomainTree<T,DT>::nodeFission(util::MemorySegment& mem_sgmt,
template <typename T, typename DT>
void
-DomainTree<T,DT>::insertRebalance
- (typename DomainTreeNode<T,DT>::DomainTreeNodePtr* root,
- DomainTreeNode<T,DT>* node)
+DomainTree<T, DT>::insertRebalance
+ (typename DomainTreeNode<T, DT>::DomainTreeNodePtr* root,
+ DomainTreeNode<T, DT>* node)
{
- DomainTreeNode<T,DT>* uncle;
- DomainTreeNode<T,DT>* parent;
+ DomainTreeNode<T, DT>* uncle;
+ DomainTreeNode<T, DT>* parent;
while (node != (*root).get() &&
((parent = node->getParent())->getColor()) ==
- DomainTreeNode<T,DT>::RED) {
+ DomainTreeNode<T, DT>::RED) {
// Here, node->parent_ is not NULL and it is also red, so
// node->parent_->parent_ is also not NULL.
if (parent == parent->getParent()->getLeft()) {
uncle = parent->getParent()->getRight();
if (uncle != NULL && uncle->getColor() ==
- DomainTreeNode<T,DT>::RED) {
- parent->setColor(DomainTreeNode<T,DT>::BLACK);
- uncle->setColor(DomainTreeNode<T,DT>::BLACK);
- parent->getParent()->setColor(DomainTreeNode<T,DT>::RED);
+ DomainTreeNode<T, DT>::RED) {
+ parent->setColor(DomainTreeNode<T, DT>::BLACK);
+ uncle->setColor(DomainTreeNode<T, DT>::BLACK);
+ parent->getParent()->setColor(DomainTreeNode<T, DT>::RED);
node = parent->getParent();
} else {
if (node == parent->getRight()) {
@@ -1794,18 +1801,18 @@ DomainTree<T,DT>::insertRebalance
leftRotate(root, node);
parent = node->getParent();
}
- parent->setColor(DomainTreeNode<T,DT>::BLACK);
- parent->getParent()->setColor(DomainTreeNode<T,DT>::RED);
+ parent->setColor(DomainTreeNode<T, DT>::BLACK);
+ parent->getParent()->setColor(DomainTreeNode<T, DT>::RED);
rightRotate(root, parent->getParent());
}
} else {
uncle = parent->getParent()->getLeft();
if (uncle != NULL && uncle->getColor() ==
- DomainTreeNode<T,DT>::RED) {
- parent->setColor(DomainTreeNode<T,DT>::BLACK);
- uncle->setColor(DomainTreeNode<T,DT>::BLACK);
- parent->getParent()->setColor(DomainTreeNode<T,DT>::RED);
+ DomainTreeNode<T, DT>::RED) {
+ parent->setColor(DomainTreeNode<T, DT>::BLACK);
+ uncle->setColor(DomainTreeNode<T, DT>::BLACK);
+ parent->getParent()->setColor(DomainTreeNode<T, DT>::RED);
node = parent->getParent();
} else {
if (node == parent->getLeft()) {
@@ -1813,31 +1820,31 @@ DomainTree<T,DT>::insertRebalance
rightRotate(root, node);
parent = node->getParent();
}
- parent->setColor(DomainTreeNode<T,DT>::BLACK);
- parent->getParent()->setColor(DomainTreeNode<T,DT>::RED);
+ parent->setColor(DomainTreeNode<T, DT>::BLACK);
+ parent->getParent()->setColor(DomainTreeNode<T, DT>::RED);
leftRotate(root, parent->getParent());
}
}
}
- (*root)->setColor(DomainTreeNode<T,DT>::BLACK);
+ (*root)->setColor(DomainTreeNode<T, DT>::BLACK);
}
template <typename T, typename DT>
-DomainTreeNode<T,DT>*
-DomainTree<T,DT>::leftRotate
- (typename DomainTreeNode<T,DT>::DomainTreeNodePtr* root,
- DomainTreeNode<T,DT>* node)
+DomainTreeNode<T, DT>*
+DomainTree<T, DT>::leftRotate
+ (typename DomainTreeNode<T, DT>::DomainTreeNodePtr* root,
+ DomainTreeNode<T, DT>* node)
{
- DomainTreeNode<T,DT>* const right = node->getRight();
- DomainTreeNode<T,DT>* const rleft = right->getLeft();
+ DomainTreeNode<T, DT>* const right = node->getRight();
+ DomainTreeNode<T, DT>* const rleft = right->getLeft();
node->right_ = rleft;
if (rleft != NULL) {
rleft->parent_ = node;
}
- DomainTreeNode<T,DT>* const parent = node->getParent();
+ DomainTreeNode<T, DT>* const parent = node->getParent();
right->parent_ = parent;
if (!node->isSubTreeRoot()) {
@@ -1859,19 +1866,19 @@ DomainTree<T,DT>::leftRotate
}
template <typename T, typename DT>
-DomainTreeNode<T,DT>*
-DomainTree<T,DT>::rightRotate
- (typename DomainTreeNode<T,DT>::DomainTreeNodePtr* root,
- DomainTreeNode<T,DT>* node)
+DomainTreeNode<T, DT>*
+DomainTree<T, DT>::rightRotate
+ (typename DomainTreeNode<T, DT>::DomainTreeNodePtr* root,
+ DomainTreeNode<T, DT>* node)
{
- DomainTreeNode<T,DT>* const left = node->getLeft();
- DomainTreeNode<T,DT>* const lright = left->getRight();
+ DomainTreeNode<T, DT>* const left = node->getLeft();
+ DomainTreeNode<T, DT>* const lright = left->getRight();
node->left_ = lright;
if (lright != NULL) {
lright->parent_ = node;
}
- DomainTreeNode<T,DT>* const parent = node->getParent();
+ DomainTreeNode<T, DT>* const parent = node->getParent();
left->parent_ = parent;
if (!node->isSubTreeRoot()) {
@@ -1895,7 +1902,7 @@ DomainTree<T,DT>::rightRotate
template <typename T, typename DT>
void
-DomainTree<T,DT>::dumpTree(std::ostream& os, unsigned int depth) const {
+DomainTree<T, DT>::dumpTree(std::ostream& os, unsigned int depth) const {
indent(os, depth);
os << "tree has " << node_count_ << " node(s)\n";
dumpTreeHelper(os, root_.get(), depth);
@@ -1903,8 +1910,8 @@ DomainTree<T,DT>::dumpTree(std::ostream& os, unsigned int depth) const {
template <typename T, typename DT>
void
-DomainTree<T,DT>::dumpTreeHelper(std::ostream& os,
- const DomainTreeNode<T,DT>* node,
+DomainTree<T, DT>::dumpTreeHelper(std::ostream& os,
+ const DomainTreeNode<T, DT>* node,
unsigned int depth) const
{
if (node == NULL) {
@@ -1915,7 +1922,7 @@ DomainTree<T,DT>::dumpTreeHelper(std::ostream& os,
indent(os, depth);
os << node->getLabels() << " ("
- << ((node->getColor() == DomainTreeNode<T,DT>::BLACK) ? "black" : "red")
+ << ((node->getColor() == DomainTreeNode<T, DT>::BLACK) ? "black" : "red")
<< ")";
if (node->isEmpty()) {
os << " [invisible]";
@@ -1925,7 +1932,7 @@ DomainTree<T,DT>::dumpTreeHelper(std::ostream& os,
}
os << "\n";
- const DomainTreeNode<T,DT>* down = node->getDown();
+ const DomainTreeNode<T, DT>* down = node->getDown();
if (down != NULL) {
indent(os, depth + 1);
os << "begin down from " << node->getLabels() << "\n";
@@ -1939,14 +1946,14 @@ DomainTree<T,DT>::dumpTreeHelper(std::ostream& os,
template <typename T, typename DT>
void
-DomainTree<T,DT>::indent(std::ostream& os, unsigned int depth) {
+DomainTree<T, DT>::indent(std::ostream& os, unsigned int depth) {
static const unsigned int INDENT_FOR_EACH_DEPTH = 5;
os << std::string(depth * INDENT_FOR_EACH_DEPTH, ' ');
}
template <typename T, typename DT>
void
-DomainTree<T,DT>::dumpDot(std::ostream& os, bool show_pointers) const {
+DomainTree<T, DT>::dumpDot(std::ostream& os, bool show_pointers) const {
int nodecount = 0;
os << "digraph g {\n";
@@ -1957,8 +1964,8 @@ DomainTree<T,DT>::dumpDot(std::ostream& os, bool show_pointers) const {
template <typename T, typename DT>
int
-DomainTree<T,DT>::dumpDotHelper(std::ostream& os,
- const DomainTreeNode<T,DT>* node,
+DomainTree<T, DT>::dumpDotHelper(std::ostream& os,
+ const DomainTreeNode<T, DT>* node,
int* nodecount, bool show_pointers) const
{
if (node == NULL) {
@@ -1979,7 +1986,7 @@ DomainTree<T,DT>::dumpDotHelper(std::ostream& os,
}
os << "\"] [";
- if (node->getColor() == DomainTreeNode<T,DT>::RED) {
+ if (node->getColor() == DomainTreeNode<T, DT>::RED) {
os << "color=red";
} else {
os << "color=black";
diff --git a/src/lib/datasrc/memory/tests/domaintree_unittest.cc b/src/lib/datasrc/memory/tests/domaintree_unittest.cc
index 8ff9437..ff5ba94 100644
--- a/src/lib/datasrc/memory/tests/domaintree_unittest.cc
+++ b/src/lib/datasrc/memory/tests/domaintree_unittest.cc
@@ -38,7 +38,7 @@ using namespace isc::datasrc::memory;
// EXPECT_xxx macros, for which we need an explicit empty definition.
const size_t Name::MAX_LABELS;
-/* The initial structure of rbtree
+/* The initial structure of dtree
*
* .
* |
@@ -61,6 +61,8 @@ namespace {
class DeleterType {
public:
+ DeleterType() {}
+
void operator()(int* i) const {
delete i;
}
@@ -87,139 +89,139 @@ private:
class DomainTreeTest : public::testing::Test {
protected:
DomainTreeTest() :
- rbtree_holder_(mem_sgmt_, TestDomainTree::create(mem_sgmt_)),
- rbtree_expose_empty_node_holder_(mem_sgmt_,
+ dtree_holder_(mem_sgmt_, TestDomainTree::create(mem_sgmt_)),
+ dtree_expose_empty_node_holder_(mem_sgmt_,
TestDomainTree::create(mem_sgmt_, true)),
- rbtree(*rbtree_holder_.get()),
- rbtree_expose_empty_node(*rbtree_expose_empty_node_holder_.get()),
- crbtnode(NULL)
+ dtree(*dtree_holder_.get()),
+ dtree_expose_empty_node(*dtree_expose_empty_node_holder_.get()),
+ cdtnode(NULL)
{
const char* const domain_names[] = {
"c", "b", "a", "x.d.e.f", "z.d.e.f", "g.h", "i.g.h", "o.w.y.d.e.f",
"j.z.d.e.f", "p.w.y.d.e.f", "q.w.y.d.e.f", "k.g.h"};
int name_count = sizeof(domain_names) / sizeof(domain_names[0]);
for (int i = 0; i < name_count; ++i) {
- rbtree.insert(mem_sgmt_, Name(domain_names[i]), &rbtnode);
- rbtnode->setData(new int(i + 1));
+ dtree.insert(mem_sgmt_, Name(domain_names[i]), &dtnode);
+ dtnode->setData(new int(i + 1));
- rbtree_expose_empty_node.insert(mem_sgmt_, Name(domain_names[i]),
- &rbtnode);
- rbtnode->setData(new int(i + 1));
+ dtree_expose_empty_node.insert(mem_sgmt_, Name(domain_names[i]),
+ &dtnode);
+ dtnode->setData(new int(i + 1));
}
}
util::MemorySegmentLocal mem_sgmt_;
- TreeHolder rbtree_holder_;
- TreeHolder rbtree_expose_empty_node_holder_;
- TestDomainTree& rbtree;
- TestDomainTree& rbtree_expose_empty_node;
- TestDomainTreeNode* rbtnode;
- const TestDomainTreeNode* crbtnode;
+ TreeHolder dtree_holder_;
+ TreeHolder dtree_expose_empty_node_holder_;
+ TestDomainTree& dtree;
+ TestDomainTree& dtree_expose_empty_node;
+ TestDomainTreeNode* dtnode;
+ const TestDomainTreeNode* cdtnode;
};
TEST_F(DomainTreeTest, nodeCount) {
- EXPECT_EQ(15, rbtree.getNodeCount());
+ EXPECT_EQ(15, dtree.getNodeCount());
// Delete all nodes, then the count should be set to 0. This also tests
// the behavior of deleteAllNodes().
- rbtree.deleteAllNodes(mem_sgmt_);
- EXPECT_EQ(0, rbtree.getNodeCount());
+ dtree.deleteAllNodes(mem_sgmt_);
+ EXPECT_EQ(0, dtree.getNodeCount());
}
TEST_F(DomainTreeTest, setGetData) {
- rbtnode->setData(new int(11));
- EXPECT_EQ(11, *(rbtnode->getData()));
+ dtnode->setData(new int(11));
+ EXPECT_EQ(11, *(dtnode->getData()));
}
TEST_F(DomainTreeTest, insertNames) {
- EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt_,
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, dtree.insert(mem_sgmt_,
Name("d.e.f"),
- &rbtnode));
- EXPECT_EQ(Name("d.e.f"), rbtnode->getName());
- EXPECT_EQ(15, rbtree.getNodeCount());
+ &dtnode));
+ EXPECT_EQ(Name("d.e.f"), dtnode->getName());
+ EXPECT_EQ(15, dtree.getNodeCount());
// insert not exist node
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("0"),
- &rbtnode));
- EXPECT_EQ(Name("0"), rbtnode->getName());
- EXPECT_EQ(16, rbtree.getNodeCount());
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("0"),
+ &dtnode));
+ EXPECT_EQ(Name("0"), dtnode->getName());
+ EXPECT_EQ(16, dtree.getNodeCount());
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_,
Name("example.com"),
- &rbtnode));
- EXPECT_EQ(17, rbtree.getNodeCount());
- rbtnode->setData(new int(12));
+ &dtnode));
+ EXPECT_EQ(17, dtree.getNodeCount());
+ dtnode->setData(new int(12));
// return ALREADYEXISTS, since node "example.com" already has
// been explicitly inserted
- EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt_,
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, dtree.insert(mem_sgmt_,
Name("example.com"),
- &rbtnode));
- EXPECT_EQ(17, rbtree.getNodeCount());
+ &dtnode));
+ EXPECT_EQ(17, dtree.getNodeCount());
// split the node "d.e.f"
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("k.e.f"),
- &rbtnode));
- EXPECT_EQ(Name("k"), rbtnode->getName());
- EXPECT_EQ(19, rbtree.getNodeCount());
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("k.e.f"),
+ &dtnode));
+ EXPECT_EQ(Name("k"), dtnode->getName());
+ EXPECT_EQ(19, dtree.getNodeCount());
// split the node "g.h"
- EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt_, Name("h"),
- &rbtnode));
- EXPECT_EQ(Name("h"), rbtnode->getName());
- EXPECT_EQ(20, rbtree.getNodeCount());
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, dtree.insert(mem_sgmt_, Name("h"),
+ &dtnode));
+ EXPECT_EQ(Name("h"), dtnode->getName());
+ EXPECT_EQ(20, dtree.getNodeCount());
// add child domain
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_,
Name("m.p.w.y.d.e.f"),
- &rbtnode));
- EXPECT_EQ(Name("m"), rbtnode->getName());
- EXPECT_EQ(21, rbtree.getNodeCount());
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
+ &dtnode));
+ EXPECT_EQ(Name("m"), dtnode->getName());
+ EXPECT_EQ(21, dtree.getNodeCount());
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_,
Name("n.p.w.y.d.e.f"),
- &rbtnode));
- EXPECT_EQ(Name("n"), rbtnode->getName());
- EXPECT_EQ(22, rbtree.getNodeCount());
-
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("l.a"),
- &rbtnode));
- EXPECT_EQ(Name("l"), rbtnode->getName());
- EXPECT_EQ(23, rbtree.getNodeCount());
-
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("r.d.e.f"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("s.d.e.f"),
- &rbtnode));
- EXPECT_EQ(25, rbtree.getNodeCount());
-
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
+ &dtnode));
+ EXPECT_EQ(Name("n"), dtnode->getName());
+ EXPECT_EQ(22, dtree.getNodeCount());
+
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("l.a"),
+ &dtnode));
+ EXPECT_EQ(Name("l"), dtnode->getName());
+ EXPECT_EQ(23, dtree.getNodeCount());
+
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("r.d.e.f"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("s.d.e.f"),
+ &dtnode));
+ EXPECT_EQ(25, dtree.getNodeCount());
+
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_,
Name("h.w.y.d.e.f"),
- &rbtnode));
+ &dtnode));
// add more nodes one by one to cover leftRotate and rightRotate
- EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt_, Name("f"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("m"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("nm"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("om"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("k"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("l"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("fe"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("ge"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("i"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("ae"),
- &rbtnode));
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_, Name("n"),
- &rbtnode));
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, dtree.insert(mem_sgmt_, Name("f"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("m"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("nm"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("om"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("k"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("l"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("fe"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("ge"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("i"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("ae"),
+ &dtnode));
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_, Name("n"),
+ &dtnode));
}
TEST_F(DomainTreeTest, subTreeRoot) {
@@ -229,103 +231,103 @@ TEST_F(DomainTreeTest, subTreeRoot) {
// copied correctly.
EXPECT_EQ(TestDomainTree::ALREADYEXISTS,
- rbtree_expose_empty_node.insert(mem_sgmt_, Name("d.e.f"),
- &rbtnode));
+ dtree_expose_empty_node.insert(mem_sgmt_, Name("d.e.f"),
+ &dtnode));
EXPECT_EQ(TestDomainTree::SUCCESS,
- rbtree_expose_empty_node.insert(mem_sgmt_, Name("0"),
- &rbtnode));
+ dtree_expose_empty_node.insert(mem_sgmt_, Name("0"),
+ &dtnode));
EXPECT_EQ(TestDomainTree::SUCCESS,
- rbtree_expose_empty_node.insert(mem_sgmt_, Name("example.com"),
- &rbtnode));
+ dtree_expose_empty_node.insert(mem_sgmt_, Name("example.com"),
+ &dtnode));
EXPECT_EQ(TestDomainTree::ALREADYEXISTS,
- rbtree_expose_empty_node.insert(mem_sgmt_, Name("example.com"),
- &rbtnode));
+ dtree_expose_empty_node.insert(mem_sgmt_, Name("example.com"),
+ &dtnode));
EXPECT_EQ(TestDomainTree::SUCCESS,
- rbtree_expose_empty_node.insert(mem_sgmt_, Name("k.e.f"),
- &rbtnode));
+ dtree_expose_empty_node.insert(mem_sgmt_, Name("k.e.f"),
+ &dtnode));
// "g.h" is not a subtree root
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree_expose_empty_node.find(Name("g.h"), &rbtnode));
- EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
+ dtree_expose_empty_node.find(Name("g.h"), &dtnode));
+ EXPECT_FALSE(dtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
// fission the node "g.h"
EXPECT_EQ(TestDomainTree::ALREADYEXISTS,
- rbtree_expose_empty_node.insert(mem_sgmt_, Name("h"),
- &rbtnode));
+ dtree_expose_empty_node.insert(mem_sgmt_, Name("h"),
+ &dtnode));
// the node "h" (h.down_ -> "g") should not be a subtree root. "g"
// should be a subtree root.
- EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
+ EXPECT_FALSE(dtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
// "g.h" should be a subtree root now.
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree_expose_empty_node.find(Name("g.h"), &rbtnode));
- EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
+ dtree_expose_empty_node.find(Name("g.h"), &dtnode));
+ EXPECT_TRUE(dtnode->getFlag(TestDomainTreeNode::FLAG_SUBTREE_ROOT));
}
TEST_F(DomainTreeTest, findName) {
- // find const rbtnode
+ // find const dtnode
// exact match
- EXPECT_EQ(TestDomainTree::EXACTMATCH, rbtree.find(Name("a"), &crbtnode));
- EXPECT_EQ(Name("a"), crbtnode->getName());
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, dtree.find(Name("a"), &cdtnode));
+ EXPECT_EQ(Name("a"), cdtnode->getName());
// not found
- EXPECT_EQ(TestDomainTree::NOTFOUND, rbtree.find(Name("d.e.f"), &crbtnode));
- EXPECT_EQ(TestDomainTree::NOTFOUND, rbtree.find(Name("y.d.e.f"), &crbtnode));
- EXPECT_EQ(TestDomainTree::NOTFOUND, rbtree.find(Name("x"), &crbtnode));
- EXPECT_EQ(TestDomainTree::NOTFOUND, rbtree.find(Name("m.n"), &crbtnode));
+ EXPECT_EQ(TestDomainTree::NOTFOUND, dtree.find(Name("d.e.f"), &cdtnode));
+ EXPECT_EQ(TestDomainTree::NOTFOUND, dtree.find(Name("y.d.e.f"), &cdtnode));
+ EXPECT_EQ(TestDomainTree::NOTFOUND, dtree.find(Name("x"), &cdtnode));
+ EXPECT_EQ(TestDomainTree::NOTFOUND, dtree.find(Name("m.n"), &cdtnode));
// if we expose empty node, we can get the empty node created during insert
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree_expose_empty_node.find(Name("d.e.f"), &crbtnode));
+ dtree_expose_empty_node.find(Name("d.e.f"), &cdtnode));
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree_expose_empty_node.find(Name("w.y.d.e.f"), &crbtnode));
+ dtree_expose_empty_node.find(Name("w.y.d.e.f"), &cdtnode));
// partial match
- EXPECT_EQ(TestDomainTree::PARTIALMATCH, rbtree.find(Name("m.b"), &crbtnode));
- EXPECT_EQ(Name("b"), crbtnode->getName());
+ EXPECT_EQ(TestDomainTree::PARTIALMATCH, dtree.find(Name("m.b"), &cdtnode));
+ EXPECT_EQ(Name("b"), cdtnode->getName());
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- rbtree_expose_empty_node.find(Name("m.d.e.f"), &crbtnode));
+ dtree_expose_empty_node.find(Name("m.d.e.f"), &cdtnode));
- // find rbtnode
- EXPECT_EQ(TestDomainTree::EXACTMATCH, rbtree.find(Name("q.w.y.d.e.f"),
- &rbtnode));
- EXPECT_EQ(Name("q"), rbtnode->getName());
+ // find dtnode
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, dtree.find(Name("q.w.y.d.e.f"),
+ &dtnode));
+ EXPECT_EQ(Name("q"), dtnode->getName());
}
TEST_F(DomainTreeTest, findError) {
// For the version that takes a node chain, the chain must be empty.
TestDomainTreeNodeChain chain;
- EXPECT_EQ(TestDomainTree::EXACTMATCH, rbtree.find(Name("a"), &crbtnode,
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, dtree.find(Name("a"), &cdtnode,
chain));
// trying to reuse the same chain. it should result in an exception.
- EXPECT_THROW(rbtree.find(Name("a"), &crbtnode, chain),
+ EXPECT_THROW(dtree.find(Name("a"), &cdtnode, chain),
BadValue);
}
TEST_F(DomainTreeTest, flags) {
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt_,
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt_,
Name("flags.example"),
- &rbtnode));
+ &dtnode));
// by default, flags are all off
- EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ EXPECT_FALSE(dtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
// set operation, by default it enables the flag
- rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
- EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ dtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
+ EXPECT_TRUE(dtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
// try disable the flag explicitly
- rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, false);
- EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ dtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, false);
+ EXPECT_FALSE(dtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
// try enable the flag explicitly
- rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, true);
- EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ dtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, true);
+ EXPECT_TRUE(dtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
// setting an unknown flag will trigger an exception
- EXPECT_THROW(rbtnode->setFlag(static_cast<TestDomainTreeNode::Flags>(2), true),
+ EXPECT_THROW(dtnode->setFlag(static_cast<TestDomainTreeNode::Flags>(2), true),
isc::InvalidParameter);
}
@@ -337,63 +339,63 @@ testCallback(const TestDomainTreeNode&, bool* callback_checker) {
template <typename T>
void
-performCallbackTest(TestDomainTree& rbtree,
+performCallbackTest(TestDomainTree& dtree,
util::MemorySegmentLocal& mem_sgmt,
const T& name_called,
const T& name_not_called)
{
- TestDomainTreeNode* rbtnode;
- const TestDomainTreeNode* crbtnode;
+ TestDomainTreeNode* dtnode;
+ const TestDomainTreeNode* cdtnode;
// by default callback isn't enabled
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt,
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt,
Name("callback.example"),
- &rbtnode));
- rbtnode->setData(new int(1));
- EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ &dtnode));
+ dtnode->setData(new int(1));
+ EXPECT_FALSE(dtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
// enable/re-disable callback
- rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
- EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
- rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, false);
- EXPECT_FALSE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ dtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
+ EXPECT_TRUE(dtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ dtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK, false);
+ EXPECT_FALSE(dtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
// enable again for subsequent tests
- rbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
+ dtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
// add more levels below and above the callback node for partial match.
- TestDomainTreeNode* subrbtnode;
- EXPECT_EQ(TestDomainTree::SUCCESS, rbtree.insert(mem_sgmt,
+ TestDomainTreeNode* subdtnode;
+ EXPECT_EQ(TestDomainTree::SUCCESS, dtree.insert(mem_sgmt,
Name("sub.callback.example"),
- &subrbtnode));
- subrbtnode->setData(new int(2));
- TestDomainTreeNode* parentrbtnode;
- EXPECT_EQ(TestDomainTree::ALREADYEXISTS, rbtree.insert(mem_sgmt,
+ &subdtnode));
+ subdtnode->setData(new int(2));
+ TestDomainTreeNode* parentdtnode;
+ EXPECT_EQ(TestDomainTree::ALREADYEXISTS, dtree.insert(mem_sgmt,
Name("example"),
- &parentrbtnode));
+ &parentdtnode));
// the child/parent nodes shouldn't "inherit" the callback flag.
- // "rbtnode" may be invalid due to the insertion, so we need to re-find
+ // "dtnode" may be invalid due to the insertion, so we need to re-find
// it.
- EXPECT_EQ(TestDomainTree::EXACTMATCH, rbtree.find(Name("callback.example"),
- &rbtnode));
- EXPECT_TRUE(rbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
- EXPECT_FALSE(subrbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
- EXPECT_FALSE(parentrbtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ EXPECT_EQ(TestDomainTree::EXACTMATCH, dtree.find(Name("callback.example"),
+ &dtnode));
+ EXPECT_TRUE(dtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ EXPECT_FALSE(subdtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
+ EXPECT_FALSE(parentdtnode->getFlag(TestDomainTreeNode::FLAG_CALLBACK));
// check if the callback is called from find()
TestDomainTreeNodeChain node_path1;
bool callback_called = false;
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree.find(name_called, &crbtnode, node_path1,
+ dtree.find(name_called, &cdtnode, node_path1,
testCallback, &callback_called));
EXPECT_TRUE(callback_called);
// enable callback at the parent node, but it doesn't have data so
// the callback shouldn't be called.
TestDomainTreeNodeChain node_path2;
- parentrbtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
+ parentdtnode->setFlag(TestDomainTreeNode::FLAG_CALLBACK);
callback_called = false;
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree.find(name_not_called, &crbtnode, node_path2,
+ dtree.find(name_not_called, &cdtnode, node_path2,
testCallback, &callback_called));
EXPECT_FALSE(callback_called);
}
@@ -402,7 +404,7 @@ TEST_F(DomainTreeTest, callbackName) {
const Name n1("sub.callback.example");
const Name n2("callback.example");
- performCallbackTest(rbtree, mem_sgmt_, n1, n2);
+ performCallbackTest(dtree, mem_sgmt_, n1, n2);
}
TEST_F(DomainTreeTest, callbackLabelSequence) {
@@ -411,7 +413,7 @@ TEST_F(DomainTreeTest, callbackLabelSequence) {
const LabelSequence ls1(n1);
const LabelSequence ls2(n2);
- performCallbackTest(rbtree, mem_sgmt_, ls1, ls2);
+ performCallbackTest(dtree, mem_sgmt_, ls1, ls2);
}
TEST_F(DomainTreeTest, chainLevel) {
@@ -426,9 +428,9 @@ TEST_F(DomainTreeTest, chainLevel) {
TestDomainTree& tree(*tree_holder.get());
Name node_name(Name::ROOT_NAME());
EXPECT_EQ(TestDomainTree::SUCCESS, tree.insert(mem_sgmt_, node_name,
- &rbtnode));
+ &dtnode));
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- tree.find(node_name, &crbtnode, chain));
+ tree.find(node_name, &cdtnode, chain));
EXPECT_EQ(1, chain.getLevelCount());
/*
@@ -449,15 +451,15 @@ TEST_F(DomainTreeTest, chainLevel) {
for (unsigned int i = 2; i <= Name::MAX_LABELS; ++i) {
node_name = Name("a.").concatenate(node_name);
EXPECT_EQ(TestDomainTree::SUCCESS, tree.insert(mem_sgmt_, node_name,
- &rbtnode));
+ &dtnode));
TestDomainTreeNodeChain found_chain;
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- tree.find(node_name, &crbtnode, found_chain));
+ tree.find(node_name, &cdtnode, found_chain));
EXPECT_EQ(i, found_chain.getLevelCount());
}
// Confirm the last inserted name has the possible maximum length with
- // maximum label count. This confirms the rbtree and chain level cannot
+ // maximum label count. This confirms the dtree and chain level cannot
// be larger.
EXPECT_EQ(Name::MAX_LABELS, node_name.getLabelCount());
EXPECT_THROW(node_name.concatenate(Name("a.")), TooLongName);
@@ -504,7 +506,7 @@ TEST_F(DomainTreeTest, getUpperNode) {
TestDomainTreeNodeChain node_path;
const TestDomainTreeNode* node = NULL;
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree_expose_empty_node.find(Name(names[0]),
+ dtree_expose_empty_node.find(Name(names[0]),
&node,
node_path));
for (int i = 0; i < name_count; ++i) {
@@ -514,7 +516,7 @@ TEST_F(DomainTreeTest, getUpperNode) {
if (upper_node_names[i] != NULL) {
const TestDomainTreeNode* upper_node2 = NULL;
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree_expose_empty_node.find(Name(upper_node_names[i]),
+ dtree_expose_empty_node.find(Name(upper_node_names[i]),
&upper_node2));
EXPECT_NE(static_cast<void*>(NULL), upper_node2);
EXPECT_EQ(upper_node, upper_node2);
@@ -522,7 +524,7 @@ TEST_F(DomainTreeTest, getUpperNode) {
EXPECT_EQ(static_cast<void*>(NULL), upper_node);
}
- node = rbtree_expose_empty_node.nextNode(node_path);
+ node = dtree_expose_empty_node.nextNode(node_path);
}
// We should have reached the end of the tree.
@@ -533,11 +535,11 @@ TEST_F(DomainTreeTest, nextNode) {
TestDomainTreeNodeChain node_path;
const TestDomainTreeNode* node = NULL;
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree.find(Name(names[0]), &node, node_path));
+ dtree.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());
- node = rbtree.nextNode(node_path);
+ node = dtree.nextNode(node_path);
}
// We should have reached the end of the tree.
@@ -547,7 +549,7 @@ TEST_F(DomainTreeTest, nextNode) {
// Just walk using previousNode until the beginning of the tree and check it is
// OK
//
-// rbtree - the tree to walk
+// dtree - the tree to walk
// node - result of previous call to find(), starting position of the walk
// node_path - the path from the previous call to find(), will be modified
// chain_length - the number of names that should be in the chain to be walked
@@ -558,7 +560,7 @@ TEST_F(DomainTreeTest, nextNode) {
// (true is for finds that return no match, false for the ones that return
// match)
void
-previousWalk(TestDomainTree& rbtree, const TestDomainTreeNode* node,
+previousWalk(TestDomainTree& dtree, const TestDomainTreeNode* node,
TestDomainTreeNodeChain& node_path, size_t chain_length,
bool skip_first)
{
@@ -566,7 +568,7 @@ previousWalk(TestDomainTree& rbtree, const TestDomainTreeNode* node,
// If the first is not found, this is supposed to be NULL and we skip
// it in our checks.
EXPECT_EQ(static_cast<void*>(NULL), node);
- node = rbtree.previousNode(node_path);
+ node = dtree.previousNode(node_path);
}
for (size_t i(chain_length); i > 0; --i) {
EXPECT_NE(static_cast<void*>(NULL), node);
@@ -579,10 +581,10 @@ previousWalk(TestDomainTree& rbtree, const TestDomainTreeNode* node,
const TestDomainTreeNode* node2(NULL);
TestDomainTreeNodeChain node_path2;
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree.find(Name(names[i - 1]), &node2, node_path2));
+ dtree.find(Name(names[i - 1]), &node2, node_path2));
EXPECT_EQ(node, node2);
}
- node = rbtree.previousNode(node_path);
+ node = dtree.previousNode(node_path);
}
// We should have reached the start of the tree.
@@ -590,12 +592,12 @@ previousWalk(TestDomainTree& rbtree, const TestDomainTreeNode* node,
EXPECT_EQ(".", node->getLabels().toText());
// With one more call it results in NULL
- node = rbtree.previousNode(node_path);
+ node = dtree.previousNode(node_path);
EXPECT_EQ(static_cast<void*>(NULL), node);
// Calling previousNode() yet again should still return NULL without
// fail.
- node = rbtree.previousNode(node_path);
+ node = dtree.previousNode(node_path);
EXPECT_EQ(static_cast<void*>(NULL), node);
}
@@ -603,14 +605,14 @@ previousWalk(TestDomainTree& rbtree, const TestDomainTreeNode* node,
TEST_F(DomainTreeTest, previousNode) {
// First, iterate the whole tree from the end to the beginning.
TestDomainTreeNodeChain node_path;
- EXPECT_THROW(rbtree.previousNode(node_path), isc::BadValue) <<
+ EXPECT_THROW(dtree.previousNode(node_path), isc::BadValue) <<
"Throw before a search was done on the path";
const TestDomainTreeNode* node(NULL);
{
SCOPED_TRACE("Iterate through");
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree.find(Name(names[name_count - 1]), &node, node_path));
- previousWalk(rbtree, node, node_path, name_count, false);
+ dtree.find(Name(names[name_count - 1]), &node, node_path));
+ previousWalk(dtree, node, node_path, name_count, false);
node = NULL;
node_path.clear();
}
@@ -619,8 +621,8 @@ TEST_F(DomainTreeTest, previousNode) {
SCOPED_TRACE("Iterate from the middle");
// Now, start somewhere in the middle, but within the real node.
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree.find(Name(names[4]), &node, node_path));
- previousWalk(rbtree, node, node_path, 5, false);
+ dtree.find(Name(names[4]), &node, node_path));
+ previousWalk(dtree, node, node_path, 5, false);
node = NULL;
node_path.clear();
}
@@ -630,9 +632,9 @@ TEST_F(DomainTreeTest, previousNode) {
// If we start at the lowest (which is "a"), we get to the beginning
// right away.
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- rbtree.find(Name(names[0]), &node, node_path));
+ dtree.find(Name(names[0]), &node, node_path));
EXPECT_NE(static_cast<void*>(NULL), node);
- node = rbtree.previousNode(node_path);
+ node = dtree.previousNode(node_path);
ASSERT_NE(static_cast<void*>(NULL), node);
EXPECT_EQ(".", node->getLabels().toText());
node = NULL;
@@ -644,9 +646,9 @@ TEST_F(DomainTreeTest, previousNode) {
// If we start before the lowest (. < 0. < a.), we should not get a
// node. Its previous node should be the root.
EXPECT_EQ(TestDomainTree::NOTFOUND,
- rbtree.find<void*>(Name("0"), &node, node_path, NULL, NULL));
+ dtree.find<void*>(Name("0"), &node, node_path, NULL, NULL));
EXPECT_EQ(static_cast<void*>(NULL), node);
- node = rbtree.previousNode(node_path);
+ node = dtree.previousNode(node_path);
ASSERT_NE(static_cast<void*>(NULL), node);
EXPECT_EQ(".", node->getLabels().toText());
node = NULL;
@@ -656,8 +658,8 @@ TEST_F(DomainTreeTest, previousNode) {
{
SCOPED_TRACE("Start after the last");
EXPECT_EQ(TestDomainTree::NOTFOUND,
- rbtree.find(Name("z"), &node, node_path));
- previousWalk(rbtree, node, node_path, name_count, true);
+ dtree.find(Name("z"), &node, node_path));
+ previousWalk(dtree, node, node_path, name_count, true);
node = NULL;
node_path.clear();
}
@@ -668,8 +670,8 @@ TEST_F(DomainTreeTest, previousNode) {
// we exited - 'c' (actually, we should get it by the find, as partial
// match).
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- rbtree.find(Name("b.c"), &node, node_path));
- previousWalk(rbtree, node, node_path, 3, false);
+ dtree.find(Name("b.c"), &node, node_path));
+ previousWalk(dtree, node, node_path, 3, false);
node = NULL;
node_path.clear();
}
@@ -682,8 +684,8 @@ TEST_F(DomainTreeTest, previousNode) {
// The d.e.f is empty node, so it is hidden by find. Therefore NOTFOUND
// and not PARTIALMATCH.
EXPECT_EQ(TestDomainTree::NOTFOUND,
- rbtree.find(Name("xy.d.e.f"), &node, node_path));
- previousWalk(rbtree, node, node_path, 5, true);
+ dtree.find(Name("xy.d.e.f"), &node, node_path));
+ previousWalk(dtree, node, node_path, 5, true);
node = NULL;
node_path.clear();
}
@@ -696,8 +698,8 @@ TEST_F(DomainTreeTest, previousNode) {
// The d.e.f is empty node, so it is hidden by find. Therefore NOTFOUND
// and not PARTIALMATCH.
EXPECT_EQ(TestDomainTree::NOTFOUND,
- rbtree.find(Name("yz.d.e.f"), &node, node_path));
- previousWalk(rbtree, node, node_path, 9, true);
+ dtree.find(Name("yz.d.e.f"), &node, node_path));
+ previousWalk(dtree, node, node_path, 9, true);
node = NULL;
node_path.clear();
}
@@ -710,7 +712,7 @@ TEST_F(DomainTreeTest, previousNode) {
// 'g.h' is an empty node, so we get a NOTFOUND and not
// PARTIALMATCH.
EXPECT_EQ(TestDomainTree::NOTFOUND,
- rbtree.find(Name("x.h"), &node, node_path));
+ dtree.find(Name("x.h"), &node, node_path));
// 'g.h' is the COMMONANCESTOR.
EXPECT_EQ(node_path.getLastComparedNode()->getName(), Name("g.h"));
EXPECT_EQ(NameComparisonResult::COMMONANCESTOR,
@@ -719,7 +721,7 @@ TEST_F(DomainTreeTest, previousNode) {
EXPECT_GT(node_path.getLastComparisonResult().getOrder(), 0);
// We then descend into 'i.g.h' and walk all the nodes in the
// tree.
- previousWalk(rbtree, node, node_path, name_count, true);
+ previousWalk(dtree, node, node_path, name_count, true);
node = NULL;
node_path.clear();
}
@@ -729,8 +731,8 @@ TEST_F(DomainTreeTest, previousNode) {
// The d.e.f is a single node, but we want only part of it. We
// should start iterating before it.
EXPECT_EQ(TestDomainTree::NOTFOUND,
- rbtree.find(Name("e.f"), &node, node_path));
- previousWalk(rbtree, node, node_path, 3, true);
+ dtree.find(Name("e.f"), &node, node_path));
+ previousWalk(dtree, node, node_path, 3, true);
node = NULL;
node_path.clear();
}
@@ -753,7 +755,7 @@ TEST_F(DomainTreeTest, previousNode) {
TEST_F(DomainTreeTest, nextNodeError) {
// Empty chain for nextNode() is invalid.
TestDomainTreeNodeChain chain;
- EXPECT_THROW(rbtree.nextNode(chain), BadValue);
+ EXPECT_THROW(dtree.nextNode(chain), BadValue);
}
// A helper function for getLastComparedNode() below.
@@ -776,7 +778,7 @@ comparisonChecks(const TestDomainTreeNodeChain& chain,
}
TEST_F(DomainTreeTest, getLastComparedNode) {
- TestDomainTree& tree = rbtree_expose_empty_node; // use the "empty OK" mode
+ TestDomainTree& tree = dtree_expose_empty_node; // use the "empty OK" mode
TestDomainTreeNodeChain chain;
// initially there should be no 'last compared'.
@@ -786,7 +788,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
TreeHolder tree_holder(mem_sgmt_, TestDomainTree::create(mem_sgmt_));
TestDomainTree& empty_tree(*tree_holder.get());
EXPECT_EQ(TestDomainTree::NOTFOUND,
- empty_tree.find(Name("a"), &crbtnode, chain));
+ empty_tree.find(Name("a"), &cdtnode, chain));
EXPECT_EQ(static_cast<void*>(NULL), chain.getLastComparedNode());
chain.clear();
@@ -805,7 +807,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
EXPECT_EQ(TestDomainTree::EXACTMATCH,
tree.find(Name("k.g.h"), &expected_node));
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- tree.find(Name("x.k.g.h"), &crbtnode, chain));
+ tree.find(Name("x.k.g.h"), &cdtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// k.g.h < x.k.g.h, 1 = # labels of "k"
comparisonChecks(chain, 1, 1, NameComparisonResult::SUBDOMAIN);
@@ -816,7 +818,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
EXPECT_EQ(TestDomainTree::EXACTMATCH,
tree.find(Name("x.d.e.f"), &expected_node));
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- tree.find(Name("a.d.e.f"), &crbtnode, chain));
+ tree.find(Name("a.d.e.f"), &cdtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// a < x, no common labels
comparisonChecks(chain, -1, 0, NameComparisonResult::NONE);
@@ -827,7 +829,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
EXPECT_EQ(TestDomainTree::EXACTMATCH,
tree.find(Name("z.d.e.f"), &expected_node));
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- tree.find(Name("zz.d.e.f"), &crbtnode, chain));
+ tree.find(Name("zz.d.e.f"), &cdtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// zz > z, no common label
comparisonChecks(chain, 1, 0, NameComparisonResult::NONE);
@@ -838,7 +840,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
EXPECT_EQ(TestDomainTree::EXACTMATCH,
tree.find(Name("w.y.d.e.f"), &expected_node));
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- tree.find(Name("y.d.e.f"), &crbtnode, chain));
+ tree.find(Name("y.d.e.f"), &cdtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// y < w.y, 1 = # labels of "y"
comparisonChecks(chain, -1, 1, NameComparisonResult::SUPERDOMAIN);
@@ -848,7 +850,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
// with the search name in the subtree below the matching node.
// (the expected node is the same as the previous case)
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- tree.find(Name("z.y.d.e.f"), &crbtnode, chain));
+ tree.find(Name("z.y.d.e.f"), &cdtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// z.y > w.y, 1 = # labels of "y"
comparisonChecks(chain, 1, 1, NameComparisonResult::COMMONANCESTOR);
@@ -858,7 +860,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
// branch. (find() still returns PARTIALMATCH due to the top level ".")
EXPECT_EQ(TestDomainTree::EXACTMATCH, tree.find(Name("c"), &expected_node));
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- tree.find(Name("bb"), &crbtnode, chain));
+ tree.find(Name("bb"), &cdtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// bb < c, no common label
comparisonChecks(chain, -1, 0, NameComparisonResult::NONE);
@@ -867,7 +869,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
// Search stops in the highest level (under ".") after following a right
// branch. (the expected node is the same as the previous case)
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- tree.find(Name("d"), &crbtnode, chain));
+ tree.find(Name("d"), &cdtnode, chain));
EXPECT_EQ(expected_node, chain.getLastComparedNode());
// d > c, no common label
comparisonChecks(chain, 1, 0, NameComparisonResult::NONE);
@@ -877,7 +879,7 @@ TEST_F(DomainTreeTest, getLastComparedNode) {
TEST_F(DomainTreeTest, dumpTree) {
std::ostringstream str;
std::ostringstream str2;
- rbtree.dumpTree(str);
+ dtree.dumpTree(str);
str2 << "tree has 15 node(s)\n"
". (black) [invisible] [subtreeroot]\n"
" begin down from .\n"
@@ -931,8 +933,8 @@ TEST_F(DomainTreeTest, dumpTree) {
TEST_F(DomainTreeTest, swap) {
// Store info about the first tree
std::ostringstream str1;
- rbtree.dumpTree(str1);
- size_t count1(rbtree.getNodeCount());
+ dtree.dumpTree(str1);
+ size_t count1(dtree.getNodeCount());
// Create second one and store state
TreeHolder tree_holder(mem_sgmt_, TestDomainTree::create(mem_sgmt_));
@@ -943,15 +945,15 @@ TEST_F(DomainTreeTest, swap) {
tree2.dumpTree(str2);
// Swap them
- ASSERT_NO_THROW(tree2.swap(rbtree));
+ ASSERT_NO_THROW(tree2.swap(dtree));
// Check their sizes
- ASSERT_EQ(1, rbtree.getNodeCount());
+ ASSERT_EQ(1, dtree.getNodeCount());
ASSERT_EQ(count1, tree2.getNodeCount());
// And content
std::ostringstream out;
- rbtree.dumpTree(out);
+ dtree.dumpTree(out);
ASSERT_EQ(str2.str(), out.str());
out.str("");
tree2.dumpTree(out);
@@ -964,40 +966,40 @@ TEST_F(DomainTreeTest, swap) {
TEST_F(DomainTreeTest, root) {
TreeHolder tree_holder(mem_sgmt_, TestDomainTree::create(mem_sgmt_));
TestDomainTree& root(*tree_holder.get());
- root.insert(mem_sgmt_, Name::ROOT_NAME(), &rbtnode);
- rbtnode->setData(new int(1));
+ root.insert(mem_sgmt_, Name::ROOT_NAME(), &dtnode);
+ dtnode->setData(new int(1));
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- root.find(Name::ROOT_NAME(), &crbtnode));
- EXPECT_EQ(rbtnode, crbtnode);
+ root.find(Name::ROOT_NAME(), &cdtnode));
+ EXPECT_EQ(dtnode, cdtnode);
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- root.find(Name("example.com"), &crbtnode));
- EXPECT_EQ(rbtnode, crbtnode);
+ root.find(Name("example.com"), &cdtnode));
+ EXPECT_EQ(dtnode, cdtnode);
// Insert a new name that better matches the query name. find() should
// find the better one.
- root.insert(mem_sgmt_, Name("com"), &rbtnode);
- rbtnode->setData(new int(2));
+ root.insert(mem_sgmt_, Name("com"), &dtnode);
+ dtnode->setData(new int(2));
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- root.find(Name("example.com"), &crbtnode));
- EXPECT_EQ(rbtnode, crbtnode);
+ root.find(Name("example.com"), &cdtnode));
+ EXPECT_EQ(dtnode, cdtnode);
// Perform the same tests for the tree that allows matching against empty
// nodes.
TreeHolder tree_holder_emptyok(mem_sgmt_,
TestDomainTree::create(mem_sgmt_, true));
TestDomainTree& root_emptyok(*tree_holder_emptyok.get());
- root_emptyok.insert(mem_sgmt_, Name::ROOT_NAME(), &rbtnode);
+ root_emptyok.insert(mem_sgmt_, Name::ROOT_NAME(), &dtnode);
EXPECT_EQ(TestDomainTree::EXACTMATCH,
- root_emptyok.find(Name::ROOT_NAME(), &crbtnode));
- EXPECT_EQ(rbtnode, crbtnode);
+ root_emptyok.find(Name::ROOT_NAME(), &cdtnode));
+ EXPECT_EQ(dtnode, cdtnode);
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- root_emptyok.find(Name("example.com"), &crbtnode));
- EXPECT_EQ(rbtnode, crbtnode);
+ root_emptyok.find(Name("example.com"), &cdtnode));
+ EXPECT_EQ(dtnode, cdtnode);
- root.insert(mem_sgmt_, Name("com"), &rbtnode);
+ root.insert(mem_sgmt_, Name("com"), &dtnode);
EXPECT_EQ(TestDomainTree::PARTIALMATCH,
- root.find(Name("example.com"), &crbtnode));
- EXPECT_EQ(rbtnode, crbtnode);
+ root.find(Name("example.com"), &cdtnode));
+ EXPECT_EQ(dtnode, cdtnode);
}
}
More information about the bind10-changes
mailing list