Date view Thread view Subject view Author view

Subject: [Boost-commit] svn:boost r74969 - in sandbox/tree_node: boost boost/detail/function boost/tree_node libs/tree_node/doc libs/tree_node/doc/html libs/tree_node/doc/html/tree_node libs/tree_node/doc/html/tree_node/concepts libs/tree_node/doc/html/tree_node/reference libs/tree_node/example
From: sponage_at_[hidden]
Date: 2011-10-16 12:01:31

Author: expaler
Date: 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
New Revision: 74969
URL: http://svn.boost.org/trac/boost/changeset/74969

Log:
Boost.TreeNode candidate library: Removed RACI Tree Node concept; added Non-Associative Tree Node, Binary Tree Node, and N-ary Tree node concepts; added raw_binary_node and in_order_iterator class templates.
Added:
   sandbox/tree_node/boost/detail/function/
   sandbox/tree_node/boost/detail/function/add_const_to_2nd_pointee.hpp (contents, props changed)
   sandbox/tree_node/boost/detail/function/add_const_to_2nd_sh_ptee.hpp (contents, props changed)
   sandbox/tree_node/boost/detail/function/add_const_to_pointee.hpp (contents, props changed)
   sandbox/tree_node/boost/detail/function/add_const_to_sh_ptee.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/breadth_first_iterator.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/depth_first_iterator.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/in_order_iterator.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/post_order_iterator.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/pre_order_iterator.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/raw_associative_node.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/raw_binary_node.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/raw_node.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/simple_associative_node.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/simple_node.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/traversal_state.hpp (contents, props changed)
   sandbox/tree_node/boost/tree_node/typeof.hpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/index.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/associative_tree_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/binary_tree_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/full_tree_node_iterator.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/nary_tree_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/non_assoc_tree_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node_desc_iterator.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node_iterator.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/breadth_first_iterator.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/depth_first_iterator.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/in_order_iterator.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/post_order_iterator.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/pre_order_iterator.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_associative_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_binary_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/simple_associative_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/simple_node.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/traversal_state.html (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/default_unconstructible_type.cpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/default_unconstructible_type.hpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/raw_associative_node.cpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/raw_binary_node.cpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/raw_node.cpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/show_functions.cpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/show_functions.hpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/showcase_descendant_iterators.hpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/showcase_iterators.hpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/simple_associative_node.cpp (contents, props changed)
   sandbox/tree_node/libs/tree_node/example/simple_node.cpp (contents, props changed)
Removed:
   sandbox/tree_node/libs/tree_node/doc/concept_assoc_tree_node.qbk
   sandbox/tree_node/libs/tree_node/doc/concept_descendant_iterator.qbk
   sandbox/tree_node/libs/tree_node/doc/concept_full_iterator.qbk
   sandbox/tree_node/libs/tree_node/doc/concept_iterator.qbk
   sandbox/tree_node/libs/tree_node/doc/concept_raci_tree_node.qbk
   sandbox/tree_node/libs/tree_node/doc/concept_tree_node.qbk
   sandbox/tree_node/libs/tree_node/doc/concepts.qbk
   sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/raci_tree_node.html
   sandbox/tree_node/libs/tree_node/doc/ref_breadth_first_iterator.qbk
   sandbox/tree_node/libs/tree_node/doc/ref_depth_first_iterator.qbk
   sandbox/tree_node/libs/tree_node/doc/ref_post_order_iterator.qbk
   sandbox/tree_node/libs/tree_node/doc/ref_pre_order_iterator.qbk
   sandbox/tree_node/libs/tree_node/doc/ref_raw_associative_node.qbk
   sandbox/tree_node/libs/tree_node/doc/ref_raw_node.qbk
   sandbox/tree_node/libs/tree_node/doc/ref_simple_associative_node.qbk
   sandbox/tree_node/libs/tree_node/doc/ref_simple_node.qbk
   sandbox/tree_node/libs/tree_node/doc/ref_traversal_state.qbk
   sandbox/tree_node/libs/tree_node/doc/reference.qbk
   sandbox/tree_node/libs/tree_node/doc/tree_node.qbk

Added: sandbox/tree_node/boost/detail/function/add_const_to_2nd_pointee.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/detail/function/add_const_to_2nd_pointee.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_DETAIL_FUNCTION_ADD_CONST_TO_2ND_POINTEE_HPP_INCLUDED
+#define BOOST_DETAIL_FUNCTION_ADD_CONST_TO_2ND_POINTEE_HPP_INCLUDED
+
+#include <utility>
+
+namespace boost { namespace detail {
+
+ template <typename K, typename V>
+ struct add_const_to_2nd_pointee
+ {
+ typedef ::std::pair<K const,V const*> result_type;
+ typedef ::std::pair<K const,V*> argument_type;
+
+ result_type operator()(argument_type const& arg) const;
+ };
+
+ template <typename K, typename V>
+ inline typename add_const_to_2nd_pointee<K,V>::result_type
+ add_const_to_2nd_pointee<K,V>::operator()(
+ argument_type const& arg
+ ) const
+ {
+ return result_type(arg.first, arg.second);
+ }
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_FUNCTION_ADD_CONST_TO_2ND_POINTEE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/detail/function/add_const_to_2nd_sh_ptee.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/detail/function/add_const_to_2nd_sh_ptee.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,39 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_DETAIL_FUNCTION_ADD_CONST_TO_2ND_SH_PTEE_HPP_INCLUDED
+#define BOOST_DETAIL_FUNCTION_ADD_CONST_TO_2ND_SH_PTEE_HPP_INCLUDED
+
+#include <utility>
+#include <boost/tr1/memory.hpp>
+
+namespace boost { namespace detail {
+
+ template <typename K, typename V>
+ struct add_const_to_2nd_shared_pointee
+ {
+ typedef ::std::pair<K const,::std::tr1::shared_ptr<V const> >
+ result_type;
+ typedef ::std::pair<K const,::std::tr1::shared_ptr<V> >
+ argument_type;
+
+ result_type operator()(argument_type const& arg) const;
+ };
+
+ template <typename K, typename V>
+ inline typename add_const_to_2nd_shared_pointee<K,V>::result_type
+ add_const_to_2nd_shared_pointee<K,V>::operator()(
+ argument_type const& arg
+ ) const
+ {
+ return result_type(
+ arg.first
+ , ::std::tr1::shared_ptr<V const>(arg.second)
+ );
+ }
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_FUNCTION_ADD_CONST_TO_2ND_SH_PTEE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/detail/function/add_const_to_pointee.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/detail/function/add_const_to_pointee.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,29 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_DETAIL_FUNCTION_ADD_CONST_TO_POINTEE_HPP_INCLUDED
+#define BOOST_DETAIL_FUNCTION_ADD_CONST_TO_POINTEE_HPP_INCLUDED
+
+namespace boost { namespace detail {
+
+ template <typename T>
+ struct add_const_to_pointee
+ {
+ typedef T const* result_type;
+ typedef T* argument_type;
+
+ result_type operator()(argument_type const& arg) const;
+ };
+
+ template <typename T>
+ inline typename add_const_to_pointee<T>::result_type
+ add_const_to_pointee<T>::operator()(argument_type const& arg) const
+ {
+ return arg;
+ }
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_FUNCTION_ADD_CONST_TO_POINTEE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/detail/function/add_const_to_sh_ptee.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/detail/function/add_const_to_sh_ptee.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_DETAIL_FUNCTION_ADD_CONST_TO_SH_PTEE_HPP_INCLUDED
+#define BOOST_DETAIL_FUNCTION_ADD_CONST_TO_SH_PTEE_HPP_INCLUDED
+
+#include <boost/tr1/memory.hpp>
+
+namespace boost { namespace detail {
+
+ template <typename T>
+ struct add_const_to_shared_pointee
+ {
+ typedef ::std::tr1::shared_ptr<T const> result_type;
+ typedef ::std::tr1::shared_ptr<T> argument_type;
+
+ result_type operator()(argument_type const& arg) const;
+ };
+
+ template <typename T>
+ inline typename add_const_to_shared_pointee<T>::result_type
+ add_const_to_shared_pointee<T>::operator()(
+ argument_type const& arg
+ ) const
+ {
+ return result_type(arg);
+ }
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_FUNCTION_ADD_CONST_TO_SH_PTEE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,22 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_HPP_INCLUDED
+#define BOOST_TREE_NODE_HPP_INCLUDED
+
+#include <boost/tree_node/traversal_state.hpp>
+#include <boost/tree_node/breadth_first_iterator.hpp>
+#include <boost/tree_node/pre_order_iterator.hpp>
+#include <boost/tree_node/post_order_iterator.hpp>
+#include <boost/tree_node/depth_first_iterator.hpp>
+#include <boost/tree_node/in_order_iterator.hpp>
+#include <boost/tree_node/raw_binary_node.hpp>
+#include <boost/tree_node/raw_node.hpp>
+#include <boost/tree_node/simple_node.hpp>
+#include <boost/tree_node/raw_associative_node.hpp>
+#include <boost/tree_node/simple_associative_node.hpp>
+
+#endif // BOOST_TREE_NODE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/breadth_first_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/breadth_first_iterator.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,598 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_BREADTH_FIRST_ITERATOR_HPP_INCLUDED
+#define BOOST_TREE_BREADTH_FIRST_ITERATOR_HPP_INCLUDED
+
+#include <iterator>
+#include <deque>
+#include <boost/config.hpp>
+#include <boost/tr1/type_traits.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/equal_to.hpp>
+#ifndef BOOST_NO_SFINAE
+#include <boost/utility/enable_if.hpp>
+#endif
+#include <boost/fusion/adapted/std_pair.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/detail/metafunction/element_type.hpp>
+#include <boost/tree_node/traversal_state.hpp>
+
+//[reference__breadth_first_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename MimicsChildIterator>
+ class breadth_first_iterator
+ {
+ //<-
+ typedef typename ::boost::mpl::eval_if<
+ ::std::tr1::is_pointer<NodePointer>
+ , ::std::tr1::remove_pointer<NodePointer>
+ , ::boost::detail::element_type<NodePointer>
+ >::type
+ element_type;
+ typedef typename ::std::tr1::remove_const<element_type>::type
+ node_type;
+ typedef typename ::boost::mpl::if_<
+ ::std::tr1::is_const<element_type>
+ , typename node_type::const_child_iterator
+ , typename node_type::child_iterator
+ >::type
+ child_iterator;
+ typedef typename ::std::iterator_traits<child_iterator>::value_type
+ child_value;
+ typedef typename ::boost::fusion::traits::is_sequence<
+ child_value
+ >::type
+ is_associative;
+ typedef typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_iterator
+ , NodePointer
+ >::type
+ queue_element;
+ //->
+
+ public:
+ typedef // implementation_defined
+ //<-
+ typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_value
+ , NodePointer
+ >::type
+ //->
+ value_type;
+ typedef value_type const&
+ reference;
+ typedef // implementation_defined
+ //<-
+ typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_iterator
+ , value_type const*
+ >::type
+ //->
+ pointer;
+ typedef ::std::ptrdiff_t
+ difference_type;
+ typedef ::std::forward_iterator_tag
+ iterator_category;
+
+ //<-
+ private:
+#ifndef BOOST_NO_SFINAE
+ struct enabler
+ {
+ };
+#endif
+
+ ::std::deque<queue_element> _queue;
+ queue_element _current;
+ traversal_state _state;
+
+ public:
+ //->
+ breadth_first_iterator();
+
+ explicit breadth_first_iterator(NodePointer const& node);
+
+ template <typename NP, typename MCI>
+ breadth_first_iterator(
+ breadth_first_iterator<NP,MCI> const& other
+//<-
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ typename ::boost::mpl::if_<
+ ::std::tr1::is_convertible<NP,NodePointer>
+ , ::boost::mpl::equal_to<MCI,MimicsChildIterator>
+ , ::boost::mpl::false_
+ >::type
+ , enabler
+ >::type = enabler()
+#endif
+//->
+ );
+
+ reference operator*() const;
+
+ pointer operator->() const;
+
+ breadth_first_iterator& operator++();
+
+ breadth_first_iterator operator++(int);
+
+ operator traversal_state() const;
+
+ //<-
+ private:
+ static NodePointer
+ _deref(child_iterator const&, ::boost::mpl::true_);
+
+ static NodePointer
+ _deref(child_iterator const&, ::boost::mpl::false_);
+
+ reference _deref(::boost::mpl::true_) const;
+
+ reference _deref(::boost::mpl::false_) const;
+
+ pointer _indirect(::boost::mpl::true_) const;
+
+ pointer _indirect(::boost::mpl::false_) const;
+
+ NodePointer _current_node(::boost::mpl::true_) const;
+
+ NodePointer const& _current_node(::boost::mpl::false_) const;
+
+ void _initialize(NodePointer const&, ::boost::mpl::true_);
+
+ void _initialize(NodePointer const&, ::boost::mpl::false_);
+
+ void _push_child(child_iterator const&, ::boost::mpl::true_);
+
+ void _push_child(child_iterator const&, ::boost::mpl::false_);
+
+ void _push_children(NodePointer const&, ::boost::mpl::true_);
+
+ void _push_children(NodePointer const&, ::boost::mpl::false_);
+
+ void _pop();
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ friend bool
+#else
+ friend typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator==(
+ breadth_first_iterator<NP1,MCI1> const& lhs
+ , breadth_first_iterator<NP2,MCI2> const& rhs
+ );
+ //->
+ };
+
+ //<-
+ template <typename NP, typename MCI>
+ breadth_first_iterator<NP,MCI>::breadth_first_iterator()
+ : _queue(), _current(), _state(no_traversal)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ breadth_first_iterator<NP,MCI>::breadth_first_iterator(NP const& node)
+ : _queue()
+ , _current()
+ , _state(node ? breadth_first_traversal : no_traversal)
+ {
+ _initialize(node, MCI());
+ }
+
+ template <typename NP1, typename MCI1>
+ template <typename NP2, typename MCI2>
+ breadth_first_iterator<NP1,MCI1>::breadth_first_iterator(
+ breadth_first_iterator<NP2,MCI2> const& other
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ typename ::boost::mpl::if_<
+ ::std::tr1::is_convertible<NP2,NP1>
+ , ::boost::mpl::equal_to<MCI2,MCI1>
+ , ::boost::mpl::false_
+ >::type
+ , enabler
+ >::type
+#endif
+ ) : _queue(other._queue.begin(), other._queue.end())
+ , _current(other._current)
+ , _state(other._state)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ breadth_first_iterator<NP,MCI>::_initialize(
+ NP const& node
+ , ::boost::mpl::true_
+ )
+ {
+ if (node)
+ {
+ _push_children(node, MCI());
+ _pop();
+ }
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ breadth_first_iterator<NP,MCI>::_initialize(
+ NP const& node
+ , ::boost::mpl::false_
+ )
+ {
+ _current = node;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename breadth_first_iterator<NP,MCI>::reference
+ breadth_first_iterator<NP,MCI>::_deref(::boost::mpl::true_) const
+ {
+ return *_current;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename breadth_first_iterator<NP,MCI>::reference
+ breadth_first_iterator<NP,MCI>::_deref(::boost::mpl::false_) const
+ {
+ return _current;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename breadth_first_iterator<NP,MCI>::reference
+ breadth_first_iterator<NP,MCI>::operator*() const
+ {
+ return _deref(MCI());
+ }
+
+ template <typename NP, typename MCI>
+ inline typename breadth_first_iterator<NP,MCI>::pointer
+ breadth_first_iterator<NP,MCI>::_indirect(::boost::mpl::true_) const
+ {
+ return _current;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename breadth_first_iterator<NP,MCI>::pointer
+ breadth_first_iterator<NP,MCI>::_indirect(::boost::mpl::false_) const
+ {
+ return &_current;
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ breadth_first_iterator<NP,MCI>::_deref(
+ child_iterator const& itr
+ , ::boost::mpl::true_
+ )
+ {
+ return itr->second;
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ breadth_first_iterator<NP,MCI>::_deref(
+ child_iterator const& itr
+ , ::boost::mpl::false_
+ )
+ {
+ return *itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ breadth_first_iterator<NP,MCI>::_current_node(
+ ::boost::mpl::true_
+ ) const
+ {
+ return _deref(_current, is_associative());
+ }
+
+ template <typename NP, typename MCI>
+ inline NP const&
+ breadth_first_iterator<NP,MCI>::_current_node(
+ ::boost::mpl::false_
+ ) const
+ {
+ return _current;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename breadth_first_iterator<NP,MCI>::pointer
+ breadth_first_iterator<NP,MCI>::operator->() const
+ {
+ return _indirect(MCI());
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ breadth_first_iterator<NP,MCI>::_push_child(
+ child_iterator const& itr
+ , ::boost::mpl::true_
+ )
+ {
+ _queue.push_back(itr->second);
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ breadth_first_iterator<NP,MCI>::_push_child(
+ child_iterator const& itr
+ , ::boost::mpl::false_
+ )
+ {
+ _queue.push_back(*itr);
+ }
+
+ template <typename NP, typename MCI>
+ void
+ breadth_first_iterator<NP,MCI>::_push_children(
+ NP const& node
+ , ::boost::mpl::true_
+ )
+ {
+ child_iterator itr_end = node->get_child_end();
+
+ for (
+ child_iterator itr = node->get_child_begin();
+ itr != itr_end;
+ ++itr
+ )
+ {
+ _queue.push_back(itr);
+ }
+ }
+
+ template <typename NP, typename MCI>
+ void
+ breadth_first_iterator<NP,MCI>::_push_children(
+ NP const& node
+ , ::boost::mpl::false_
+ )
+ {
+ child_iterator itr_end = node->get_child_end();
+
+ for (
+ child_iterator itr = node->get_child_begin();
+ itr != itr_end;
+ ++itr
+ )
+ {
+ _push_child(itr, is_associative());
+ }
+ }
+
+ template <typename NP, typename MCI>
+ inline void breadth_first_iterator<NP,MCI>::_pop()
+ {
+ if (_queue.empty())
+ {
+ _state = no_traversal;
+ }
+ else
+ {
+ _current = _queue.front();
+ _queue.pop_front();
+ }
+ }
+
+ template <typename NP, typename MCI>
+ inline breadth_first_iterator<NP,MCI>&
+ breadth_first_iterator<NP,MCI>::operator++()
+ {
+ MCI mci;
+ _push_children(_current_node(mci), mci);
+ _pop();
+ return *this;
+ }
+
+ template <typename NP, typename MCI>
+ inline breadth_first_iterator<NP,MCI>
+ breadth_first_iterator<NP,MCI>::operator++(int)
+ {
+ breadth_first_iterator<NP,MCI> itr(*this);
+ ++(*this);
+ return itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline breadth_first_iterator<NP,MCI>::operator traversal_state() const
+ {
+ return _state;
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__breadth_first_iterator__operator_equals
+namespace boost { namespace tree_node {
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+//<-
+#ifdef BOOST_NO_SFINAE
+ bool
+#else
+//->
+ typename ::boost::enable_if< ::boost::mpl::equal_to<MCI1,MCI2>,bool>::type
+//<-
+#endif
+//->
+ operator==(
+ breadth_first_iterator<NP1,MCI1> const& lhs
+ , breadth_first_iterator<NP2,MCI2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ inline bool
+#else
+ inline typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator==(
+ breadth_first_iterator<NP1,MCI1> const& lhs
+ , breadth_first_iterator<NP2,MCI2> const& rhs
+ )
+ {
+ if (lhs._state == rhs._state)
+ {
+ return lhs._state ? (lhs._current == rhs._current) : !rhs._state;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__breadth_first_iterator__operator_not_equal
+namespace boost { namespace tree_node {
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+//<-
+#ifdef BOOST_NO_SFINAE
+ bool
+#else
+//->
+ typename ::boost::enable_if< ::boost::mpl::equal_to<MCI1,MCI2>,bool>::type
+//<-
+#endif
+//->
+ operator!=(
+ breadth_first_iterator<NP1,MCI1> const& lhs
+ , breadth_first_iterator<NP2,MCI2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ inline bool
+#else
+ inline typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator!=(
+ breadth_first_iterator<NP1,MCI1> const& lhs
+ , breadth_first_iterator<NP2,MCI2> const& rhs
+ )
+ {
+ return !(lhs == rhs);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__make_breadth_first_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ breadth_first_iterator<NodePointer,::boost::mpl::false_>
+ make_breadth_first_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline breadth_first_iterator<NodePointer,::boost::mpl::false_>
+ make_breadth_first_iterator(NodePointer const& node)
+ {
+ return breadth_first_iterator<NodePointer,::boost::mpl::false_>(node);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__make_breadth_first_descendant_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ breadth_first_iterator<NodePointer,::boost::mpl::true_>
+ make_breadth_first_descendant_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline breadth_first_iterator<NodePointer,::boost::mpl::true_>
+ make_breadth_first_descendant_iterator(NodePointer const& node)
+ {
+ return breadth_first_iterator<NodePointer,::boost::mpl::true_>(node);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__breadth_first_iterate
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ breadth_first_iterate(NodePointer const& node, UnaryFunction function);
+
+ //<-
+ template <typename NodePointer, typename UnaryFunction>
+ void breadth_first_iterate(NodePointer const& node, UnaryFunction function)
+ {
+ for (
+ breadth_first_iterator<NodePointer,::boost::mpl::false_> itr(node);
+ itr;
+ ++itr
+ )
+ {
+ function(*itr);
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__breadth_first_iterate_descendants
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ breadth_first_iterate_descendants(
+ NodePointer const& node
+ , UnaryFunction function
+ );
+
+ //<-
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ breadth_first_iterate_descendants(
+ NodePointer const& node
+ , UnaryFunction function
+ )
+ {
+ for (
+ breadth_first_iterator<NodePointer,::boost::mpl::true_> itr(node);
+ itr;
+ ++itr
+ )
+ {
+ function(*itr);
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_BREADTH_FIRST_ITERATOR_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/depth_first_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/depth_first_iterator.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,545 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_DEPTH_FIRST_ITERATOR_HPP_INCLUDED
+#define BOOST_TREE_NODE_DEPTH_FIRST_ITERATOR_HPP_INCLUDED
+
+#include <iterator>
+#include <deque>
+#include <boost/config.hpp>
+#include <boost/tr1/type_traits.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/equal_to.hpp>
+#ifndef BOOST_NO_SFINAE
+#include <boost/utility/enable_if.hpp>
+#endif
+#include <boost/fusion/adapted/std_pair.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/detail/metafunction/element_type.hpp>
+#include <boost/tree_node/traversal_state.hpp>
+
+//[reference__depth_first_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename MimicsChildIterator>
+ class depth_first_iterator
+ {
+ //<-
+ typedef typename ::boost::mpl::eval_if<
+ ::std::tr1::is_pointer<NodePointer>
+ , ::std::tr1::remove_pointer<NodePointer>
+ , ::boost::detail::element_type<NodePointer>
+ >::type
+ element_type;
+ typedef typename ::std::tr1::remove_const<element_type>::type
+ node_type;
+ typedef typename ::boost::mpl::if_<
+ ::std::tr1::is_const<element_type>
+ , typename node_type::const_child_iterator
+ , typename node_type::child_iterator
+ >::type
+ child_iterator;
+ typedef typename ::std::iterator_traits<child_iterator>::value_type
+ child_value;
+ typedef typename ::boost::fusion::traits::is_sequence<
+ child_value
+ >::type
+ is_associative;
+ //->
+
+ public:
+ typedef // implementation_defined
+ //<-
+ typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_value
+ , NodePointer
+ >::type
+ //->
+ value_type;
+ typedef value_type const&
+ reference;
+ typedef // implementation_defined
+ //<-
+ typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_iterator
+ , value_type const*
+ >::type
+ //->
+ pointer;
+ typedef ::std::ptrdiff_t
+ difference_type;
+ typedef ::std::forward_iterator_tag
+ iterator_category;
+
+ //<-
+ private:
+#ifndef BOOST_NO_SFINAE
+ struct enabler
+ {
+ };
+#endif
+
+ ::std::deque<NodePointer> _node_stack;
+ ::std::deque<child_iterator> _itr_stack;
+ NodePointer _current_node;
+ child_iterator _current_itr;
+ traversal_state _state;
+
+ public:
+ //->
+ depth_first_iterator();
+
+ explicit depth_first_iterator(NodePointer const& node);
+
+ template <typename NP, typename MCI>
+ depth_first_iterator(
+ depth_first_iterator<NP,MCI> const& other
+//<-
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ typename ::boost::mpl::if_<
+ ::std::tr1::is_convertible<NP,NodePointer>
+ , ::boost::mpl::equal_to<MCI,MimicsChildIterator>
+ , ::boost::mpl::false_
+ >::type
+ , enabler
+ >::type = enabler()
+#endif
+//->
+ );
+
+ reference operator*() const;
+
+ pointer operator->() const;
+
+ depth_first_iterator& operator++();
+
+ depth_first_iterator operator++(int);
+
+ operator traversal_state() const;
+
+ //<-
+ private:
+ static NodePointer
+ _deref(child_iterator const&, ::boost::mpl::true_);
+
+ static NodePointer
+ _deref(child_iterator const&, ::boost::mpl::false_);
+
+ reference _deref(::boost::mpl::true_) const;
+
+ reference _deref(::boost::mpl::false_) const;
+
+ pointer _indirect(::boost::mpl::true_) const;
+
+ pointer _indirect(::boost::mpl::false_) const;
+
+ void _initialize(::boost::mpl::true_);
+
+ void _initialize(::boost::mpl::false_);
+
+ void _set_state(::boost::mpl::true_);
+
+ void _set_state(::boost::mpl::false_);
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ friend bool
+#else
+ friend typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator==(
+ depth_first_iterator<NP1,MCI1> const& lhs
+ , depth_first_iterator<NP2,MCI2> const& rhs
+ );
+ //->
+ };
+
+ //<-
+ template <typename NP, typename MCI>
+ depth_first_iterator<NP,MCI>::depth_first_iterator()
+ : _node_stack()
+ , _itr_stack()
+ , _current_node()
+ , _current_itr()
+ , _state(no_traversal)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ depth_first_iterator<NP,MCI>::depth_first_iterator(NP const& node)
+ : _node_stack()
+ , _itr_stack()
+ , _current_node(node)
+ , _current_itr()
+ , _state(node ? pre_order_traversal : no_traversal)
+ {
+ if (node)
+ {
+ _itr_stack.push_back(node->get_child_begin());
+ _initialize(MCI());
+ }
+ }
+
+ template <typename NP1, typename MCI1>
+ template <typename NP2, typename MCI2>
+ depth_first_iterator<NP1,MCI1>::depth_first_iterator(
+ depth_first_iterator<NP2,MCI2> const& other
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ typename ::boost::mpl::if_<
+ ::std::tr1::is_convertible<NP2,NP1>
+ , ::boost::mpl::equal_to<MCI2,MCI1>
+ , ::boost::mpl::false_
+ >::type
+ , enabler
+ >::type
+#endif
+ ) : _node_stack(other._node_stack.begin(), other._node_stack.end())
+ , _itr_stack(other._itr_stack.begin(), other._itr_stack.end())
+ , _current_node(other._current_node)
+ , _current_itr(other._current_itr)
+ , _state(other._state)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ depth_first_iterator<NP,MCI>::_initialize(::boost::mpl::true_)
+ {
+ ++(*this);
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ depth_first_iterator<NP,MCI>::_initialize(::boost::mpl::false_)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ inline typename depth_first_iterator<NP,MCI>::reference
+ depth_first_iterator<NP,MCI>::_deref(::boost::mpl::true_) const
+ {
+ return *_current_itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename depth_first_iterator<NP,MCI>::reference
+ depth_first_iterator<NP,MCI>::_deref(::boost::mpl::false_) const
+ {
+ return _current_node;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename depth_first_iterator<NP,MCI>::reference
+ depth_first_iterator<NP,MCI>::operator*() const
+ {
+ return _deref(MCI());
+ }
+
+ template <typename NP, typename MCI>
+ inline typename depth_first_iterator<NP,MCI>::pointer
+ depth_first_iterator<NP,MCI>::_indirect(::boost::mpl::true_) const
+ {
+ return _current_itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename depth_first_iterator<NP,MCI>::pointer
+ depth_first_iterator<NP,MCI>::_indirect(::boost::mpl::false_) const
+ {
+ return &_current_node;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename depth_first_iterator<NP,MCI>::pointer
+ depth_first_iterator<NP,MCI>::operator->() const
+ {
+ return _indirect(MCI());
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ depth_first_iterator<NP,MCI>::_deref(
+ child_iterator const& itr
+ , ::boost::mpl::true_
+ )
+ {
+ return itr->second;
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ depth_first_iterator<NP,MCI>::_deref(
+ child_iterator const& itr
+ , ::boost::mpl::false_
+ )
+ {
+ return *itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline void depth_first_iterator<NP,MCI>::_set_state(::boost::mpl::true_)
+ {
+ _state = _node_stack.empty() ? no_traversal : post_order_traversal;
+ }
+
+ template <typename NP, typename MCI>
+ inline void depth_first_iterator<NP,MCI>::_set_state(::boost::mpl::false_)
+ {
+ _state = post_order_traversal;
+ }
+
+ template <typename NP, typename MCI>
+ depth_first_iterator<NP,MCI>&
+ depth_first_iterator<NP,MCI>::operator++()
+ {
+ if (_state == post_order_traversal)
+ {
+ _itr_stack.pop_back();
+
+ if (_node_stack.empty())
+ {
+ _state = no_traversal;
+
+ while (!_itr_stack.empty())
+ {
+ _itr_stack.pop_back();
+ }
+ }
+ else
+ {
+ _current_node = _node_stack.back();
+ _node_stack.pop_back();
+
+ if (++_current_itr == _current_node->get_child_end())
+ {
+ _set_state(MCI());
+
+ if (_state)
+ {
+ child_iterator itr = _itr_stack.back();
+
+ _itr_stack.pop_back();
+
+ if (!_itr_stack.empty())
+ {
+ _current_itr = _itr_stack.back();
+ }
+
+ _itr_stack.push_back(itr);
+ }
+ else
+ {
+ while (!_itr_stack.empty())
+ {
+ _itr_stack.pop_back();
+ }
+ }
+ }
+ else
+ {
+ _itr_stack.pop_back();
+ _node_stack.push_back(_current_node);
+ _itr_stack.push_back(_current_itr);
+ _current_node = _deref(_current_itr, is_associative());
+ _state = pre_order_traversal;
+ _itr_stack.push_back(_current_node->get_child_begin());
+ }
+ }
+ }
+ else
+ {
+ child_iterator& itr = _itr_stack.back();
+
+ if (itr == _current_node->get_child_end())
+ {
+ _set_state(MCI());
+ }
+ else
+ {
+ _node_stack.push_back(_current_node);
+ _current_itr = itr;
+ _current_node = _deref(itr, is_associative());
+ _state = pre_order_traversal;
+ _itr_stack.push_back(_current_node->get_child_begin());
+ }
+ }
+
+ return *this;
+ }
+
+ template <typename NP, typename MCI>
+ inline depth_first_iterator<NP,MCI>
+ depth_first_iterator<NP,MCI>::operator++(int)
+ {
+ depth_first_iterator<NP,MCI> itr(*this);
+ ++(*this);
+ return itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline depth_first_iterator<NP,MCI>::operator traversal_state() const
+ {
+ return _state;
+ }
+ //->
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+//<-
+#ifdef BOOST_NO_SFINAE
+ bool
+#else
+//->
+ typename ::boost::enable_if< ::boost::mpl::equal_to<MCI1,MCI2>,bool>::type
+//<-
+#endif
+//->
+ operator==(
+ depth_first_iterator<NP1,MCI1> const& lhs
+ , depth_first_iterator<NP2,MCI2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ inline bool
+#else
+ inline typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator==(
+ depth_first_iterator<NP1,MCI1> const& lhs
+ , depth_first_iterator<NP2,MCI2> const& rhs
+ )
+ {
+ if (lhs._state == rhs._state)
+ {
+ return lhs._state ? (*lhs == *rhs) : !rhs._state;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ //->
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+//<-
+#ifdef BOOST_NO_SFINAE
+ bool
+#else
+//->
+ typename ::boost::enable_if< ::boost::mpl::equal_to<MCI1,MCI2>,bool>::type
+//<-
+#endif
+//->
+ operator!=(
+ depth_first_iterator<NP1,MCI1> const& lhs
+ , depth_first_iterator<NP2,MCI2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ inline bool
+#else
+ inline typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator!=(
+ depth_first_iterator<NP1,MCI1> const& lhs
+ , depth_first_iterator<NP2,MCI2> const& rhs
+ )
+ {
+ return !(lhs == rhs);
+ }
+ //->
+
+ template <typename NodePointer>
+ depth_first_iterator<NodePointer,::boost::mpl::false_>
+ make_depth_first_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline depth_first_iterator<NodePointer,::boost::mpl::false_>
+ make_depth_first_iterator(NodePointer const& node)
+ {
+ return depth_first_iterator<NodePointer,::boost::mpl::false_>(node);
+ }
+ //->
+
+ template <typename NodePointer>
+ depth_first_iterator<NodePointer,::boost::mpl::true_>
+ make_depth_first_descendant_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline depth_first_iterator<NodePointer,::boost::mpl::true_>
+ make_depth_first_descendant_iterator(NodePointer const& node)
+ {
+ return depth_first_iterator<NodePointer,::boost::mpl::true_>(node);
+ }
+ //->
+
+ template <typename NodePointer, typename BinaryFunction>
+ void depth_first_iterate(NodePointer const& node, BinaryFunction function);
+
+ //<-
+ template <typename NodePointer, typename BinaryFunction>
+ void depth_first_iterate(NodePointer const& node, BinaryFunction function)
+ {
+ for (
+ depth_first_iterator<NodePointer,::boost::mpl::false_> itr(node);
+ itr;
+ ++itr
+ )
+ {
+ function(*itr, traversal_state(itr));
+ }
+ }
+ //->
+
+ template <typename NodePointer, typename BinaryFunction>
+ void
+ depth_first_iterate_descendants(
+ NodePointer const& node
+ , BinaryFunction function
+ );
+
+ //<-
+ template <typename NodePointer, typename BinaryFunction>
+ void
+ depth_first_iterate_descendants(
+ NodePointer const& node
+ , BinaryFunction function
+ )
+ {
+ for (
+ depth_first_iterator<NodePointer,::boost::mpl::true_> itr(node);
+ itr;
+ ++itr
+ )
+ {
+ function(*itr, traversal_state(itr));
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_DEPTH_FIRST_ITERATOR_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/in_order_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/in_order_iterator.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,395 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_IN_ORDER_ITERATOR_HPP_INCLUDED
+#define BOOST_TREE_IN_ORDER_ITERATOR_HPP_INCLUDED
+
+#include <iterator>
+#include <boost/config.hpp>
+#ifndef BOOST_NO_SFINAE
+#include <boost/tr1/type_traits.hpp>
+#include <boost/utility/enable_if.hpp>
+#endif
+#include <boost/tree_node/traversal_state.hpp>
+
+//[reference__in_order_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ class in_order_iterator
+ {
+ public:
+ typedef NodePointer value_type;
+ typedef value_type const& reference;
+ typedef value_type const* pointer;
+ typedef ::std::ptrdiff_t difference_type;
+ typedef ::std::bidirectional_iterator_tag iterator_category;
+
+ //<-
+ private:
+#ifndef BOOST_NO_SFINAE
+ struct enabler
+ {
+ };
+#endif
+
+ value_type _current;
+ value_type _root_parent;
+ traversal_state _state;
+
+ public:
+ //->
+ in_order_iterator();
+
+ in_order_iterator(NodePointer const& node, bool start_left = true);
+
+ template <typename NP>
+ in_order_iterator(
+ in_order_iterator<NP> const& other
+//<-
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ ::std::tr1::is_convertible<NP,NodePointer>
+ , enabler
+ >::type = enabler()
+#endif
+//->
+ );
+
+ reference operator*() const;
+
+ pointer operator->() const;
+
+ in_order_iterator& operator++();
+
+ in_order_iterator operator++(int);
+
+ in_order_iterator& operator--();
+
+ in_order_iterator operator--(int);
+
+ operator traversal_state() const;
+
+ //<-
+ private:
+ template <typename NP1, typename NP2>
+ friend bool
+ operator==(
+ in_order_iterator<NP1> const& lhs
+ , in_order_iterator<NP2> const& rhs
+ );
+ //->
+ };
+
+ //<-
+ template <typename NP>
+ in_order_iterator<NP>::in_order_iterator()
+ : _current(), _root_parent(), _state(no_traversal)
+ {
+ }
+
+ template <typename NP>
+ in_order_iterator<NP>::in_order_iterator(NP const& node, bool start_left)
+ : _current(node)
+ , _root_parent(node ? node->get_parent() : 0)
+ , _state(node ? in_order_traversal : no_traversal)
+ {
+ if (node)
+ {
+ if (start_left)
+ {
+ while (_current->get_left_child())
+ {
+ _current = _current->get_left_child();
+ }
+ }
+ else
+ {
+ while (_current->get_right_child())
+ {
+ _current = _current->get_right_child();
+ }
+ }
+ }
+ }
+
+ template <typename NP1>
+ template <typename NP2>
+ in_order_iterator<NP1>::in_order_iterator(
+ in_order_iterator<NP2> const& other
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ ::std::tr1::is_convertible<NP2,NP1>
+ , enabler
+ >::type
+#endif
+ ) : _current(other._current)
+ , _root_parent(other._root_parent)
+ , _state(other._state)
+ {
+ }
+
+ template <typename NP>
+ inline typename in_order_iterator<NP>::reference
+ in_order_iterator<NP>::operator*() const
+ {
+ return _current;
+ }
+
+ template <typename NP>
+ inline typename in_order_iterator<NP>::pointer
+ in_order_iterator<NP>::operator->() const
+ {
+ return &_current;
+ }
+
+ template <typename NP>
+ in_order_iterator<NP>& in_order_iterator<NP>::operator++()
+ {
+ value_type node = _current->get_right_child();
+
+ if (node)
+ {
+ while (node->get_left_child())
+ {
+ node = node->get_left_child();
+ }
+
+ _current = node;
+ return *this;
+ }
+
+ node = _current;
+
+ for (
+ value_type next = node->get_parent();
+ next != _root_parent;
+ next = next->get_parent()
+ )
+ {
+ if (node == next->get_left_child())
+ {
+ _current = next;
+ return *this;
+ }
+
+ node = next;
+ }
+
+ _current = _root_parent = 0;
+ _state = no_traversal;
+ return *this;
+ }
+
+ template <typename NP>
+ inline in_order_iterator<NP> in_order_iterator<NP>::operator++(int)
+ {
+ in_order_iterator<NP> itr(*this);
+ ++(*this);
+ return itr;
+ }
+
+ template <typename NP>
+ inline in_order_iterator<NP>& in_order_iterator<NP>::operator--()
+ {
+ value_type node = _current->get_left_child();
+
+ if (node)
+ {
+ while (node->get_right_child())
+ {
+ node = node->get_right_child();
+ }
+
+ _current = node;
+ return *this;
+ }
+
+ node = _current;
+
+ for (
+ value_type next = node->get_parent();
+ next != _root_parent;
+ next = next->get_parent()
+ )
+ {
+ if (node == next->get_right_child())
+ {
+ _current = next;
+ return *this;
+ }
+
+ node = next;
+ }
+
+ _current = _root_parent = 0;
+ _state = no_traversal;
+ return *this;
+ }
+
+ template <typename NP>
+ inline in_order_iterator<NP> in_order_iterator<NP>::operator--(int)
+ {
+ in_order_iterator<NP> itr(*this);
+ --(*this);
+ return itr;
+ }
+
+ template <typename NP>
+ inline in_order_iterator<NP>::operator traversal_state() const
+ {
+ return _state;
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__in_order_iterator__operator_equals
+namespace boost { namespace tree_node {
+
+ template <typename NP1, typename NP2>
+ bool
+ operator==(
+ in_order_iterator<NP1> const& lhs
+ , in_order_iterator<NP2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2>
+ inline bool
+ operator==(
+ in_order_iterator<NP1> const& lhs
+ , in_order_iterator<NP2> const& rhs
+ )
+ {
+ if (lhs._state == rhs._state)
+ {
+ return lhs._state ? (lhs._current == rhs._current) : !rhs._state;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__in_order_iterator__operator_not_equal
+namespace boost { namespace tree_node {
+
+ template <typename NP1, typename NP2>
+ bool
+ operator!=(
+ in_order_iterator<NP1> const& lhs
+ , in_order_iterator<NP2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2>
+ inline bool
+ operator!=(
+ in_order_iterator<NP1> const& lhs
+ , in_order_iterator<NP2> const& rhs
+ )
+ {
+ return !(lhs == rhs);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__make_in_order_forward_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ in_order_iterator<NodePointer>
+ make_in_order_forward_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline in_order_iterator<NodePointer>
+ make_in_order_forward_iterator(NodePointer const& node)
+ {
+ return in_order_iterator<NodePointer>(node, true);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__make_in_order_reverse_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ in_order_iterator<NodePointer>
+ make_in_order_reverse_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline in_order_iterator<NodePointer>
+ make_in_order_reverse_iterator(NodePointer const& node)
+ {
+ return in_order_iterator<NodePointer>(node, false);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__in_order_iterate_forward
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ in_order_iterate_forward(
+ NodePointer const& node
+ , UnaryFunction function
+ );
+
+ //<-
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ in_order_iterate_forward(
+ NodePointer const& node
+ , UnaryFunction function
+ )
+ {
+ for (in_order_iterator<NodePointer> itr(node, true); itr; ++itr)
+ {
+ function(*itr);
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__in_order_iterate_reverse
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ in_order_iterate_reverse(
+ NodePointer const& node
+ , UnaryFunction function
+ );
+
+ //<-
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ in_order_iterate_reverse(
+ NodePointer const& node
+ , UnaryFunction function
+ )
+ {
+ for (in_order_iterator<NodePointer> itr(node, false); itr; --itr)
+ {
+ function(*itr);
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_IN_ORDER_ITERATOR_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/post_order_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/post_order_iterator.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,616 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_POST_ORDER_ITERATOR_HPP_INCLUDED
+#define BOOST_TREE_NODE_POST_ORDER_ITERATOR_HPP_INCLUDED
+
+#include <iterator>
+#include <deque>
+#include <boost/config.hpp>
+#include <boost/tr1/type_traits.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/equal_to.hpp>
+#ifndef BOOST_NO_SFINAE
+#include <boost/utility/enable_if.hpp>
+#endif
+#include <boost/fusion/adapted/std_pair.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/detail/metafunction/element_type.hpp>
+#include <boost/tree_node/traversal_state.hpp>
+
+//[reference__post_order_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename MimicsChildIterator>
+ class post_order_iterator
+ {
+ //<-
+ typedef typename ::boost::mpl::eval_if<
+ ::std::tr1::is_pointer<NodePointer>
+ , ::std::tr1::remove_pointer<NodePointer>
+ , ::boost::detail::element_type<NodePointer>
+ >::type
+ element_type;
+ typedef typename ::std::tr1::remove_const<element_type>::type
+ node_type;
+ typedef typename ::boost::mpl::if_<
+ ::std::tr1::is_const<element_type>
+ , typename node_type::const_child_iterator
+ , typename node_type::child_iterator
+ >::type
+ child_iterator;
+ typedef typename ::std::iterator_traits<child_iterator>::value_type
+ child_value;
+ typedef typename ::boost::fusion::traits::is_sequence<
+ child_value
+ >::type
+ is_associative;
+ typedef typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_iterator
+ , NodePointer
+ >::type
+ stack_element;
+ //->
+
+ public:
+ typedef // implementation_defined
+ //<-
+ typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_value
+ , NodePointer
+ >::type
+ //->
+ value_type;
+ typedef value_type const&
+ reference;
+ typedef // implementation_defined
+ //<-
+ typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_iterator
+ , value_type const*
+ >::type
+ //->
+ pointer;
+ typedef ::std::ptrdiff_t
+ difference_type;
+ typedef ::std::forward_iterator_tag
+ iterator_category;
+
+ //<-
+ private:
+ struct enabler
+ {
+ };
+
+ std::deque<stack_element> _stack;
+ stack_element _current;
+ traversal_state _state;
+
+ public:
+ //->
+ post_order_iterator();
+
+ explicit post_order_iterator(NodePointer const& node);
+
+ template <typename NP, typename MCI>
+ post_order_iterator(
+ post_order_iterator<NP,MCI> const& other
+//<-
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ typename ::boost::mpl::if_<
+ ::std::tr1::is_convertible<NP,NodePointer>
+ , ::boost::mpl::equal_to<MCI,MimicsChildIterator>
+ , ::boost::mpl::false_
+ >::type
+ , enabler
+ >::type = enabler()
+#endif
+//->
+ );
+
+ reference operator*() const;
+
+ pointer operator->() const;
+
+ post_order_iterator& operator++();
+
+ post_order_iterator operator++(int);
+
+ operator traversal_state() const;
+
+ //<-
+ private:
+ static NodePointer
+ _deref(child_iterator const&, ::boost::mpl::true_);
+
+ static NodePointer
+ _deref(child_iterator const&, ::boost::mpl::false_);
+
+ reference _deref(::boost::mpl::true_) const;
+
+ reference _deref(::boost::mpl::false_) const;
+
+ pointer _indirect(::boost::mpl::true_) const;
+
+ pointer _indirect(::boost::mpl::false_) const;
+
+ NodePointer _current_node(::boost::mpl::true_) const;
+
+ NodePointer const& _current_node(::boost::mpl::false_) const;
+
+ void _push_child(child_iterator const&, ::boost::mpl::true_);
+
+ void _push_child(child_iterator const&, ::boost::mpl::false_);
+
+ void _push_child_itr(child_iterator const&, ::boost::mpl::true_);
+
+ void _push_child_itr(child_iterator const&, ::boost::mpl::false_);
+
+ void _start(NodePointer const&);
+
+ void _initialize(NodePointer const&, ::boost::mpl::true_);
+
+ void _initialize(NodePointer const&, ::boost::mpl::false_);
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ friend bool
+#else
+ friend typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator==(
+ post_order_iterator<NP1,MCI1> const& lhs
+ , post_order_iterator<NP2,MCI2> const& rhs
+ );
+ //->
+ };
+
+ //<-
+ template <typename NP, typename MCI>
+ post_order_iterator<NP,MCI>::post_order_iterator()
+ : _stack(), _current(), _state(no_traversal)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ post_order_iterator<NP,MCI>::post_order_iterator(NP const& node)
+ : _stack()
+ , _current()
+ , _state(node ? post_order_traversal : no_traversal)
+ {
+ if (node)
+ {
+ _initialize(node, MCI());
+ }
+ }
+
+ template <typename NP1, typename MCI1>
+ template <typename NP2, typename MCI2>
+ post_order_iterator<NP1,MCI1>::post_order_iterator(
+ post_order_iterator<NP2,MCI2> const& other
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ typename ::boost::mpl::if_<
+ ::std::tr1::is_convertible<NP2,NP1>
+ , ::boost::mpl::equal_to<MCI2,MCI1>
+ , ::boost::mpl::false_
+ >::type
+ , enabler
+ >::type
+#endif
+ ) : _stack(other._stack.begin(), other._stack.end())
+ , _current(other._current)
+ , _state(other._state)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ inline typename post_order_iterator<NP,MCI>::reference
+ post_order_iterator<NP,MCI>::_deref(::boost::mpl::true_) const
+ {
+ return *_current;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename post_order_iterator<NP,MCI>::reference
+ post_order_iterator<NP,MCI>::_deref(::boost::mpl::false_) const
+ {
+ return _current;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename post_order_iterator<NP,MCI>::reference
+ post_order_iterator<NP,MCI>::operator*() const
+ {
+ return _deref(MCI());
+ }
+
+ template <typename NP, typename MCI>
+ inline typename post_order_iterator<NP,MCI>::pointer
+ post_order_iterator<NP,MCI>::_indirect(::boost::mpl::true_) const
+ {
+ return _current;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename post_order_iterator<NP,MCI>::pointer
+ post_order_iterator<NP,MCI>::_indirect(::boost::mpl::false_) const
+ {
+ return &_current;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename post_order_iterator<NP,MCI>::pointer
+ post_order_iterator<NP,MCI>::operator->() const
+ {
+ return _indirect(MCI());
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ post_order_iterator<NP,MCI>::_deref(
+ child_iterator const& itr
+ , ::boost::mpl::true_
+ )
+ {
+ return itr->second;
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ post_order_iterator<NP,MCI>::_deref(
+ child_iterator const& itr
+ , ::boost::mpl::false_
+ )
+ {
+ return *itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ post_order_iterator<NP,MCI>::_current_node(::boost::mpl::true_) const
+ {
+ return _deref(_current, is_associative());
+ }
+
+ template <typename NP, typename MCI>
+ inline NP const&
+ post_order_iterator<NP,MCI>::_current_node(::boost::mpl::false_) const
+ {
+ return _current;
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ post_order_iterator<NP,MCI>::_push_child(
+ child_iterator const& itr
+ , ::boost::mpl::true_
+ )
+ {
+ _stack.push_back(itr->second);
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ post_order_iterator<NP,MCI>::_push_child(
+ child_iterator const& itr
+ , ::boost::mpl::false_
+ )
+ {
+ _stack.push_back(*itr);
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ post_order_iterator<NP,MCI>::_push_child_itr(
+ child_iterator const& itr
+ , ::boost::mpl::true_
+ )
+ {
+ _stack.push_back(itr);
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ post_order_iterator<NP,MCI>::_push_child_itr(
+ child_iterator const& itr
+ , boost::mpl::false_
+ )
+ {
+ _push_child(itr, is_associative());
+ }
+
+ template <typename NP, typename MCI>
+ void post_order_iterator<NP,MCI>::_start(NP const& n)
+ {
+ child_iterator itr = n->get_child_begin();
+ child_iterator itr_end = n->get_child_end();
+
+ if (itr != itr_end)
+ {
+ NP node(n);
+ ::std::deque<child_iterator> pre_order_stack;
+
+ for (;;)
+ {
+ while (itr != itr_end)
+ {
+ pre_order_stack.push_back(itr);
+ ++itr;
+ }
+
+ _push_child_itr(pre_order_stack.back(), MCI());
+ node = _deref(pre_order_stack.back(), is_associative());
+ pre_order_stack.pop_back();
+
+ if (pre_order_stack.empty())
+ {
+ _current = _stack.back();
+ node = _current_node(MCI());
+ itr = node->get_child_begin();
+ itr_end = node->get_child_end();
+
+ if (itr == itr_end)
+ {
+ _stack.pop_back();
+ break;
+ }
+ }
+ else
+ {
+ itr = node->get_child_begin();
+ itr_end = node->get_child_end();
+ }
+ }
+ }
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ post_order_iterator<NP,MCI>::_initialize(
+ NP const& node
+ , ::boost::mpl::true_
+ )
+ {
+ _start(node);
+
+ if (_stack.empty())
+ {
+ _state = no_traversal;
+ }
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ post_order_iterator<NP,MCI>::_initialize(
+ NP const& node
+ , ::boost::mpl::false_
+ )
+ {
+ _stack.push_back(_current = node);
+ _start(node);
+ }
+
+ template <typename NP, typename MCI>
+ inline post_order_iterator<NP,MCI>&
+ post_order_iterator<NP,MCI>::operator++()
+ {
+ if (_stack.empty())
+ {
+ _state = no_traversal;
+ }
+ else
+ {
+ _current = _stack.back();
+ _stack.pop_back();
+ }
+
+ return *this;
+ }
+
+ template <typename NP, typename MCI>
+ inline post_order_iterator<NP,MCI>
+ post_order_iterator<NP,MCI>::operator++(int)
+ {
+ post_order_iterator<NP,MCI> itr(*this);
+ ++(*this);
+ return itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline post_order_iterator<NP,MCI>::operator traversal_state() const
+ {
+ return _state;
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__post_order_iterator__operator_equals
+namespace boost { namespace tree_node {
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+//<-
+#ifdef BOOST_NO_SFINAE
+ bool
+#else
+//->
+ typename ::boost::enable_if< ::boost::mpl::equal_to<MCI1,MCI2>,bool>::type
+//<-
+#endif
+//->
+ operator==(
+ post_order_iterator<NP1,MCI1> const& lhs
+ , post_order_iterator<NP2,MCI2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ inline bool
+#else
+ inline typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator==(
+ post_order_iterator<NP1,MCI1> const& lhs
+ , post_order_iterator<NP2,MCI2> const& rhs
+ )
+ {
+ if (lhs._state == rhs._state)
+ {
+ return lhs._state ? (lhs._current == rhs._current) : !rhs._state;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__post_order_iterator__operator_not_equal
+namespace boost { namespace tree_node {
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+//<-
+#ifdef BOOST_NO_SFINAE
+ bool
+#else
+//->
+ typename ::boost::enable_if< ::boost::mpl::equal_to<MCI1,MCI2>,bool>::type
+//<-
+#endif
+//->
+ operator!=(
+ post_order_iterator<NP1,MCI1> const& lhs
+ , post_order_iterator<NP2,MCI2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ inline bool
+#else
+ inline typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator!=(
+ post_order_iterator<NP1,MCI1> const& lhs
+ , post_order_iterator<NP2,MCI2> const& rhs
+ )
+ {
+ return !(lhs == rhs);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__make_post_order_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ post_order_iterator<NodePointer,::boost::mpl::false_>
+ make_post_order_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline post_order_iterator<NodePointer,::boost::mpl::false_>
+ make_post_order_iterator(NodePointer const& node)
+ {
+ return post_order_iterator<NodePointer,::boost::mpl::false_>(node);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__make_post_order_descendant_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ post_order_iterator<NodePointer,::boost::mpl::true_>
+ make_post_order_descendant_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline post_order_iterator<NodePointer,::boost::mpl::true_>
+ make_post_order_descendant_iterator(NodePointer const& node)
+ {
+ return post_order_iterator<NodePointer,::boost::mpl::true_>(node);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__post_order_iterate
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename UnaryFunction>
+ void post_order_iterate(NodePointer const& node, UnaryFunction function);
+
+ //<-
+ template <typename NodePointer, typename UnaryFunction>
+ void post_order_iterate(NodePointer const& node, UnaryFunction function)
+ {
+ for (
+ post_order_iterator<NodePointer,::boost::mpl::false_> itr(node);
+ itr;
+ ++itr
+ )
+ {
+ function(*itr);
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__post_order_iterate_descendants
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ post_order_iterate_descendants(
+ NodePointer const& node
+ , UnaryFunction function
+ );
+
+ //<-
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ post_order_iterate_descendants(
+ NodePointer const& node
+ , UnaryFunction function
+ )
+ {
+ for (
+ post_order_iterator<NodePointer,::boost::mpl::true_> itr(node);
+ itr;
+ ++itr
+ )
+ {
+ function(*itr);
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_POST_ORDER_ITERATOR_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/pre_order_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/pre_order_iterator.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,547 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_PRE_ORDER_ITERATOR_HPP_INCLUDED
+#define BOOST_TREE_NODE_PRE_ORDER_ITERATOR_HPP_INCLUDED
+
+#include <iterator>
+#include <deque>
+#include <boost/config.hpp>
+#include <boost/tr1/type_traits.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#ifndef BOOST_NO_SFINAE
+#include <boost/utility/enable_if.hpp>
+#endif
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/adapted/std_pair.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/detail/metafunction/element_type.hpp>
+#include <boost/tree_node/traversal_state.hpp>
+
+//[reference__pre_order_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename MimicsChildIterator>
+ class pre_order_iterator
+ {
+ //<-
+ typedef typename ::boost::mpl::eval_if<
+ ::std::tr1::is_pointer<NodePointer>
+ , ::std::tr1::remove_pointer<NodePointer>
+ , ::boost::detail::element_type<NodePointer>
+ >::type
+ element_type;
+ typedef typename ::std::tr1::remove_const<element_type>::type
+ node_type;
+ typedef typename ::boost::mpl::if_<
+ ::std::tr1::is_const<element_type>
+ , typename node_type::const_child_iterator
+ , typename node_type::child_iterator
+ >::type
+ child_iterator;
+ typedef typename ::std::iterator_traits<child_iterator>::value_type
+ child_value;
+ typedef typename ::boost::fusion::traits::is_sequence<
+ child_value
+ >::type
+ is_associative;
+ //->
+
+ public:
+ typedef // implementation_defined
+ //<-
+ typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_value
+ , NodePointer
+ >::type
+ //->
+ value_type;
+ typedef value_type const&
+ reference;
+ typedef // implementation_defined
+ //<-
+ typename ::boost::mpl::if_<
+ MimicsChildIterator
+ , child_iterator
+ , value_type const*
+ >::type
+ //->
+ pointer;
+ typedef ::std::ptrdiff_t
+ difference_type;
+ typedef ::std::forward_iterator_tag
+ iterator_category;
+
+ //<-
+ private:
+#ifndef BOOST_NO_SFINAE
+ struct enabler
+ {
+ };
+#endif
+
+ ::std::deque<NodePointer> _node_stack;
+ ::std::deque<child_iterator> _itr_stack;
+ NodePointer _current_node;
+ child_iterator _current_itr;
+ traversal_state _state;
+
+ public:
+ //->
+ pre_order_iterator();
+
+ explicit pre_order_iterator(NodePointer const& node);
+
+ template <typename NP, typename MCI>
+ pre_order_iterator(
+ pre_order_iterator<NP,MCI> const& other
+//<-
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ typename ::boost::mpl::if_<
+ ::std::tr1::is_convertible<NP,NodePointer>
+ , ::boost::mpl::equal_to<MCI,MimicsChildIterator>
+ , ::boost::mpl::false_
+ >::type
+ , enabler
+ >::type = enabler()
+#endif
+//->
+ );
+
+ reference operator*() const;
+
+ pointer operator->() const;
+
+ pre_order_iterator& operator++();
+
+ pre_order_iterator operator++(int);
+
+ operator traversal_state() const;
+
+ //<-
+ private:
+ static NodePointer
+ _deref(child_iterator const&, ::boost::mpl::true_);
+
+ static NodePointer
+ _deref(child_iterator const&, ::boost::mpl::false_);
+
+ reference _deref(::boost::mpl::true_) const;
+
+ reference _deref(::boost::mpl::false_) const;
+
+ pointer _indirect(::boost::mpl::true_) const;
+
+ pointer _indirect(::boost::mpl::false_) const;
+
+ void _initialize(::boost::mpl::true_);
+
+ void _initialize(::boost::mpl::false_);
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ friend bool
+#else
+ friend typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator==(
+ pre_order_iterator<NP1,MCI1> const& lhs
+ , pre_order_iterator<NP2,MCI2> const& rhs
+ );
+ //->
+ };
+
+ //<-
+ template <typename NP, typename MCI>
+ pre_order_iterator<NP,MCI>::pre_order_iterator()
+ : _node_stack()
+ , _itr_stack()
+ , _current_node()
+ , _current_itr()
+ , _state(no_traversal)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ pre_order_iterator<NP,MCI>::pre_order_iterator(NP const& node)
+ : _node_stack()
+ , _itr_stack()
+ , _current_node(node)
+ , _current_itr()
+ , _state(node ? pre_order_traversal : no_traversal)
+ {
+ if (node)
+ {
+ _itr_stack.push_back(node->get_child_begin());
+ _initialize(MCI());
+ }
+ }
+
+ template <typename NP1, typename MCI1>
+ template <typename NP2, typename MCI2>
+ pre_order_iterator<NP1,MCI1>::pre_order_iterator(
+ pre_order_iterator<NP2,MCI2> const& other
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ typename ::boost::mpl::if_<
+ ::std::tr1::is_convertible<NP2,NP1>
+ , ::boost::mpl::equal_to<MCI2,MCI1>
+ , ::boost::mpl::false_
+ >::type
+ , enabler
+ >::type
+#endif
+ ) : _node_stack(other._node_stack.begin(), other._node_stack.end())
+ , _itr_stack(other._itr_stack.begin(), other._itr_stack.end())
+ , _current_node(other._current_node)
+ , _current_itr(other._current_itr)
+ , _state(other._state)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ pre_order_iterator<NP,MCI>::_initialize(::boost::mpl::true_)
+ {
+ ++(*this);
+ }
+
+ template <typename NP, typename MCI>
+ inline void
+ pre_order_iterator<NP,MCI>::_initialize(::boost::mpl::false_)
+ {
+ }
+
+ template <typename NP, typename MCI>
+ inline typename pre_order_iterator<NP,MCI>::reference
+ pre_order_iterator<NP,MCI>::_deref(::boost::mpl::true_) const
+ {
+ return *_current_itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename pre_order_iterator<NP,MCI>::reference
+ pre_order_iterator<NP,MCI>::_deref(::boost::mpl::false_) const
+ {
+ return _current_node;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename pre_order_iterator<NP,MCI>::reference
+ pre_order_iterator<NP,MCI>::operator*() const
+ {
+ return _deref(MCI());
+ }
+
+ template <typename NP, typename MCI>
+ inline typename pre_order_iterator<NP,MCI>::pointer
+ pre_order_iterator<NP,MCI>::_indirect(::boost::mpl::true_) const
+ {
+ return _current_itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename pre_order_iterator<NP,MCI>::pointer
+ pre_order_iterator<NP,MCI>::_indirect(::boost::mpl::false_) const
+ {
+ return &_current_node;
+ }
+
+ template <typename NP, typename MCI>
+ inline typename pre_order_iterator<NP,MCI>::pointer
+ pre_order_iterator<NP,MCI>::operator->() const
+ {
+ return _indirect(MCI());
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ pre_order_iterator<NP,MCI>::_deref(
+ child_iterator const& itr
+ , ::boost::mpl::true_
+ )
+ {
+ return itr->second;
+ }
+
+ template <typename NP, typename MCI>
+ inline NP
+ pre_order_iterator<NP,MCI>::_deref(
+ child_iterator const& itr
+ , ::boost::mpl::false_
+ )
+ {
+ return *itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline pre_order_iterator<NP,MCI>& pre_order_iterator<NP,MCI>::operator++()
+ {
+ if (_itr_stack.back() == _current_node->get_child_end())
+ {
+ bool is_post_order = true;
+
+ while (is_post_order)
+ {
+ _itr_stack.pop_back();
+
+ if (_node_stack.empty())
+ {
+ _state = no_traversal;
+
+ while (!_itr_stack.empty())
+ {
+ _itr_stack.pop_back();
+ }
+
+ is_post_order = false;
+ }
+ else
+ {
+ _current_node = _node_stack.back();
+ _node_stack.pop_back();
+
+ if (++_current_itr == _current_node->get_child_end())
+ {
+ child_iterator itr = _itr_stack.back();
+
+ _itr_stack.pop_back();
+
+ if (!_itr_stack.empty())
+ {
+ _current_itr = _itr_stack.back();
+ }
+
+ _itr_stack.push_back(itr);
+ }
+ else
+ {
+ _itr_stack.pop_back();
+ _node_stack.push_back(_current_node);
+ _itr_stack.push_back(_current_itr);
+ _current_node = _deref(_current_itr, is_associative());
+ _itr_stack.push_back(
+ _current_node->get_child_begin()
+ );
+ is_post_order = false;
+ }
+ }
+ }
+ }
+ else
+ {
+ _node_stack.push_back(_current_node);
+ _current_node = _deref(
+ _current_itr = _itr_stack.back()
+ , is_associative()
+ );
+ _itr_stack.push_back(_current_node->get_child_begin());
+ }
+
+ return *this;
+ }
+
+ template <typename NP, typename MCI>
+ inline pre_order_iterator<NP,MCI>
+ pre_order_iterator<NP,MCI>::operator++(int)
+ {
+ pre_order_iterator<NP,MCI> itr(*this);
+ ++(*this);
+ return itr;
+ }
+
+ template <typename NP, typename MCI>
+ inline pre_order_iterator<NP,MCI>::operator traversal_state() const
+ {
+ return _state;
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__pre_order_iterator__operator_equals
+namespace boost { namespace tree_node {
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+//<-
+#ifdef BOOST_NO_SFINAE
+ bool
+#else
+//->
+ typename ::boost::enable_if< ::boost::mpl::equal_to<MCI1,MCI2>,bool>::type
+//<-
+#endif
+//->
+ operator==(
+ pre_order_iterator<NP1,MCI1> const& lhs
+ , pre_order_iterator<NP2,MCI2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ inline bool
+#else
+ inline typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator==(
+ pre_order_iterator<NP1,MCI1> const& lhs
+ , pre_order_iterator<NP2,MCI2> const& rhs
+ )
+ {
+ if (lhs._state == rhs._state)
+ {
+ return lhs._state ? (*lhs == *rhs) : !rhs._state;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__pre_order_iterator__operator_not_equal
+namespace boost { namespace tree_node {
+
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+//<-
+#ifdef BOOST_NO_SFINAE
+ bool
+#else
+//->
+ typename ::boost::enable_if< ::boost::mpl::equal_to<MCI1,MCI2>,bool>::type
+//<-
+#endif
+//->
+ operator!=(
+ pre_order_iterator<NP1,MCI1> const& lhs
+ , pre_order_iterator<NP2,MCI2> const& rhs
+ );
+
+ //<-
+ template <typename NP1, typename NP2, typename MCI1, typename MCI2>
+#ifdef BOOST_NO_SFINAE
+ inline bool
+#else
+ inline typename ::boost::enable_if<
+ ::boost::mpl::equal_to<MCI1,MCI2>
+ , bool
+ >::type
+#endif
+ operator!=(
+ pre_order_iterator<NP1,MCI1> const& lhs
+ , pre_order_iterator<NP2,MCI2> const& rhs
+ )
+ {
+ return !(lhs == rhs);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__make_pre_order_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ pre_order_iterator<NodePointer,::boost::mpl::false_>
+ make_pre_order_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline pre_order_iterator<NodePointer,::boost::mpl::false_>
+ make_pre_order_iterator(NodePointer const& node)
+ {
+ return pre_order_iterator<NodePointer,::boost::mpl::false_>(node);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__make_pre_order_descendant_iterator
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer>
+ pre_order_iterator<NodePointer,::boost::mpl::true_>
+ make_pre_order_descendant_iterator(NodePointer const& node);
+
+ //<-
+ template <typename NodePointer>
+ inline pre_order_iterator<NodePointer,::boost::mpl::true_>
+ make_pre_order_descendant_iterator(NodePointer const& node)
+ {
+ return pre_order_iterator<NodePointer,::boost::mpl::true_>(node);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__pre_order_iterate
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename UnaryFunction>
+ void pre_order_iterate(NodePointer const& node, UnaryFunction function);
+
+ //<-
+ template <typename NodePointer, typename UnaryFunction>
+ void pre_order_iterate(NodePointer const& node, UnaryFunction function)
+ {
+ for (
+ pre_order_iterator<NodePointer,::boost::mpl::false_> itr(node);
+ itr;
+ ++itr
+ )
+ {
+ function(*itr);
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+//[reference__pre_order_iterate_descendants
+namespace boost { namespace tree_node {
+
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ pre_order_iterate_descendants(
+ NodePointer const& node
+ , UnaryFunction function
+ );
+
+ //<-
+ template <typename NodePointer, typename UnaryFunction>
+ void
+ pre_order_iterate_descendants(
+ NodePointer const& node
+ , UnaryFunction function
+ )
+ {
+ for (
+ pre_order_iterator<NodePointer,::boost::mpl::true_> itr(node);
+ itr;
+ ++itr
+ )
+ {
+ function(*itr);
+ }
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_PRE_ORDER_ITERATOR_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/raw_associative_node.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/raw_associative_node.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,408 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_RAW_ASSOCIATIVE_NODE_HPP_INCLUDED
+#define BOOST_TREE_NODE_RAW_ASSOCIATIVE_NODE_HPP_INCLUDED
+
+#include <utility>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/apply_wrap.hpp>
+#include <boost/tr1/tuple.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/utility/associative_container_gen.hpp>
+#include <boost/tree_node/depth_first_iterator.hpp>
+#include <boost/detail/function/add_const_to_2nd_pointee.hpp>
+
+//[reference__raw_associative_node
+namespace boost { namespace tree_node {
+
+ template <
+ typename Key
+ , typename Data
+ , typename AssociativeContainerSelector = ::boost::mapS
+ >
+ class raw_associative_node
+ {
+ public:
+ typedef Key
+ key_type;
+ typedef Data
+ data_type;
+ typedef raw_associative_node*
+ pointer;
+ typedef raw_associative_node const*
+ const_pointer;
+
+ //<-
+ private:
+ typedef typename ::boost::mpl::apply_wrap2<
+ associative_container_gen<
+ AssociativeContainerSelector
+ >
+ , Key
+ , pointer
+ >::type
+ children;
+
+ public:
+ //->
+ typedef // implementation_defined
+ //<-
+ typename children::iterator
+ //->
+ child_iterator;
+ typedef // implementation_defined
+ //<-
+ ::boost::transform_iterator<
+ ::boost::detail::add_const_to_2nd_pointee<
+ Key
+ , raw_associative_node
+ >
+ , typename children::const_iterator
+ >
+ //->
+ const_child_iterator;
+
+ //<-
+ private:
+ children _children;
+ pointer _parent;
+ data_type _data;
+
+ public:
+ //->
+ raw_associative_node();
+
+ explicit raw_associative_node(data_type const& data);
+
+ raw_associative_node(raw_associative_node const& copy);
+
+ raw_associative_node&
+ operator=(raw_associative_node const& copy);
+
+ ~raw_associative_node();
+
+ data_type const& get_data() const;
+
+ data_type& get_data();
+
+ const_pointer get_parent() const;
+
+ pointer get_parent();
+
+ pointer add_child(key_type const& key, data_type const& data);
+
+ pointer add_child(key_type const& key);
+
+ pointer add_child_copy(key_type const& key, const_pointer const& copy);
+
+ const_child_iterator get_child_begin() const;
+
+ child_iterator get_child_begin();
+
+ const_child_iterator get_child_end() const;
+
+ child_iterator get_child_end();
+
+ std::pair<const_child_iterator,const_child_iterator>
+ get_children() const;
+
+ std::pair<child_iterator,child_iterator>
+ get_children();
+
+ const_child_iterator find_child(key_type const& key) const;
+
+ child_iterator find_child(key_type const& key);
+
+ ::std::pair<const_child_iterator,const_child_iterator>
+ find_children(key_type const& key) const;
+
+ ::std::pair<child_iterator,child_iterator>
+ find_children(key_type const& key);
+
+ ::std::size_t remove_children(key_type const& key);
+
+ void remove_all_children();
+ };
+
+ //<-
+ template <typename K, typename D, typename A>
+ raw_associative_node<K,D,A>::raw_associative_node()
+ : _children(), _parent(), _data()
+ {
+ }
+
+ template <typename K, typename D, typename A>
+ raw_associative_node<K,D,A>::raw_associative_node(data_type const& data)
+ : _children(), _parent(), _data(data)
+ {
+ }
+
+ template <typename K, typename D, typename A>
+ raw_associative_node<K,D,A>::raw_associative_node(
+ raw_associative_node const& copy
+ ) : _children(), _parent(), _data(copy._data)
+ {
+ pointer p = this;
+
+ for (
+ depth_first_iterator<const_pointer,::boost::mpl::true_> copy_itr(
+ &copy
+ );
+ copy_itr;
+ ++copy_itr
+ )
+ {
+ switch (traversal_state(copy_itr))
+ {
+ case pre_order_traversal:
+ {
+ p = p->add_child(
+ copy_itr->first
+ , copy_itr->second->get_data()
+ );
+ break;
+ }
+
+ case post_order_traversal:
+ {
+ p = p->_parent;
+ break;
+ }
+ }
+ }
+ }
+
+ template <typename K, typename D, typename A>
+ raw_associative_node<K,D,A>&
+ raw_associative_node<K,D,A>::operator=(
+ raw_associative_node const& copy
+ )
+ {
+ if (this != &copy)
+ {
+ raw_associative_node temp_copy(copy);
+
+ remove_all_children();
+ _children = temp_copy._children;
+ _data = temp_copy._data;
+ temp_copy._children.clear();
+
+ child_iterator itr_end = get_child_end();
+
+ for (child_iterator itr = get_child_begin(); itr != itr_end; ++itr)
+ {
+ itr->second->_parent = this;
+ }
+ }
+
+ return *this;
+ }
+
+ template <typename K, typename D, typename A>
+ raw_associative_node<K,D,A>::~raw_associative_node()
+ {
+ remove_all_children();
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::data_type const&
+ raw_associative_node<K,D,A>::get_data() const
+ {
+ return _data;
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::data_type&
+ raw_associative_node<K,D,A>::get_data()
+ {
+ return _data;
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::const_pointer
+ raw_associative_node<K,D,A>::get_parent() const
+ {
+ return _parent;
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::pointer
+ raw_associative_node<K,D,A>::get_parent()
+ {
+ return _parent;
+ }
+
+ template <typename K, typename D, typename A>
+ typename raw_associative_node<K,D,A>::pointer
+ raw_associative_node<K,D,A>::add_child(
+ key_type const& key
+ , data_type const& data
+ )
+ {
+ pointer child(new raw_associative_node(data));
+
+ child->_parent = this;
+ _children.insert(typename children::value_type(key, child));
+ return child;
+ }
+
+ template <typename K, typename D, typename A>
+ typename raw_associative_node<K,D,A>::pointer
+ raw_associative_node<K,D,A>::add_child(key_type const& key)
+ {
+ pointer child(new raw_associative_node());
+
+ child->_parent = this;
+ _children.insert(typename children::value_type(key, child));
+ return child;
+ }
+
+ template <typename K, typename D, typename A>
+ typename raw_associative_node<K,D,A>::pointer
+ raw_associative_node<K,D,A>::add_child_copy(
+ key_type const& key
+ , const_pointer const& copy
+ )
+ {
+ pointer child(new raw_associative_node(*copy));
+
+ child->_parent = this;
+ _children.insert(typename children::value_type(key, child));
+ return child;
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::const_child_iterator
+ raw_associative_node<K,D,A>::get_child_begin() const
+ {
+ return const_child_iterator(_children.begin());
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::child_iterator
+ raw_associative_node<K,D,A>::get_child_begin()
+ {
+ return _children.begin();
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::const_child_iterator
+ raw_associative_node<K,D,A>::get_child_end() const
+ {
+ return const_child_iterator(_children.end());
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::child_iterator
+ raw_associative_node<K,D,A>::get_child_end()
+ {
+ return _children.end();
+ }
+
+ template <typename K, typename D, typename A>
+ inline ::std::pair<
+ typename raw_associative_node<K,D,A>::const_child_iterator
+ , typename raw_associative_node<K,D,A>::const_child_iterator
+ >
+ raw_associative_node<K,D,A>::get_children() const
+ {
+ return ::std::pair<const_child_iterator,const_child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename K, typename D, typename A>
+ inline ::std::pair<
+ typename raw_associative_node<K,D,A>::child_iterator
+ , typename raw_associative_node<K,D,A>::child_iterator
+ >
+ raw_associative_node<K,D,A>::get_children()
+ {
+ return ::std::pair<child_iterator,child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::const_child_iterator
+ raw_associative_node<K,D,A>::find_child(key_type const& key) const
+ {
+ return const_child_iterator(_children.find(key));
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename raw_associative_node<K,D,A>::child_iterator
+ raw_associative_node<K,D,A>::find_child(key_type const& key)
+ {
+ return _children.find(key);
+ }
+
+ template <typename K, typename D, typename A>
+ inline ::std::pair<
+ typename raw_associative_node<K,D,A>::const_child_iterator
+ , typename raw_associative_node<K,D,A>::const_child_iterator
+ >
+ raw_associative_node<K,D,A>::find_children(key_type const& key) const
+ {
+ ::std::pair<
+ typename children::const_iterator
+ , typename children::const_iterator
+ > p(_children.equal_range(key));
+
+ return ::std::pair<const_child_iterator,const_child_iterator>(
+ const_child_iterator(p.first)
+ , const_child_iterator(p.second)
+ );
+ }
+
+ template <typename K, typename D, typename A>
+ inline ::std::pair<
+ typename raw_associative_node<K,D,A>::child_iterator
+ , typename raw_associative_node<K,D,A>::child_iterator
+ >
+ raw_associative_node<K,D,A>::find_children(key_type const& key)
+ {
+ return _children.equal_range(key);
+ }
+
+ template <typename K, typename D, typename A>
+ ::std::size_t
+ raw_associative_node<K,D,A>::remove_children(key_type const& key)
+ {
+ child_iterator itr, itr_end;
+
+ for (
+ ::std::tr1::tie(itr, itr_end) = _children.equal_range(key);
+ itr != itr_end;
+ ++itr
+ )
+ {
+ delete itr->second;
+ }
+
+ return _children.erase(key);
+ }
+
+ template <typename K, typename D, typename A>
+ void raw_associative_node<K,D,A>::remove_all_children()
+ {
+ child_iterator itr_end = get_child_end();
+
+ for (child_iterator itr = get_child_begin(); itr != itr_end; ++itr)
+ {
+ delete itr->second;
+ }
+
+ _children.clear();
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_RAW_ASSOCIATIVE_NODE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/raw_binary_node.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/raw_binary_node.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,569 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_RAW_BINARY_NODE_HPP_INCLUDED
+#define BOOST_TREE_NODE_RAW_BINARY_NODE_HPP_INCLUDED
+
+#include <iterator>
+#include <utility>
+#include <boost/config.hpp>
+#include <boost/mpl/bool.hpp>
+#ifndef BOOST_NO_SFINAE
+#include <boost/tr1/type_traits.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/utility/enable_if.hpp>
+#endif
+#include <boost/array.hpp>
+#include <boost/tree_node/depth_first_iterator.hpp>
+#include <boost/detail/function/add_const_to_pointee.hpp>
+
+//[reference__raw_binary_node
+namespace boost { namespace tree_node {
+ //<-
+ namespace _detail {
+
+ template <typename NodePointer>
+ class raw_binary_child_iterator
+ {
+#ifndef BOOST_NO_SFINAE
+ struct enabler
+ {
+ };
+#endif
+
+ NodePointer _child;
+
+ public:
+ typedef NodePointer value_type;
+ typedef value_type const& reference;
+ typedef value_type const* pointer;
+ typedef ::std::ptrdiff_t difference_type;
+ typedef ::std::forward_iterator_tag iterator_category;
+
+ explicit raw_binary_child_iterator(NodePointer const& p);
+
+ raw_binary_child_iterator();
+
+ template <typename NP>
+ raw_binary_child_iterator(
+ raw_binary_child_iterator<NP> const& other
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ ::std::tr1::is_convertible<NP,NodePointer>
+ , enabler
+ >::type = enabler()
+#endif
+ );
+
+ reference operator*() const;
+
+ pointer operator->() const;
+
+ raw_binary_child_iterator& operator++();
+
+ raw_binary_child_iterator operator++(int);
+
+ template <typename NP1, typename NP2>
+ friend bool
+ operator==(
+ raw_binary_child_iterator<NP1> const& lhs
+ , raw_binary_child_iterator<NP2> const& rhs
+ );
+ };
+
+ template <typename NodePointer>
+ raw_binary_child_iterator<NodePointer>::raw_binary_child_iterator(
+ NodePointer const& p
+ ) : _child(
+ p->get_left_child() ? p->get_left_child() : p->get_right_child()
+ )
+ {
+ }
+
+ template <typename NodePointer>
+ raw_binary_child_iterator<NodePointer>::raw_binary_child_iterator()
+ : _child(0)
+ {
+ }
+
+ template <typename NodePointer>
+ template <typename NP>
+ raw_binary_child_iterator<NodePointer>::raw_binary_child_iterator(
+ raw_binary_child_iterator<NP> const& other
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ ::std::tr1::is_convertible<NP,NodePointer>
+ , enabler
+ >::type
+#endif
+ ) : _child(other._child)
+ {
+ }
+
+ template <typename NodePointer>
+ inline typename raw_binary_child_iterator<NodePointer>::reference
+ raw_binary_child_iterator<NodePointer>::operator*() const
+ {
+ return _child;
+ }
+
+ template <typename NodePointer>
+ inline typename raw_binary_child_iterator<NodePointer>::pointer
+ raw_binary_child_iterator<NodePointer>::operator->() const
+ {
+ return &_child;
+ }
+
+ template <typename NodePointer>
+ inline raw_binary_child_iterator<NodePointer>&
+ raw_binary_child_iterator<NodePointer>::operator++()
+ {
+ NodePointer sibling = _child->get_parent()->get_right_child();
+ _child = (_child == sibling) ? 0 : sibling;
+ return *this;
+ }
+
+ template <typename NodePointer>
+ raw_binary_child_iterator<NodePointer>
+ raw_binary_child_iterator<NodePointer>::operator++(int)
+ {
+ raw_binary_child_iterator<NodePointer> itr(*this);
+ ++(*this);
+ return itr;
+ }
+
+ template <typename NP1, typename NP2>
+ inline bool
+ operator==(
+ raw_binary_child_iterator<NP1> const& lhs
+ , raw_binary_child_iterator<NP2> const& rhs
+ )
+ {
+ return lhs._child == rhs._child;
+ }
+
+ template <typename NP1, typename NP2>
+ inline bool
+ operator!=(
+ raw_binary_child_iterator<NP1> const& lhs
+ , raw_binary_child_iterator<NP2> const& rhs
+ )
+ {
+ return !(lhs == rhs);
+ }
+ } // namespace _detail
+ //->
+
+ template <typename T>
+ class raw_binary_node
+ {
+ public:
+ typedef T
+ data_type;
+ typedef raw_binary_node*
+ pointer;
+ typedef raw_binary_node const*
+ const_pointer;
+ typedef // implementation_defined
+ //<-
+ _detail::raw_binary_child_iterator<pointer>
+ //->
+ child_iterator;
+ typedef // implementation_defined
+ //<-
+ _detail::raw_binary_child_iterator<const_pointer>
+ //->
+ const_child_iterator;
+
+ //<-
+ private:
+ pointer _left_child;
+ pointer _right_child;
+ pointer _parent;
+ data_type _data;
+
+ public:
+ //->
+ raw_binary_node();
+
+ explicit raw_binary_node(data_type const& data);
+
+ raw_binary_node(raw_binary_node const& copy);
+
+ raw_binary_node& operator=(raw_binary_node const& copy);
+
+ ~raw_binary_node();
+
+ data_type const& get_data() const;
+
+ data_type& get_data();
+
+ const_pointer get_parent() const;
+
+ pointer get_parent();
+
+ pointer add_left_child(data_type const& data);
+
+ pointer add_left_child();
+
+ pointer add_left_child_copy(const_pointer const& copy);
+
+ pointer add_right_child(data_type const& data);
+
+ pointer add_right_child();
+
+ pointer add_right_child_copy(const_pointer const& copy);
+
+ const_pointer get_left_child() const;
+
+ pointer get_left_child();
+
+ const_pointer get_right_child() const;
+
+ pointer get_right_child();
+
+ const_child_iterator get_child_begin() const;
+
+ child_iterator get_child_begin();
+
+ const_child_iterator get_child_end() const;
+
+ child_iterator get_child_end();
+
+ std::pair<const_child_iterator,const_child_iterator>
+ get_children() const;
+
+ std::pair<child_iterator,child_iterator>
+ get_children();
+
+ pointer rotate_left();
+
+ pointer rotate_right();
+
+ void remove_left_child();
+
+ void remove_right_child();
+
+ void remove_all_children();
+ };
+
+ //<-
+ template <typename T>
+ raw_binary_node<T>::raw_binary_node()
+ : _left_child(), _right_child(), _parent(), _data()
+ {
+ }
+
+ template <typename T>
+ raw_binary_node<T>::raw_binary_node(data_type const& data)
+ : _left_child(), _right_child(), _parent(), _data(data)
+ {
+ }
+
+ template <typename T>
+ raw_binary_node<T>::raw_binary_node(raw_binary_node const& copy)
+ : _left_child(), _right_child(), _parent(), _data(copy._data)
+ {
+ pointer p = this;
+
+ for (
+ depth_first_iterator<const_pointer,::boost::mpl::true_> copy_itr(
+ &copy
+ );
+ copy_itr;
+ ++copy_itr
+ )
+ {
+ switch (traversal_state(copy_itr))
+ {
+ case pre_order_traversal:
+ {
+ const_pointer c_p = *copy_itr;
+
+ if (c_p->_parent->_left_child == c_p)
+ {
+ p = p->add_left_child(c_p->get_data());
+ }
+ else // if (c_p->_parent->_right_child == c_p)
+ {
+ p = p->add_right_child(c_p->get_data());
+ }
+
+ break;
+ }
+
+ case post_order_traversal:
+ {
+ p = p->_parent;
+ break;
+ }
+ }
+ }
+ }
+
+ template <typename T>
+ raw_binary_node<T>&
+ raw_binary_node<T>::operator=(raw_binary_node const& copy)
+ {
+ if (this != &copy)
+ {
+ raw_binary_node temp_copy(copy);
+
+ delete _left_child;
+ delete _right_child;
+ _left_child = temp_copy._left_child;
+ _right_child = temp_copy._right_child;
+ _data = temp_copy._data;
+ temp_copy._left_child = temp_copy._right_child = 0;
+ _left_child->_parent = _right_child->_parent = this;
+ }
+
+ return *this;
+ }
+
+ template <typename T>
+ raw_binary_node<T>::~raw_binary_node()
+ {
+ remove_all_children();
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::data_type const&
+ raw_binary_node<T>::get_data() const
+ {
+ return _data;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::data_type&
+ raw_binary_node<T>::get_data()
+ {
+ return _data;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::const_pointer
+ raw_binary_node<T>::get_parent() const
+ {
+ return _parent;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::get_parent()
+ {
+ return _parent;
+ }
+
+ template <typename T>
+ typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::add_left_child(data_type const& data)
+ {
+ _left_child = new raw_binary_node(data);
+ _left_child->_parent = this;
+ return _left_child;
+ }
+
+ template <typename T>
+ typename raw_binary_node<T>::pointer raw_binary_node<T>::add_left_child()
+ {
+ _left_child = new raw_binary_node();
+ _left_child->_parent = this;
+ return _left_child;
+ }
+
+ template <typename T>
+ typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::add_left_child_copy(const_pointer const& copy)
+ {
+ _left_child = new raw_binary_node(*copy);
+ _left_child->_parent = this;
+ return _left_child;
+ }
+
+ template <typename T>
+ typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::add_right_child(data_type const& data)
+ {
+ _right_child = new raw_binary_node(data);
+ _right_child->_parent = this;
+ return _right_child;
+ }
+
+ template <typename T>
+ typename raw_binary_node<T>::pointer raw_binary_node<T>::add_right_child()
+ {
+ _right_child = new raw_binary_node();
+ _right_child->_parent = this;
+ return _right_child;
+ }
+
+ template <typename T>
+ typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::add_right_child_copy(const_pointer const& copy)
+ {
+ _right_child = new raw_binary_node(*copy);
+ _right_child->_parent = this;
+ return _right_child;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::const_pointer
+ raw_binary_node<T>::get_left_child() const
+ {
+ return _left_child;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::get_left_child()
+ {
+ return _left_child;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::const_pointer
+ raw_binary_node<T>::get_right_child() const
+ {
+ return _right_child;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::get_right_child()
+ {
+ return _right_child;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::const_child_iterator
+ raw_binary_node<T>::get_child_begin() const
+ {
+ return const_child_iterator(this);
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::child_iterator
+ raw_binary_node<T>::get_child_begin()
+ {
+ return child_iterator(this);
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::const_child_iterator
+ raw_binary_node<T>::get_child_end() const
+ {
+ return const_child_iterator();
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::child_iterator
+ raw_binary_node<T>::get_child_end()
+ {
+ return child_iterator();
+ }
+
+ template <typename T>
+ inline ::std::pair<
+ typename raw_binary_node<T>::const_child_iterator
+ , typename raw_binary_node<T>::const_child_iterator
+ >
+ raw_binary_node<T>::get_children() const
+ {
+ return ::std::pair<const_child_iterator,const_child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename T>
+ inline ::std::pair<
+ typename raw_binary_node<T>::child_iterator
+ , typename raw_binary_node<T>::child_iterator
+ >
+ raw_binary_node<T>::get_children()
+ {
+ return ::std::pair<child_iterator,child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::rotate_left()
+ {
+ pointer pivot = _right_child;
+
+ pivot->_parent = _parent;
+ _right_child = pivot->_left_child;
+ _right_child->_parent = pivot->_left_child = this;
+
+ if (_parent)
+ {
+ if (_parent->_left_child == this)
+ {
+ _parent->_left_child = pivot;
+ }
+ else // if (_parent->_right_child == this)
+ {
+ _parent->_right_child = pivot;
+ }
+ }
+
+ return _parent = pivot;
+ }
+
+ template <typename T>
+ inline typename raw_binary_node<T>::pointer
+ raw_binary_node<T>::rotate_right()
+ {
+ pointer pivot = _left_child;
+
+ pivot->_parent = _parent;
+ _left_child = pivot->_right_child;
+ _left_child->_parent = pivot->_right_child = this;
+
+ if (_parent)
+ {
+ if (_parent->_right_child == this)
+ {
+ _parent->_right_child = pivot;
+ }
+ else // if (_parent->_left_child == this)
+ {
+ _parent->_left_child = pivot;
+ }
+ }
+
+ return _parent = pivot;
+ }
+
+ template <typename T>
+ void raw_binary_node<T>::remove_left_child()
+ {
+ delete _left_child;
+ _left_child = 0;
+ }
+
+ template <typename T>
+ void raw_binary_node<T>::remove_right_child()
+ {
+ delete _right_child;
+ _right_child = 0;
+ }
+
+ template <typename T>
+ inline void raw_binary_node<T>::remove_all_children()
+ {
+ remove_left_child();
+ remove_right_child();
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_RAW_BINARY_NODE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/raw_node.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/raw_node.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,321 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_RAW_NODE_HPP_INCLUDED
+#define BOOST_TREE_NODE_RAW_NODE_HPP_INCLUDED
+
+#include <utility>
+#include <boost/mpl/bool.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/utility/container_gen.hpp>
+#include <boost/tree_node/depth_first_iterator.hpp>
+#include <boost/detail/function/add_const_to_pointee.hpp>
+
+//[reference__raw_node
+namespace boost { namespace tree_node {
+
+ template <typename T, typename Selector = ::boost::dequeS>
+ class raw_node
+ {
+ public:
+ typedef T
+ data_type;
+ typedef raw_node*
+ pointer;
+ typedef raw_node const*
+ const_pointer;
+
+ //<-
+ private:
+ typedef typename ::boost::container_gen<Selector,pointer>::type
+ children;
+
+ public:
+ //->
+ typedef // implementation_defined
+ //<-
+ typename children::iterator
+ //->
+ child_iterator;
+ typedef // implementation_defined
+ //<-
+#if 0
+// TODO:
+// Fix crash that occurs on depth-first iteration
+// when this code is is used.
+ ::boost::transform_iterator<
+ ::boost::detail::add_const_to_pointee<raw_node>
+ , typename children::const_iterator
+ >
+#else
+ typename children::const_iterator
+#endif
+ //->
+ const_child_iterator;
+
+ //<-
+ private:
+ children _children;
+ pointer _parent;
+ data_type _data;
+
+ public:
+ //->
+ raw_node();
+
+ explicit raw_node(data_type const& data);
+
+ raw_node(raw_node const& copy);
+
+ raw_node& operator=(raw_node const& copy);
+
+ ~raw_node();
+
+ data_type const& get_data() const;
+
+ data_type& get_data();
+
+ const_pointer get_parent() const;
+
+ pointer get_parent();
+
+ pointer add_child(data_type const& data);
+
+ pointer add_child();
+
+ pointer add_child_copy(const_pointer const& copy);
+
+ const_child_iterator get_child_begin() const;
+
+ child_iterator get_child_begin();
+
+ const_child_iterator get_child_end() const;
+
+ child_iterator get_child_end();
+
+ std::pair<const_child_iterator,const_child_iterator>
+ get_children() const;
+
+ std::pair<child_iterator,child_iterator>
+ get_children();
+
+ void remove_all_children();
+
+ //<-
+ private:
+ void _add_child(pointer const& child);
+ //->
+ };
+
+ //<-
+ template <typename T, typename Selector>
+ raw_node<T,Selector>::raw_node() : _children(), _parent(), _data()
+ {
+ }
+
+ template <typename T, typename Selector>
+ raw_node<T,Selector>::raw_node(data_type const& data)
+ : _children(), _parent(), _data(data)
+ {
+ }
+
+ template <typename T, typename Selector>
+ raw_node<T,Selector>::raw_node(raw_node const& copy)
+ : _children(), _parent(), _data(copy._data)
+ {
+ pointer p = this;
+
+ for (
+ depth_first_iterator<const_pointer,::boost::mpl::true_> copy_itr(
+ &copy
+ );
+ copy_itr;
+ ++copy_itr
+ )
+ {
+ switch (traversal_state(copy_itr))
+ {
+ case pre_order_traversal:
+ {
+ p = p->add_child((*copy_itr)->get_data());
+ break;
+ }
+
+ case post_order_traversal:
+ {
+ p = p->_parent;
+ break;
+ }
+ }
+ }
+ }
+
+ template <typename T, typename Selector>
+ raw_node<T,Selector>& raw_node<T,Selector>::operator=(raw_node const& copy)
+ {
+ if (this != &copy)
+ {
+ raw_node temp_copy(copy);
+
+ remove_all_children();
+ _children = temp_copy._children;
+ _data = temp_copy._data;
+ temp_copy._children.clear();
+
+ child_iterator itr_end = get_child_end();
+
+ for (child_iterator itr = get_child_begin(); itr != itr_end; ++itr)
+ {
+ (*itr)->_parent = this;
+ }
+ }
+
+ return *this;
+ }
+
+ template <typename T, typename Selector>
+ raw_node<T,Selector>::~raw_node()
+ {
+ remove_all_children();
+ }
+
+ template <typename T, typename Selector>
+ inline typename raw_node<T,Selector>::data_type const&
+ raw_node<T,Selector>::get_data() const
+ {
+ return _data;
+ }
+
+ template <typename T, typename Selector>
+ inline typename raw_node<T,Selector>::data_type&
+ raw_node<T,Selector>::get_data()
+ {
+ return _data;
+ }
+
+ template <typename T, typename Selector>
+ inline typename raw_node<T,Selector>::const_pointer
+ raw_node<T,Selector>::get_parent() const
+ {
+ return _parent;
+ }
+
+ template <typename T, typename Selector>
+ inline typename raw_node<T,Selector>::pointer
+ raw_node<T,Selector>::get_parent()
+ {
+ return _parent;
+ }
+
+ template <typename T, typename Selector>
+ typename raw_node<T,Selector>::pointer
+ raw_node<T,Selector>::add_child(data_type const& data)
+ {
+ pointer child = new raw_node(data);
+
+ child->_parent = this;
+ _add_child(child);
+ return child;
+ }
+
+ template <typename T, typename Selector>
+ typename raw_node<T,Selector>::pointer raw_node<T,Selector>::add_child()
+ {
+ pointer child = new raw_node();
+
+ child->_parent = this;
+ _add_child(child);
+ return child;
+ }
+
+ template <typename T, typename Selector>
+ typename raw_node<T,Selector>::pointer
+ raw_node<T,Selector>::add_child_copy(const_pointer const& copy)
+ {
+ pointer child = new raw_node(*copy);
+
+ child->_parent = this;
+ _add_child(child);
+ return child;
+ }
+
+ template <typename T, typename Selector>
+ inline typename raw_node<T,Selector>::const_child_iterator
+ raw_node<T,Selector>::get_child_begin() const
+ {
+ return const_child_iterator(_children.begin());
+ }
+
+ template <typename T, typename Selector>
+ inline typename raw_node<T,Selector>::child_iterator
+ raw_node<T,Selector>::get_child_begin()
+ {
+ return _children.begin();
+ }
+
+ template <typename T, typename Selector>
+ inline typename raw_node<T,Selector>::const_child_iterator
+ raw_node<T,Selector>::get_child_end() const
+ {
+ return const_child_iterator(_children.end());
+ }
+
+ template <typename T, typename Selector>
+ inline typename raw_node<T,Selector>::child_iterator
+ raw_node<T,Selector>::get_child_end()
+ {
+ return _children.end();
+ }
+
+ template <typename T, typename Selector>
+ inline ::std::pair<
+ typename raw_node<T,Selector>::const_child_iterator
+ , typename raw_node<T,Selector>::const_child_iterator
+ >
+ raw_node<T,Selector>::get_children() const
+ {
+ return ::std::pair<const_child_iterator,const_child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename T, typename Selector>
+ inline ::std::pair<
+ typename raw_node<T,Selector>::child_iterator
+ , typename raw_node<T,Selector>::child_iterator
+ >
+ raw_node<T,Selector>::get_children()
+ {
+ return ::std::pair<child_iterator,child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename T, typename Selector>
+ void raw_node<T,Selector>::remove_all_children()
+ {
+ child_iterator itr_end = get_child_end();
+
+ for (child_iterator itr = get_child_begin(); itr != itr_end; ++itr)
+ {
+ delete *itr;
+ }
+
+ _children.clear();
+ }
+
+ template <typename T, typename Selector>
+ inline void raw_node<T,Selector>::_add_child(pointer const& child)
+ {
+ _children.insert(_children.end(), child);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_RAW_NODE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/simple_associative_node.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/simple_associative_node.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,410 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_SIMPLE_ASSOCIATIVE_NODE_HPP_INCLUDED
+#define BOOST_TREE_NODE_SIMPLE_ASSOCIATIVE_NODE_HPP_INCLUDED
+
+#include <utility>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/apply_wrap.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/tr1/memory.hpp>
+#include <boost/tr1/tuple.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/utility/associative_container_gen.hpp>
+#include <boost/tree_node/depth_first_iterator.hpp>
+#include <boost/detail/function/add_const_to_2nd_sh_ptee.hpp>
+
+//[reference__simple_associative_node
+namespace boost { namespace tree_node {
+
+ template <
+ typename Key
+ , typename Data
+ , typename AssociativeContainerSelector = ::boost::mapS
+ >
+ class simple_associative_node
+ : public ::std::tr1::enable_shared_from_this<
+ simple_associative_node<Key,Data,AssociativeContainerSelector>
+ >
+ , private noncopyable
+ {
+ public:
+ typedef Key
+ key_type;
+ typedef Data
+ data_type;
+ typedef ::std::tr1::shared_ptr<simple_associative_node>
+ pointer;
+ typedef ::std::tr1::shared_ptr<simple_associative_node const>
+ const_pointer;
+
+ //<-
+ private:
+ typedef typename ::boost::mpl::apply_wrap2<
+ associative_container_gen<
+ AssociativeContainerSelector
+ >
+ , key_type
+ , pointer
+ >::type
+ children;
+
+ public:
+ //->
+ typedef // implementation_defined
+ //<-
+ typename children::iterator
+ //->
+ child_iterator;
+ typedef // implementation_defined
+ //<-
+ ::boost::transform_iterator<
+ ::boost::detail::add_const_to_2nd_shared_pointee<
+ Key
+ , simple_associative_node
+ >
+ , typename children::const_iterator
+ >
+ //->
+ const_child_iterator;
+
+ //<-
+ private:
+ children _children;
+ ::std::tr1::weak_ptr<simple_associative_node> _parent;
+ data_type _data;
+
+ simple_associative_node();
+
+ explicit simple_associative_node(data_type const& data);
+
+ public:
+ //->
+ ~simple_associative_node();
+
+ data_type const& get_data() const;
+
+ data_type& get_data();
+
+ const_pointer get_parent() const;
+
+ pointer get_parent();
+
+ pointer add_child(key_type const& key, data_type const& data);
+
+ pointer add_child(key_type const& key);
+
+ pointer add_child_copy(key_type const& key, const_pointer const& copy);
+
+ const_child_iterator get_child_begin() const;
+
+ child_iterator get_child_begin();
+
+ const_child_iterator get_child_end() const;
+
+ child_iterator get_child_end();
+
+ std::pair<const_child_iterator,const_child_iterator>
+ get_children() const;
+
+ std::pair<child_iterator,child_iterator>
+ get_children();
+
+ const_child_iterator find_child(key_type const& key) const;
+
+ child_iterator find_child(key_type const& key);
+
+ ::std::pair<const_child_iterator,const_child_iterator>
+ find_children(key_type const& key) const;
+
+ ::std::pair<child_iterator,child_iterator>
+ find_children(key_type const& key);
+
+ ::std::size_t remove_children(Key const& key);
+
+ void remove_all_children();
+
+ static pointer create(data_type const& data);
+
+ static pointer create();
+
+ static pointer create_copy(const_pointer const& p);
+ };
+
+ //<-
+ template <typename K, typename D, typename A>
+ simple_associative_node<K,D,A>::simple_associative_node()
+ : _children(), _parent(), _data()
+ {
+ }
+
+ template <typename K, typename D, typename A>
+ simple_associative_node<K,D,A>::simple_associative_node(data_type const& d)
+ : _children(), _parent(), _data(d)
+ {
+ }
+
+ template <typename K, typename D, typename A>
+ simple_associative_node<K,D,A>::~simple_associative_node()
+ {
+ remove_all_children();
+ _parent.reset();
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::data_type const&
+ simple_associative_node<K,D,A>::get_data() const
+ {
+ return _data;
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::data_type&
+ simple_associative_node<K,D,A>::get_data()
+ {
+ return _data;
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::const_pointer
+ simple_associative_node<K,D,A>::get_parent() const
+ {
+ return const_pointer(_parent.lock());
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::pointer
+ simple_associative_node<K,D,A>::get_parent()
+ {
+ return pointer(_parent.lock());
+ }
+
+ template <typename K, typename D, typename A>
+ typename simple_associative_node<K,D,A>::pointer
+ simple_associative_node<K,D,A>::add_child(
+ key_type const& key
+ , data_type const& data
+ )
+ {
+ pointer child(new simple_associative_node(data));
+
+ child->_parent = this->shared_from_this();
+ _children.insert(typename children::value_type(key, child));
+ return child;
+ }
+
+ template <typename K, typename D, typename A>
+ typename simple_associative_node<K,D,A>::pointer
+ simple_associative_node<K,D,A>::add_child(key_type const& key)
+ {
+ pointer child(new simple_associative_node());
+
+ child->_parent = this->shared_from_this();
+ _children.insert(typename children::value_type(key, child));
+ return child;
+ }
+
+ template <typename K, typename D, typename A>
+ typename simple_associative_node<K,D,A>::pointer
+ simple_associative_node<K,D,A>::add_child_copy(
+ key_type const& key
+ , const_pointer const& copy
+ )
+ {
+ pointer child(create_copy(copy));
+
+ child->_parent = this->shared_from_this();
+ _children.insert(typename children::value_type(key, child));
+ return child;
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::const_child_iterator
+ simple_associative_node<K,D,A>::get_child_begin() const
+ {
+ return const_child_iterator(_children.begin());
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::child_iterator
+ simple_associative_node<K,D,A>::get_child_begin()
+ {
+ return _children.begin();
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::const_child_iterator
+ simple_associative_node<K,D,A>::get_child_end() const
+ {
+ return const_child_iterator(_children.end());
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::child_iterator
+ simple_associative_node<K,D,A>::get_child_end()
+ {
+ return _children.end();
+ }
+
+ template <typename K, typename D, typename A>
+ inline ::std::pair<
+ typename simple_associative_node<K,D,A>::const_child_iterator
+ , typename simple_associative_node<K,D,A>::const_child_iterator
+ >
+ simple_associative_node<K,D,A>::get_children() const
+ {
+ return ::std::pair<const_child_iterator,const_child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename K, typename D, typename A>
+ inline ::std::pair<
+ typename simple_associative_node<K,D,A>::child_iterator
+ , typename simple_associative_node<K,D,A>::child_iterator
+ >
+ simple_associative_node<K,D,A>::get_children()
+ {
+ return ::std::pair<child_iterator,child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::const_child_iterator
+ simple_associative_node<K,D,A>::find_child(key_type const& key) const
+ {
+ return const_child_iterator(_children.find(key));
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::child_iterator
+ simple_associative_node<K,D,A>::find_child(key_type const& key)
+ {
+ return _children.find(key);
+ }
+
+ template <typename K, typename D, typename A>
+ inline ::std::pair<
+ typename simple_associative_node<K,D,A>::const_child_iterator
+ , typename simple_associative_node<K,D,A>::const_child_iterator
+ >
+ simple_associative_node<K,D,A>::find_children(
+ key_type const& key
+ ) const
+ {
+ ::std::pair<
+ typename children::const_iterator
+ , typename children::const_iterator
+ > p(_children.equal_range(key));
+
+ return ::std::pair<const_child_iterator,const_child_iterator>(
+ const_child_iterator(p.first)
+ , const_child_iterator(p.second)
+ );
+ }
+
+ template <typename K, typename D, typename A>
+ inline ::std::pair<
+ typename simple_associative_node<K,D,A>::child_iterator
+ , typename simple_associative_node<K,D,A>::child_iterator
+ >
+ simple_associative_node<K,D,A>::find_children(key_type const& key)
+ {
+ return _children.equal_range(key);
+ }
+
+ template <typename K, typename D, typename A>
+ ::std::size_t
+ simple_associative_node<K,D,A>::remove_children(key_type const& key)
+ {
+ child_iterator itr, itr_end;
+
+ for (
+ ::std::tr1::tie(itr, itr_end) = _children.equal_range(key);
+ itr != itr_end;
+ ++itr
+ )
+ {
+ itr->second->remove_all_children();
+ itr->second->_parent.reset();
+ }
+
+ return _children.erase(key);
+ }
+
+ template <typename K, typename D, typename A>
+ void simple_associative_node<K,D,A>::remove_all_children()
+ {
+ child_iterator itr_end = get_child_end();
+
+ for (child_iterator itr = get_child_begin(); itr != itr_end; ++itr)
+ {
+ itr->second->remove_all_children();
+ itr->second->_parent.reset();
+ }
+
+ _children.clear();
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::pointer
+ simple_associative_node<K,D,A>::create(data_type const& data)
+ {
+ return pointer(new simple_associative_node(data));
+ }
+
+ template <typename K, typename D, typename A>
+ inline typename simple_associative_node<K,D,A>::pointer
+ simple_associative_node<K,D,A>::create()
+ {
+ return pointer(new simple_associative_node());
+ }
+
+ template <typename K, typename D, typename A>
+ typename simple_associative_node<K,D,A>::pointer
+ simple_associative_node<K,D,A>::create_copy(const_pointer const& copy)
+ {
+ pointer result(new simple_associative_node(copy->get_data()));
+ pointer p(result);
+
+ for (
+ depth_first_iterator<const_pointer,::boost::mpl::true_> copy_itr(
+ copy
+ );
+ copy_itr;
+ ++copy_itr
+ )
+ {
+ switch (traversal_state(copy_itr))
+ {
+ case pre_order_traversal:
+ {
+ p = p->add_child(
+ copy_itr->first
+ , copy_itr->second->get_data()
+ );
+ break;
+ }
+
+ case post_order_traversal:
+ {
+ p = p->get_parent();
+ break;
+ }
+ }
+ }
+
+ return result;
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_SIMPLE_ASSOCIATIVE_NODE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/simple_node.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/simple_node.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,317 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_SIMPLE_NODE_HPP_INCLUDED
+#define BOOST_TREE_NODE_SIMPLE_NODE_HPP_INCLUDED
+
+#include <utility>
+#include <boost/mpl/bool.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/tr1/memory.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/utility/container_gen.hpp>
+#include <boost/tree_node/depth_first_iterator.hpp>
+#include <boost/detail/function/add_const_to_sh_ptee.hpp>
+
+//[reference__simple_node
+namespace boost { namespace tree_node {
+
+ template <typename T, typename Selector = ::boost::dequeS>
+ class simple_node
+ : public ::std::tr1::enable_shared_from_this<simple_node<T> >
+ , private noncopyable
+ {
+ public:
+ typedef T
+ data_type;
+ typedef ::std::tr1::shared_ptr<simple_node>
+ pointer;
+ typedef ::std::tr1::shared_ptr<simple_node const>
+ const_pointer;
+
+ //<-
+ private:
+ typedef typename ::boost::container_gen<Selector,pointer>::type
+ children;
+
+ public:
+ //->
+ typedef // implementation_defined
+ //<-
+ typename children::iterator
+ //->
+ child_iterator;
+ typedef // implementation_defined
+ //<-
+ ::boost::transform_iterator<
+ ::boost::detail::add_const_to_shared_pointee<simple_node>
+ , typename children::const_iterator
+ >
+ //->
+ const_child_iterator;
+
+ //<-
+ private:
+ children _children;
+ ::std::tr1::weak_ptr<simple_node> _parent;
+ data_type _data;
+
+ simple_node();
+
+ explicit simple_node(data_type const& data);
+
+ public:
+ //->
+ ~simple_node();
+
+ data_type const& get_data() const;
+
+ data_type& get_data();
+
+ const_pointer get_parent() const;
+
+ pointer get_parent();
+
+ pointer add_child(data_type const& data);
+
+ pointer add_child();
+
+ pointer add_child_copy(const_pointer const& copy);
+
+ const_child_iterator get_child_begin() const;
+
+ child_iterator get_child_begin();
+
+ const_child_iterator get_child_end() const;
+
+ child_iterator get_child_end();
+
+ std::pair<const_child_iterator,const_child_iterator>
+ get_children() const;
+
+ std::pair<child_iterator,child_iterator>
+ get_children();
+
+ void remove_all_children();
+
+ static pointer create(data_type const& data);
+
+ static pointer create();
+
+ static pointer create_copy(const_pointer const& p);
+
+ //<-
+ private:
+ void _add_child(pointer const& child);
+ //->
+ };
+
+ //<-
+ template <typename T, typename Selector>
+ simple_node<T,Selector>::simple_node() : _children(), _parent(), _data()
+ {
+ }
+
+ template <typename T, typename Selector>
+ simple_node<T,Selector>::simple_node(data_type const& data)
+ : _children(), _parent(), _data(data)
+ {
+ }
+
+ template <typename T, typename Selector>
+ simple_node<T,Selector>::~simple_node()
+ {
+ remove_all_children();
+ _parent.reset();
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::data_type const&
+ simple_node<T,Selector>::get_data() const
+ {
+ return _data;
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::data_type&
+ simple_node<T,Selector>::get_data()
+ {
+ return _data;
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::const_pointer
+ simple_node<T,Selector>::get_parent() const
+ {
+ return const_pointer(_parent.lock());
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::pointer
+ simple_node<T,Selector>::get_parent()
+ {
+ return pointer(_parent.lock());
+ }
+
+ template <typename T, typename Selector>
+ typename simple_node<T,Selector>::pointer
+ simple_node<T,Selector>::add_child(data_type const& data)
+ {
+ pointer child(new simple_node(data));
+
+ child->_parent = this->shared_from_this();
+ _add_child(child);
+ return child;
+ }
+
+ template <typename T, typename Selector>
+ typename simple_node<T,Selector>::pointer
+ simple_node<T,Selector>::add_child()
+ {
+ pointer child(new simple_node<T>());
+
+ child->_parent = this->shared_from_this();
+ _add_child(child);
+ return child;
+ }
+
+ template <typename T, typename Selector>
+ typename simple_node<T,Selector>::pointer
+ simple_node<T,Selector>::add_child_copy(const_pointer const& copy)
+ {
+ pointer child(create_copy(copy));
+
+ child->_parent = this->shared_from_this();
+ _add_child(child);
+ return child;
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::const_child_iterator
+ simple_node<T,Selector>::get_child_begin() const
+ {
+ return const_child_iterator(_children.begin());
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::child_iterator
+ simple_node<T,Selector>::get_child_begin()
+ {
+ return _children.begin();
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::const_child_iterator
+ simple_node<T,Selector>::get_child_end() const
+ {
+ return const_child_iterator(_children.end());
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::child_iterator
+ simple_node<T,Selector>::get_child_end()
+ {
+ return _children.end();
+ }
+
+ template <typename T, typename Selector>
+ inline ::std::pair<
+ typename simple_node<T,Selector>::const_child_iterator
+ , typename simple_node<T,Selector>::const_child_iterator
+ >
+ simple_node<T,Selector>::get_children() const
+ {
+ return ::std::pair<const_child_iterator,const_child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename T, typename Selector>
+ inline ::std::pair<
+ typename simple_node<T,Selector>::child_iterator
+ , typename simple_node<T,Selector>::child_iterator
+ >
+ simple_node<T,Selector>::get_children()
+ {
+ return ::std::pair<child_iterator,child_iterator>(
+ get_child_begin()
+ , get_child_end()
+ );
+ }
+
+ template <typename T, typename Selector>
+ void simple_node<T,Selector>::remove_all_children()
+ {
+ child_iterator itr_end = get_child_end();
+
+ for (child_iterator itr = get_child_begin(); itr != itr_end; ++itr)
+ {
+ (*itr)->remove_all_children();
+ (*itr)->_parent.reset();
+ }
+
+ _children.clear();
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::pointer
+ simple_node<T,Selector>::create(data_type const& data)
+ {
+ return pointer(new simple_node(data));
+ }
+
+ template <typename T, typename Selector>
+ inline typename simple_node<T,Selector>::pointer
+ simple_node<T,Selector>::create()
+ {
+ return pointer(new simple_node());
+ }
+
+ template <typename T, typename Selector>
+ typename simple_node<T,Selector>::pointer
+ simple_node<T,Selector>::create_copy(const_pointer const& copy)
+ {
+ pointer result(new simple_node(copy->get_data()));
+ pointer p(result);
+
+ for (
+ depth_first_iterator<const_pointer,::boost::mpl::true_> copy_itr(
+ copy
+ );
+ copy_itr;
+ ++copy_itr
+ )
+ {
+ switch (traversal_state(copy_itr))
+ {
+ case pre_order_traversal:
+ {
+ p = p->add_child((*copy_itr)->get_data());
+ break;
+ }
+
+ case post_order_traversal:
+ {
+ p = p->get_parent();
+ break;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ template <typename T, typename Selector>
+ inline void simple_node<T,Selector>::_add_child(pointer const& child)
+ {
+ _children.insert(_children.end(), child);
+ }
+ //->
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_SIMPLE_NODE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/traversal_state.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/traversal_state.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,24 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_TRAVERSAL_STATE_HPP_INCLUDED
+#define BOOST_TREE_NODE_TRAVERSAL_STATE_HPP_INCLUDED
+
+//[reference__traversal_state
+namespace boost { namespace tree_node {
+
+ enum traversal_state
+ {
+ no_traversal
+ , pre_order_traversal
+ , post_order_traversal
+ , breadth_first_traversal
+ , in_order_traversal
+ };
+}} // namespace boost::tree_node
+//]
+
+#endif // BOOST_TREE_NODE_TRAVERSAL_STATE_HPP_INCLUDED
+

Added: sandbox/tree_node/boost/tree_node/typeof.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/boost/tree_node/typeof.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,26 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TREE_NODE_TYPEOF_HPP_INCLUDED
+#define BOOST_TREE_NODE_TYPEOF_HPP_INCLUDED
+
+#include <boost/typeof/typeof.hpp>
+#include <boost/tree_node.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+BOOST_TYPEOF_REGISTER_TYPE(boost::tree_node::traversal_state)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::breadth_first_iterator, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::pre_order_iterator, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::post_order_iterator, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::depth_first_iterator, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::in_order_iterator, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::raw_binary_node, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::raw_node, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::simple_node, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::raw_assocoative_node, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tree_node::simple_assocoative_node, 3)
+
+#endif // BOOST_TREE_NODE_TYPEOF_HPP_INCLUDED
+

Deleted: sandbox/tree_node/libs/tree_node/doc/concept_assoc_tree_node.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/concept_assoc_tree_node.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,174 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:associative_tree_node Associative Tree Node]
-
-[section Description]
-Models of this concept provide key-based access to their child nodes.
-[endsect]
-
-[section Refinement of]
-__Tree_Node__
-[endsect]
-
-[variablelist Notation
- [[`Node`][A type that models the [*Associative Tree Node] concept.]]
- [[`node`][An object of type `Node::pointer`.]]
- [[`const_node`][An object of type `Node::const_pointer`.]]
- [[`Key`][The key type of `Node`.]]
- [[`key`][An object of type `Key const&`.]]
- [[`Data`][The data type of `Node`.]]
- [[`data`][An object of type `Data const&`.]]
-]
-
-[section:types Associated Types]
-One new type is introduced.
-
-[table
- [[Name][Expression][Description][Requirements]]
- [
- [Key type]
- [`Node::key_type`]
- [The type of a key that a tree node will associate with a child node.]
- []
- ]
-]
-
-In addition, the requirements for the child iterator types are strengthened:
-
- * The value type of `Node::child_iterator` must be
- [^_std_pair_<Node::key_type const&,Node::pointer>].
- * The value type of `Node::const_child_iterator` must be
- [^_std_pair_<Node::key_type const&,Node::const_pointer>].
-
-[endsect]
-
-[section:expressions Valid Expressions and Semantics]
-In addition to the expressions defined in the __Tree_Node__ concept, the
-following expressions must be valid.
-
-[table
- [
- [Name]
- [Expression]
- [Type requirements]
- [Return Type]
- [Semantics]
- [__Runtime_Complexity__]
- ]
- [
- [Child creation with data]
- [`node->add_child(key, data);`]
- []
- [`Node::pointer`]
- [
- Creates and returns a tree node to be associated with the specified
- key in the range of children of the invoking node. The node
- returned will store the specified data.
- ]
- [Amortized constant]
- ]
- [
- [Child creation]
- [`node->add_child(key)`]
- [
- The data type of `Node` must model the __Default_Constructible__
- concept.
- ]
- [`Node::pointer`]
- [
- Creates and returns a tree node to be associated with the specified
- key in the range of children of the invoking node.
- ]
- [Amortized constant]
- ]
- [
- [Child copy creation]
- [`node->add_child(key, const_node)`]
- []
- [`Node::pointer`]
- [
- Creates and returns a deep copy of `const_node` to be associated
- with the specified key in the range of children of the invoking
- node.
- ]
- [Linear with respect to the number of descendants of `const_node`]
- ]
- [
- [Child search]
- [`const_node->find_child(key)`]
- []
- [`Node::const_child_iterator`]
- [
- Returns an iterator pointing to a child node associated with the
- specified key, or `const_node->get_child_end()` if no such child
- exists.
- ]
- [Logarithmic]
- ]
- [
- [Child search]
- [`node->find_child(key)`]
- []
- [`Node::child_iterator`]
- [
- Returns an iterator pointing to a child node associated with the
- specified key, or `node->get_child_end()` if no such child exists.
- ]
- [Logarithmic]
- ]
- [
- [Child search range]
- [`const_node->find_children(key)`]
- []
- [[^_std_pair_<Node::const_child_iterator,Node::const_child_iterator>]]
- [
- Returns a pair `p` such that `[p.first, p.second)` is a range
- of all child nodes associated with the specified key. If no such
- children exist, then the range will be empty.
- ]
- [Logarithmic]
- ]
- [
- [Child search range]
- [`node->find_children(key)`]
- []
- [[^_std_pair_<Node::child_iterator,Node::child_iterator>]]
- [
- Returns a pair `p` such that `[p.first, p.second)` is a range
- of all child nodes associated with the specified key. If no such
- children exist, then the range will be empty.
- ]
- [Logarithmic]
- ]
- [
- [Remove children]
- [`const_node->remove_children(key)`]
- []
- [`std::size_t`]
- [
- Removes all child nodes associated with the specified key from the
- tree node. Returns the number of children removed.
- ]
- [
- Linear with respect to the number of children and their descendants
- in the range to be removed, plus logarithmic
- ]
- ]
-]
-[endsect]
-
-[section Models]
-
- * __raw_associative_node__
- * __simple_associative_node__
-
-[endsect]
-
-[endsect] [/ Associative Tree Node]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/concept_descendant_iterator.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/concept_descendant_iterator.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,105 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:tree_node_desc_iterator Tree Node Descendant Iterator]
-
-[section Description]
-This concept may seem redundant at first, especially when iterating through
-__Random_Access_Child_Iterator_Tree_Node__ objects; however, for
-__Associative_Tree_Node__ objects, models of this concept provide the sole
-means of accessing the key associated with each node being traversed. (Root
-nodes are not associated with keys at the tree node level, so models of this
-concept do not traverse them.)
-[endsect]
-
-[section Refinement of]
-__Tree_Node_Iterator__
-[endsect]
-
-[variablelist Notation
- [
- [`Iterator`]
- [A type that models the [*Tree Node Descendant Iterator] concept.]
- ]
- [
- [`itr`]
- [An object of type `Iterator`.]
- ]
- [
- [`Node`]
- [A type that models the __Tree_Node__ concept.]
- ]
- [
- [`node`]
- [An object of type `Node::pointer`.]
- ]
- [
- [`const_node`]
- [An object of type `Node::const_pointer`.]
- ]
-]
-
-[section:types Associated Types]
-No additional types beyond those defined in the __Tree_Node_Iterator__ concept;
-however, the requirements for the value type are strengthened: its value type,
-in turn, must model the __Forward_Iterator__ concept.
-[endsect]
-
-[section:expressions Valid Expressions and Semantics]
-None beyond those defined in the __Tree_Node_Iterator__ concept; however, the
-type requirements for the constructors are strengthened, and their semantics
-are clarified.
-
-[table
- [
- [Name]
- [Expression]
- [Type requirements]
- [Semantics]
- ]
- [
- [Constructor from mutable node]
- [``
- Iterator(node)
- Iterator itr(node)
- ``]
- []
- [
- Constructs an iterator that will iterate through the descendants of
- the specified node.
- ]
- ]
- [
- [Constructor from immutable node]
- [``
- Iterator(const_node)
- Iterator itr(const_node)
- ``]
- [
- The value type of `Iterator` must be the value type of
- `Node::const_child_iterator`.
- ]
- [
- Constructs an iterator that will iterate through the descendants of
- the specified node.
- ]
- ]
-]
-[endsect]
-
-[section Models]
-
- * The return type of __make_breadth_first_descendant_iterator__.
- * The return type of __make_pre_order_descendant_iterator__.
- * The return type of __make_post_order_descendant_iterator__.
- * The return type of __make_depth_first_descendant_iterator__.
-
-[endsect]
-
-[endsect] [/ Tree Node Descendant Iterator]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/concept_full_iterator.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/concept_full_iterator.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,83 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:full_tree_node_iterator Full Tree Node Iterator]
-
-[section Description]
-This concept specifies the requirement that models traverse the root node as
-well as its descendants.
-[endsect]
-
-[section Refinement of]
-__Tree_Node_Iterator__
-[endsect]
-
-[variablelist Notation
- [[`Iterator`][A type that models the [*Full Tree Node Iterator] concept.]]
- [[`itr`][An object of type `Iterator`.]]
- [[`Node`][A type that models the __Tree_Node__ concept.]]
- [[`node`][An object of type `Node::pointer`.]]
- [[`const_node`][An object of type `Node::const_pointer`.]]
-]
-
-[section:types Associated Types]
-No additional types beyond those defined in the __Tree_Node_Iterator__ concept;
-however, the requirements for the value type are strengthened: its unqualified
-value type, in turn, must model the __Tree_Node__ concept.
-[endsect]
-
-[section:expressions Valid Expressions and Semantics]
-None beyond those defined in the __Tree_Node_Iterator__ concept; however, the
-type requirements for the constructors are strengthened, and their semantics
-are clarified.
-
-[table
- [
- [Name]
- [Expression]
- [Type requirements]
- [Semantics]
- ]
- [
- [Constructor from mutable node]
- [``
- Iterator(node)
- Iterator itr(node)
- ``]
- []
- [
- Constructs an iterator that will iterate through the specified node
- and its descendants.
- ]
- ]
- [
- [Constructor from immutable node]
- [``
- Iterator(const_node)
- Iterator itr(const_node)
- ``]
- [The value type of `Iterator::value_type` must be `const`-qualified.]
- [
- Constructs an iterator that will iterate through the specified node
- and its descendants.
- ]
- ]
-]
-[endsect]
-
-[section Models]
-
- * The return type of __make_breadth_first_iterator__.
- * The return type of __make_pre_order_iterator__.
- * The return type of __make_post_order_iterator__.
- * The return type of __make_depth_first_iterator__.
-
-[endsect]
-
-[endsect] [/ Tree Node Iterator]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/concept_iterator.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/concept_iterator.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,106 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:tree_node_iterator Tree Node Iterator]
-
-[section Description]
-Tree-traversing iterators at the __Tree_Node__ level must be created
-differently from iterators at the __Container__ level. Furthermore, tree node
-iterators typically store more stateful information than their __Container__
-counterparts; requiring two of them to check for dereferenceability may prove
-somewhat memory-inefficient. This concept provides an alternate means of
-checking for dereferenceability that requires the use of only the active
-iterator.
-[endsect]
-
-[section Refinement of]
-__Forward_Iterator__
-[endsect]
-
-[variablelist Notation
- [[`Iterator`][A type that models the [*Tree Node Iterator] concept.]]
- [[`itr`][An object of type `Iterator`.]]
- [[`Node`][A type that models the __Tree_Node__ concept.]]
- [[`node`][An object of type `Node::pointer`.]]
- [[`const_node`][An object of type `Node::const_pointer`.]]
-]
-
-[section:types Associated Types]
-No additional types beyond those defined in the __Forward_Iterator__ concept;
-however, the requirements for the value type are strengthened: it must model
-the __Trivial_Iterator__ concept.
-[endsect]
-
-[section:expressions Valid Expressions and Semantics]
-In addition to the expressions defined in the __Forward_Iterator__ concept, the
-following expressions must be valid.
-
-[table
- [
- [Name]
- [Expression]
- [Return Type]
- [Semantics]
- [__Runtime_Complexity__]
- ]
- [
- [Default constructor]
- [``
- Iterator()
- Iterator itr
- ``]
- []
- [Constructs a non-dereferenceable (past-the-end) iterator.]
- [Constant]
- ]
- [
- [Constructor from mutable node]
- [``
- Iterator(node)
- Iterator itr(node)
- ``]
- []
- [Refinement-specific.]
- [Amortized constant]
- ]
- [
- [Constructor from immutable node]
- [``
- Iterator(const_node)
- Iterator itr(const_node)
- ``]
- []
- [Refinement-specific.]
- [Amortized constant]
- ]
- [
- [Dereferenceability]
- [`itr`]
- [A type that can be used in a boolean context.]
- [
- Returns a value convertible to `true` if `itr` is dereferenceable,
- a value convertible to `false` if it is past-the-end.
- ]
- [Constant]
- ]
-]
-
-The __Forward_Iterator__ requirement that the increment operators must exhibit
-constant time complexity has been relaxed; they now need only exhibit linear
-time complexity with respect to the number of descendants in the worst case.
-[endsect]
-
-[section Models]
-
- * All models of the __Full_Tree_Node_Iterator__ concept.
- * All models of the __Tree_Node_Descendant_Iterator__ concept.
-
-[endsect]
-
-[endsect] [/ Tree Node Iterator]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/concept_raci_tree_node.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/concept_raci_tree_node.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,118 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:raci_tree_node Random Access Child Iterator Tree Node]
-
-[section Description]
-Models of this concept provide constant-time random access to their child
-nodes.
-[endsect]
-
-[section Refinement of]
-__Tree_Node__
-[endsect]
-
-[variablelist Notation
- [
- [`Node`]
- [
- A type that models the [*Random Access Child Iterator Tree Node]
- concept.
- ]
- ]
- [
- [`node`]
- [An object of type `Node::pointer`.]
- ]
- [
- [`const_node`]
- [An object of type `Node::const_pointer`.]
- ]
- [
- [`Data`]
- [The data type of `Node`.]
- ]
- [
- [`data`]
- [An object of type `Data const&`.]
- ]
-]
-
-[section:types Associated Types]
-No additional types beyond those defined in the __Tree_Node__ concept; however,
-the requirements for the child iterator types are strengthened:
-
- * Both types must model the __Random_Access_Iterator__ concept.
- * The value type of `Node::child_iterator` must be `Node::pointer`.
- * The value type of `Node::const_child_iterator` must be
- `Node::const_pointer`.
-
-[endsect]
-
-[section:expressions Valid Expressions and Semantics]
-In addition to the expressions defined in the __Tree_Node__ concept, the
-following expressions must be valid.
-
-[table
- [
- [Name]
- [Expression]
- [Type requirements]
- [Return Type]
- [Semantics]
- [__Runtime_Complexity__]
- ]
- [
- [Child creation with data]
- [`node->add_child(data)`]
- []
- [`Node::pointer`]
- [
- Creates and returns a tree node to be stored in the range of
- children of the invoking node. The node returned will store
- the specified data.
- ]
- [Amortized constant]
- ]
- [
- [Child creation]
- [`node->add_child()`]
- [
- The data type of `Node` must model the __Default_Constructible__
- concept.
- ]
- [`Node::pointer`]
- [
- Creates and returns a tree node to be stored in the range of
- children of the invoking node.
- ]
- [Amortized constant]
- ]
- [
- [Child copy creation]
- [`node->add_child(const_node)`]
- []
- [`Node::pointer`]
- [
- Creates and returns a deep copy of `const_node` to be stored in the
- range of children of the invoking node.
- ]
- [Linear with respect to the number of descendants of `const_node`]
- ]
-]
-[endsect]
-
-[section Models]
-
- * __raw_node__
- * __simple_node__
-
-[endsect]
-
-[endsect] [/ Random-Access Child Iterator Tree Node]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/concept_tree_node.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/concept_tree_node.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,176 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:tree_node Tree Node]
-
-[section Description]
-All tree node implementations that this library provides model this concept.
-[endsect]
-
-[variablelist Notation
- [[`Node`][A type that models the [*Tree Node] concept.]]
- [[`node`][An object of type `Node::pointer`.]]
- [[`const_node`][An object of type `Node::const_pointer`.]]
-]
-
-[section:types Associated Types]
-[table
- [[Name][Expression][Description][Requirements]]
- [
- [Data type]
- [`Node::data_type`]
- [The type of the object stored in a tree node.]
- [
- It must model the __Copy_Constructible__ concept, but need not
- model the __Assignable__ concept.
- ]
- ]
- [
- [Pointer type]
- [`Node::pointer`]
- [The type of a pointer to a `Node` object.]
- [
- It must model the __Trivial_Iterator__ concept, it must point to
- a mutable object, and it must be implicitly convertible to
- `Node::const_pointer`.
- ]
- ]
- [
- [Pointer-to-const type]
- [`Node::const_pointer`]
- [The type of a pointer to a `Node const` object.]
- [
- It must model the __Trivial_Iterator__ concept, and it must /not/
- point to a mutable object.
- ]
- ]
- [
- [Child iterator type]
- [`Node::child_iterator`]
- [
- The type of iterator used to iterate through the children of a
- `Node` object.
- ]
- [
- It must model the __Input_Iterator__ concept, and it must be
- convertible to `Node::const_child_iterator`.
- ]
- ]
- [
- [Immutable child iterator type]
- [`Node::const_child_iterator`]
- [
- The type of iterator used to iterate through the children of a
- `Node const` object.
- ]
- [
- It must model the __Input_Iterator__ concept, and it must be
- convertible to `Node::const_child_iterator`.
- ]
- ]
-]
-[endsect]
-
-[section:expressions Valid Expressions and Semantics]
-[table
- [[Name][Expression][Return Type][Semantics][__Runtime_Complexity__]]
- [
- [Data access]
- [`const_node->get_data()`]
- [`Data const&`]
- [Returns the object stored in the tree node.]
- [Constant]
- ]
- [
- [Data access]
- [`node->get_data()`]
- [`Data&`]
- [Returns the object stored in the tree node.]
- [Constant]
- ]
- [
- [Parent access]
- [`const_node->get_parent()`]
- [`Node::const_pointer`]
- [
- Returns the parent of the tree node, or a null pointer if the node
- is the root.
- ]
- [Constant]
- ]
- [
- [Parent access]
- [`node->get_parent()`]
- [`Node::pointer`]
- [
- Returns the parent of the tree node, or a null pointer if the node
- is the root.
- ]
- [Constant]
- ]
- [
- [Children range begin access]
- [`const_node->get_child_begin()`]
- [`Node::const_child_iterator`]
- [
- Returns an iterator pointing to the beginning of the range of
- children of the tree node. If the range is empty, then the
- iterator points past-the-end.
- ]
- [Constant]
- ]
- [
- [Children range begin access]
- [`node->get_child_begin()`]
- [`Node::child_iterator`]
- [
- Returns an iterator pointing to the beginning of the range of
- children of the tree node. If the range is empty, then the
- iterator points past-the-end.
- ]
- [Constant]
- ]
- [
- [Children range past-the-end access]
- [`const_node->get_child_end();`]
- [`Node::const_child_iterator`]
- [
- Returns an iterator pointing past the end of the range of children
- of the tree node.
- ]
- [Constant]
- ]
- [
- [Children range past-the-end access]
- [`node->get_child_end();`]
- [`Node::child_iterator`]
- [
- Returns an iterator pointing past the end of the range of children
- of the tree node.
- ]
- [Constant]
- ]
- [
- [Remove all children]
- [`node->remove_all_children()`]
- [`void`]
- [Removes all children from the tree node.]
- [Linear with respect to the number of children]
- ]
-]
-[endsect]
-
-[section Models]
-
- * All models of the __Random_Access_Child_Iterator_Tree_Node__ concept.
- * All models of the __Associative_Tree_Node__ concept.
-
-[endsect]
-
-[endsect] [/ Tree Node]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/concepts.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/concepts.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,28 +0,0 @@
-[/=============================================================================
- Copyright (C) 2007-2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section Concepts]
-
-[include concept_tree_node.qbk]
-[include concept_raci_tree_node.qbk]
-[include concept_assoc_tree_node.qbk]
-[include concept_iterator.qbk]
-[include concept_full_iterator.qbk]
-[include concept_descendant_iterator.qbk]
-
-[heading Core Concepts]
-
- * __Tree_Node__
- * __Random_Access_Child_Iterator_Tree_Node__
- * __Associative_Tree_Node__
- * __Tree_Node_Iterator__
- * __Full_Tree_Node_Iterator__
- * __Tree_Node_Descendant_Iterator__
-
-[endsect] [/ Concepts]
-

Added: sandbox/tree_node/libs/tree_node/doc/html/index.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/index.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,58 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Chapter&#160;1.&#160;tree_node 0.1</title>
+<link rel="stylesheet" href="boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="next" href="tree_node/concepts.html" title="Concepts">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="tree_node/concepts.html"><img src="images/next.png" alt="Next"></a></div>
+<div class="chapter">
+<div class="titlepage"><div>
+<div><h2 class="title">
+<a name="tree_node"></a>Chapter&#160;1.&#160;tree_node 0.1</h2></div>
+<div><div class="author"><h3 class="author">
+<span class="firstname">Cromwell D.</span> <span class="surname">Enage</span>
+</h3></div></div>
+<div><p class="copyright">Copyright &#169; 2011 Cromwell D. Enage</p></div>
+<div><div class="legalnotice">
+<a name="idp13403232"></a><p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></div>
+</div></div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl>
+<dt><span class="section">Concepts</span></dt>
+<dt><span class="section">Reference</span></dt>
+</dl>
+</div>
+<a name="tree_node.rationale"></a><h3>
+<a name="idp13405408"></a>
+ <a class="link" href="index.html#tree_node.rationale">Rationale</a>
+ </h3>
+<p>
+ Over the course of reimplementing a decision tree learning algorithm to use modern
+ C++ techniques, the need for a generic tree library became evident. The in-house
+ data structures in use at the time were undergoing modification as well. It was
+ found that the core operations occurred at the node level rather than at the
+ tree level, which stored only high-level algorithms. Efforts went underway to
+ retrofit these algorithms to use iterators and to further factor out generic
+ data structures from the decision tree components and other application-specific
+ utilities. This library represents the Boostified culmination of these efforts.
+ </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: October 15, 2011 at 21:29:50 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="tree_node/concepts.html"><img src="images/next.png" alt="Next"></a></div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,49 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Concepts</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="next" href="concepts/tree_node.html" title="Tree Node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="concepts/tree_node.html"><img src="../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="tree_node.concepts"></a><a class="link" href="concepts.html" title="Concepts">Concepts</a>
+</h2></div></div></div>
+<a name="tree_node.concepts.core_concepts"></a><h4>
+<a name="idp14378704"></a>
+ <a class="link" href="concepts.html#tree_node.concepts.core_concepts">Core Concepts</a>
+ </h4>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a>
+ <span class="special">*</span> <a class="link" href="concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ <span class="special">*</span> <a class="link" href="concepts/non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a>
+ <span class="special">*</span> <a class="link" href="concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ <span class="special">*</span> <a class="link" href="concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary Tree Node</strong></span></a>
+<span class="special">*</span> <a class="link" href="concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ <span class="special">*</span> <a class="link" href="concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a>
+ <span class="special">*</span> <a class="link" href="concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a>
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="concepts/tree_node.html"><img src="../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/associative_tree_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/associative_tree_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,472 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Associative Tree Node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../concepts.html" title="Concepts">
+<link rel="prev" href="tree_node.html" title="Tree Node">
+<link rel="next" href="non_assoc_tree_node.html" title="Non-Associative Tree Node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="non_assoc_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.concepts.associative_tree_node"></a><a class="link" href="associative_tree_node.html" title="Associative Tree Node">Associative
+ Tree Node</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.associative_tree_node.description"></a><a class="link" href="associative_tree_node.html#tree_node.concepts.associative_tree_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ Models of this concept provide key-based access to their child nodes.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.associative_tree_node.refinement_of"></a><a class="link" href="associative_tree_node.html#tree_node.concepts.associative_tree_node.refinement_of" title="Refinement of">Refinement
+ of</a>
+</h4></div></div></div>
+<p>
+ <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+</div>
+<div class="variablelist">
+<p class="title"><b>Notation</b></p>
+<dl>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Node</span></code></span></dt>
+<dd><p>
+ A type that models the <span class="bold"><strong>Associative Tree Node</strong></span>
+ concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">const_node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Key</span></code></span></dt>
+<dd><p>
+ The key type of <code class="computeroutput"><span class="identifier">Node</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">key</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">&amp;</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Data</span></code></span></dt>
+<dd><p>
+ The data type of <code class="computeroutput"><span class="identifier">Node</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">data</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Data</span> <span class="keyword">const</span><span class="special">&amp;</span></code>.
+ </p></dd>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.associative_tree_node.types"></a><a class="link" href="associative_tree_node.html#tree_node.concepts.associative_tree_node.types" title="Associated Types">Associated
+ Types</a>
+</h4></div></div></div>
+<p>
+ One new type is introduced.
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ <p>
+ Key type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">key_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a key that a tree node will associate with a child
+ node.
+ </p>
+ </td>
+<td>
+ </td>
+</tr></tbody>
+</table></div>
+<p>
+ In addition, the requirements for the child iterator types are strengthened:
+ </p>
+<pre class="programlisting"><span class="special">*</span> <span class="identifier">The</span> <span class="identifier">value</span> <span class="identifier">type</span> <span class="identifier">of</span> <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">child_iterator</span><span class="error">`</span> <span class="identifier">must</span> <span class="identifier">be</span>
+ std::pair<span class="special">&lt;</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;,</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span><span class="special">&gt;.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="identifier">value</span> <span class="identifier">type</span> <span class="identifier">of</span> <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span><span class="error">`</span> <span class="identifier">must</span> <span class="identifier">be</span>
+ std::pair<span class="special">&lt;</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;,</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span><span class="special">&gt;.</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.associative_tree_node.expressions"></a><a class="link" href="associative_tree_node.html#tree_node.concepts.associative_tree_node.expressions" title="Valid Expressions and Semantics">Valid
+ Expressions and Semantics</a>
+</h4></div></div></div>
+<p>
+ In addition to the expressions defined in the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept, the following expressions
+ must be valid.
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Type requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Return Type
+ </p>
+ </th>
+<th>
+ <p>
+ Semantics
+ </p>
+ </th>
+<th>
+ <p>
+ <a href="http://en.wikipedia.org/wiki/Amortized_analysis" target="_top">Runtime
+ Complexity</a>
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key</span><span class="special">,</span>
+ <span class="identifier">data</span><span class="special">);</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a tree node to be associated with the specified
+ key in the range of children of the invoking node. The node returned
+ will store the specified data.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Data</span></code> must model
+ the Default Constructible concept.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a tree node to be associated with the specified
+ key in the range of children of the invoking node.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">key</span><span class="special">,</span>
+ <span class="identifier">const_node</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a deep copy of <code class="computeroutput"><span class="identifier">const_node</span></code>
+ to be associated with the specified key in the range of children
+ of the invoking node.
+ </p>
+ </td>
+<td>
+ <p>
+ Linear with respect to the number of descendants of <code class="computeroutput"><span class="identifier">const_node</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns an iterator pointing to a child node associated with
+ the specified key, or <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">get_child_end</span><span class="special">()</span></code> if no such child exists.
+ </p>
+ </td>
+<td>
+ <p>
+ Logarithmic
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns an iterator pointing to a child node associated with
+ the specified key, or <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">get_child_end</span><span class="special">()</span></code> if no such child exists.
+ </p>
+ </td>
+<td>
+ <p>
+ Logarithmic
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">find_children</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;Node::const_child_iterator,Node::const_child_iterator&gt;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns a pair <code class="computeroutput"><span class="identifier">p</span></code>
+ such that <code class="computeroutput"><span class="special">[</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span><span class="special">)</span></code> is a range of all child nodes
+ associated with the specified key. If no such children exist,
+ then the range will be empty.
+ </p>
+ </td>
+<td>
+ <p>
+ Logarithmic
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">find_children</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;Node::child_iterator,Node::child_iterator&gt;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns a pair <code class="computeroutput"><span class="identifier">p</span></code>
+ such that <code class="computeroutput"><span class="special">[</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span><span class="special">)</span></code> is a range of all child nodes
+ associated with the specified key. If no such children exist,
+ then the range will be empty.
+ </p>
+ </td>
+<td>
+ <p>
+ Logarithmic
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">remove_children</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Removes all child nodes associated with the specified key from
+ the tree node. Returns the number of children removed.
+ </p>
+ </td>
+<td>
+ <p>
+ Linear with respect to the number of children and their descendants
+ in the range to be removed, plus logarithmic
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.associative_tree_node.models"></a><a class="link" href="associative_tree_node.html#tree_node.concepts.associative_tree_node.models" title="Models">Models</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../reference/raw_associative_node.html" title="raw_associative_node"><code class="computeroutput"><span class="identifier">raw_associative_node</span></code></a>
+<span class="special">*</span> <a class="link" href="../reference/simple_associative_node.html" title="simple_associative_node"><code class="computeroutput"><span class="identifier">simple_associative_node</span></code></a>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="non_assoc_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/binary_tree_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/binary_tree_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,587 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Binary Tree Node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../concepts.html" title="Concepts">
+<link rel="prev" href="non_assoc_tree_node.html" title="Non-Associative Tree Node">
+<link rel="next" href="nary_tree_node.html" title="N-ary Tree Node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="non_assoc_tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="nary_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.concepts.binary_tree_node"></a><a class="link" href="binary_tree_node.html" title="Binary Tree Node">Binary Tree Node</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.binary_tree_node.description"></a><a class="link" href="binary_tree_node.html#tree_node.concepts.binary_tree_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ Models of this concept store at most two child nodes: left and right. The
+ operations that this concept defines include access to these children and
+ rotations that use the appropriate child as a pivot node.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.binary_tree_node.refinement_of"></a><a class="link" href="binary_tree_node.html#tree_node.concepts.binary_tree_node.refinement_of" title="Refinement of">Refinement
+ of</a>
+</h4></div></div></div>
+<p>
+ <a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative
+ Tree Node</strong></span></a>
+ </p>
+</div>
+<div class="variablelist">
+<p class="title"><b>Notation</b></p>
+<dl>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Node</span></code></span></dt>
+<dd><p>
+ A type that models the <span class="bold"><strong>Binary Tree Node</strong></span>
+ concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">const_node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Data</span></code></span></dt>
+<dd><p>
+ The data type of <code class="computeroutput"><span class="identifier">Node</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">data</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Data</span> <span class="keyword">const</span><span class="special">&amp;</span></code>.
+ </p></dd>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.binary_tree_node.types"></a><a class="link" href="binary_tree_node.html#tree_node.concepts.binary_tree_node.types" title="Associated Types">Associated
+ Types</a>
+</h4></div></div></div>
+<p>
+ No additional types beyond those defined in the <a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a> concept.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.binary_tree_node.expressions"></a><a class="link" href="binary_tree_node.html#tree_node.concepts.binary_tree_node.expressions" title="Valid Expressions and Semantics">Valid
+ Expressions and Semantics</a>
+</h4></div></div></div>
+<p>
+ In addition to the expressions defined in the <a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a> concept, the following
+ expressions must be valid.
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Type requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Return Type
+ </p>
+ </th>
+<th>
+ <p>
+ Semantics
+ </p>
+ </th>
+<th>
+ <p>
+ <a href="http://en.wikipedia.org/wiki/Amortized_analysis" target="_top">Runtime
+ Complexity</a>
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Left child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_left_child</span><span class="special">(</span><span class="identifier">data</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a tree node to be stored as the left child
+ of the invoking node. The node returned will store the specified
+ data.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_left_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Data</span></code> must model
+ the Default Constructible concept.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a tree node to be stored as the left child
+ of the invoking node.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_left_child_copy</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a deep copy of <code class="computeroutput"><span class="identifier">const_node</span></code>
+ to be stored as the left child of the invoking node.
+ </p>
+ </td>
+<td>
+ <p>
+ Linear with respect to the number of descendants of <code class="computeroutput"><span class="identifier">const_node</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_right_child</span><span class="special">(</span><span class="identifier">data</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a tree node to be stored as the right child
+ of the invoking node. The node returned will store the specified
+ data.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_right_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Data</span></code> must model
+ the Default Constructible concept.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a tree node to be stored as the right child
+ of the invoking node.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_right_child_copy</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a deep copy of <code class="computeroutput"><span class="identifier">const_node</span></code>
+ to be stored as the right child of the invoking node.
+ </p>
+ </td>
+<td>
+ <p>
+ Linear with respect to the number of descendants of <code class="computeroutput"><span class="identifier">const_node</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">get_left_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns the left child of the tree node, or a null pointer if
+ no such tree node exists.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">get_left_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns the left child of the tree node, or a null pointer if
+ no such tree node exists.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">get_right_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns the right child of the tree node, or a null pointer if
+ no such tree node exists.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">get_right_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns the right child of the tree node, or a null pointer if
+ no such tree node exists.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Rotate left
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">rotate_left</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Rotates the tree node in its hierarchy so that its right child,
+ the pivot node, becomes its parent. The left child of the pivot
+ node becomes the right child of the tree node. Returns the pivot
+ node.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Rotate right
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">rotate_right</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Rotates the tree node in its hierarchy so that its left child,
+ the pivot node, becomes its parent. The right child of the pivot
+ node becomes the left child of the tree node. Returns the pivot
+ node.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove left child
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">remove_left_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Removes the left child from the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Linear with respect to the number of descendants of the left
+ child
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove right child
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">remove_right_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Removes the right child from the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Linear with respect to the number of descendants of the right
+ child
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.binary_tree_node.models"></a><a class="link" href="binary_tree_node.html#tree_node.concepts.binary_tree_node.models" title="Models">Models</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../reference/raw_binary_node.html" title="raw_binary_node"><code class="computeroutput"><span class="identifier">raw_binary_node</span></code></a>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="non_assoc_tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="nary_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/full_tree_node_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/full_tree_node_iterator.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,202 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Full Tree Node Iterator</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../concepts.html" title="Concepts">
+<link rel="prev" href="tree_node_iterator.html" title="Tree Node Iterator">
+<link rel="next" href="tree_node_desc_iterator.html" title="Tree Node Descendant Iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tree_node_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="tree_node_desc_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.concepts.full_tree_node_iterator"></a><a class="link" href="full_tree_node_iterator.html" title="Full Tree Node Iterator">Full Tree
+ Node Iterator</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.full_tree_node_iterator.description"></a><a class="link" href="full_tree_node_iterator.html#tree_node.concepts.full_tree_node_iterator.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This concept specifies the requirement that models traverse the root node
+ as well as its descendants.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.full_tree_node_iterator.refinement_of"></a><a class="link" href="full_tree_node_iterator.html#tree_node.concepts.full_tree_node_iterator.refinement_of" title="Refinement of">Refinement
+ of</a>
+</h4></div></div></div>
+<p>
+ <a class="link" href="tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree
+ Node Iterator</strong></span></a>
+ </p>
+</div>
+<div class="variablelist">
+<p class="title"><b>Notation</b></p>
+<dl>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Iterator</span></code></span></dt>
+<dd><p>
+ A type that models the <span class="bold"><strong>Full Tree Node Iterator</strong></span>
+ concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">itr</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Iterator</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Node</span></code></span></dt>
+<dd><p>
+ A type that models the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">const_node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
+ </p></dd>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.full_tree_node_iterator.types"></a><a class="link" href="full_tree_node_iterator.html#tree_node.concepts.full_tree_node_iterator.types" title="Associated Types">Associated
+ Types</a>
+</h4></div></div></div>
+<p>
+ No additional types beyond those defined in the <a class="link" href="tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a> concept; however, the
+ requirements for the value type are strengthened: its unqualified value
+ type, in turn, must model the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.full_tree_node_iterator.expressions"></a><a class="link" href="full_tree_node_iterator.html#tree_node.concepts.full_tree_node_iterator.expressions" title="Valid Expressions and Semantics">Valid
+ Expressions and Semantics</a>
+</h4></div></div></div>
+<p>
+ None beyond those defined in the <a class="link" href="tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a> concept; however, the
+ type requirements for the constructors are strengthened, and their semantics
+ are clarified.
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Type requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Semantics
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Constructor from mutable node
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">Iterator</span><span class="special">(</span><span class="identifier">node</span><span class="special">)</span>
+<span class="identifier">Iterator</span> <span class="identifier">itr</span><span class="special">(</span><span class="identifier">node</span><span class="special">)</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ Constructs an iterator that will iterate through the specified
+ node and its descendants.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from immutable node
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">Iterator</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span>
+<span class="identifier">Iterator</span> <span class="identifier">itr</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ The value type of <code class="computeroutput"><span class="identifier">Iterator</span><span class="special">::</span><span class="identifier">value_type</span></code>
+ must be <code class="computeroutput"><span class="keyword">const</span></code>-qualified.
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs an iterator that will iterate through the specified
+ node and its descendants.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.full_tree_node_iterator.models"></a><a class="link" href="full_tree_node_iterator.html#tree_node.concepts.full_tree_node_iterator.models" title="Models">Models</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/breadth_first_iterator.html" title="breadth_first_iterator"><code class="computeroutput"><span class="identifier">make_breadth_first_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/pre_order_iterator.html" title="pre_order_iterator"><code class="computeroutput"><span class="identifier">make_pre_order_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/post_order_iterator.html" title="post_order_iterator"><code class="computeroutput"><span class="identifier">make_post_order_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/depth_first_iterator.html" title="depth_first_iterator"><code class="computeroutput"><span class="identifier">make_depth_first_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/in_order_iterator.html" title="in_order_iterator"><code class="computeroutput"><span class="identifier">make_in_order_forward_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/in_order_iterator.html" title="in_order_iterator"><code class="computeroutput"><span class="identifier">make_in_order_reverse_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tree_node_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="tree_node_desc_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/nary_tree_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/nary_tree_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,248 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>N-ary Tree Node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../concepts.html" title="Concepts">
+<link rel="prev" href="binary_tree_node.html" title="Binary Tree Node">
+<link rel="next" href="tree_node_iterator.html" title="Tree Node Iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="binary_tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="tree_node_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.concepts.nary_tree_node"></a><a class="link" href="nary_tree_node.html" title="N-ary Tree Node">N-ary Tree Node</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.nary_tree_node.description"></a><a class="link" href="nary_tree_node.html#tree_node.concepts.nary_tree_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ Models of this concept store arbitrary numbers of children and provide
+ simple child insertion expressions.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.nary_tree_node.refinement_of"></a><a class="link" href="nary_tree_node.html#tree_node.concepts.nary_tree_node.refinement_of" title="Refinement of">Refinement
+ of</a>
+</h4></div></div></div>
+<p>
+ <a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative
+ Tree Node</strong></span></a>
+ </p>
+</div>
+<div class="variablelist">
+<p class="title"><b>Notation</b></p>
+<dl>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Node</span></code></span></dt>
+<dd><p>
+ A type that models the <span class="bold"><strong>N-ary Tree Node</strong></span>
+ concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">const_node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Data</span></code></span></dt>
+<dd><p>
+ The data type of <code class="computeroutput"><span class="identifier">Node</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">data</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Data</span> <span class="keyword">const</span><span class="special">&amp;</span></code>.
+ </p></dd>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.nary_tree_node.types"></a><a class="link" href="nary_tree_node.html#tree_node.concepts.nary_tree_node.types" title="Associated Types">Associated
+ Types</a>
+</h4></div></div></div>
+<p>
+ No additional types beyond those defined in the <a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a> concept.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.nary_tree_node.expressions"></a><a class="link" href="nary_tree_node.html#tree_node.concepts.nary_tree_node.expressions" title="Valid Expressions and Semantics">Valid
+ Expressions and Semantics</a>
+</h4></div></div></div>
+<p>
+ In addition to the expressions defined in the <a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a> concept, the following
+ expressions must be valid.
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Type requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Return Type
+ </p>
+ </th>
+<th>
+ <p>
+ Semantics
+ </p>
+ </th>
+<th>
+ <p>
+ <a href="http://en.wikipedia.org/wiki/Amortized_analysis" target="_top">Runtime
+ Complexity</a>
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child</span><span class="special">(</span><span class="identifier">data</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a tree node to be stored in the range of
+ children of the invoking node. The node returned will store the
+ specified data.
+ </p>
+ </td>
+<td>
+ <p>
+ Logarithmic
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Data</span></code> must model
+ the Default Constructible concept.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a tree node to be stored in the range of
+ children of the invoking node.
+ </p>
+ </td>
+<td>
+ <p>
+ Logarithmic
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span></code>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates and returns a deep copy of <code class="computeroutput"><span class="identifier">const_node</span></code>
+ to be stored in the range of children of the invoking node.
+ </p>
+ </td>
+<td>
+ <p>
+ Linear with respect to the number of descendants of <code class="computeroutput"><span class="identifier">const_node</span></code>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.nary_tree_node.models"></a><a class="link" href="nary_tree_node.html#tree_node.concepts.nary_tree_node.models" title="Models">Models</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../reference/raw_node.html" title="raw_node"><code class="computeroutput"><span class="identifier">raw_node</span></code></a>
+<span class="special">*</span> <a class="link" href="../reference/simple_node.html" title="simple_node"><code class="computeroutput"><span class="identifier">simple_node</span></code></a>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="binary_tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="tree_node_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/non_assoc_tree_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/non_assoc_tree_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,87 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Non-Associative Tree Node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../concepts.html" title="Concepts">
+<link rel="prev" href="associative_tree_node.html" title="Associative Tree Node">
+<link rel="next" href="binary_tree_node.html" title="Binary Tree Node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="associative_tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="binary_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.concepts.non_assoc_tree_node"></a><a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node">Non-Associative
+ Tree Node</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.non_assoc_tree_node.description"></a><a class="link" href="non_assoc_tree_node.html#tree_node.concepts.non_assoc_tree_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ Models of this concept provide access to their child nodes via iterator
+ dereferencing.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.non_assoc_tree_node.refinement_of"></a><a class="link" href="non_assoc_tree_node.html#tree_node.concepts.non_assoc_tree_node.refinement_of" title="Refinement of">Refinement
+ of</a>
+</h4></div></div></div>
+<p>
+ <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.non_assoc_tree_node.types"></a><a class="link" href="non_assoc_tree_node.html#tree_node.concepts.non_assoc_tree_node.types" title="Associated Types">Associated
+ Types</a>
+</h4></div></div></div>
+<p>
+ No additional types beyond those defined in the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept; however, the requirements
+ for the child iterator types are strengthened:
+ </p>
+<pre class="programlisting"><span class="special">*</span> <span class="identifier">The</span> <span class="identifier">value</span> <span class="identifier">type</span> <span class="identifier">of</span> <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">child_iterator</span><span class="error">`</span> <span class="identifier">must</span> <span class="identifier">be</span> <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span><span class="error">`</span><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="identifier">value</span> <span class="identifier">type</span> <span class="identifier">of</span> <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span><span class="error">`</span> <span class="identifier">must</span> <span class="identifier">be</span>
+ <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span><span class="error">`</span><span class="special">.</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.non_assoc_tree_node.expressions"></a><a class="link" href="non_assoc_tree_node.html#tree_node.concepts.non_assoc_tree_node.expressions" title="Valid Expressions and Semantics">Valid
+ Expressions and Semantics</a>
+</h4></div></div></div>
+<p>
+ None beyond those defined in the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.non_assoc_tree_node.models"></a><a class="link" href="non_assoc_tree_node.html#tree_node.concepts.non_assoc_tree_node.models" title="Models">Models</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <span class="identifier">All</span> <span class="identifier">models</span> <span class="identifier">of</span> <span class="identifier">the</span> <a class="link" href="binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a> <span class="identifier">concept</span><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">All</span> <span class="identifier">models</span> <span class="identifier">of</span> <span class="identifier">the</span> <a class="link" href="nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary Tree Node</strong></span></a> <span class="identifier">concept</span><span class="special">.</span>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="associative_tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="binary_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Deleted: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/raci_tree_node.html
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/raci_tree_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,255 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Random Access Child Iterator Tree Node</title>
-<link rel="stylesheet" href="../../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
-<link rel="up" href="../concepts.html" title="Concepts">
-<link rel="prev" href="tree_node.html" title="Tree Node">
-<link rel="next" href="associative_tree_node.html" title="Associative Tree Node">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="associative_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="tree_node.concepts.raci_tree_node"></a><a class="link" href="raci_tree_node.html" title="Random Access Child Iterator Tree Node">Random Access Child
- Iterator Tree Node</a>
-</h3></div></div></div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="tree_node.concepts.raci_tree_node.description"></a><a class="link" href="raci_tree_node.html#tree_node.concepts.raci_tree_node.description" title="Description">Description</a>
-</h4></div></div></div>
-<p>
- Models of this concept provide constant-time random access to their child
- nodes.
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="tree_node.concepts.raci_tree_node.refinement_of"></a><a class="link" href="raci_tree_node.html#tree_node.concepts.raci_tree_node.refinement_of" title="Refinement of">Refinement
- of</a>
-</h4></div></div></div>
-<p>
- <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
- Node</strong></span></a>
- </p>
-</div>
-<div class="variablelist">
-<p class="title"><b>Notation</b></p>
-<dl>
-<dt><span class="term"><code class="computeroutput"><span class="identifier">Node</span></code></span></dt>
-<dd><p>
- A type that models the <span class="bold"><strong>Random Access Child Iterator
- Tree Node</strong></span> concept.
- </p></dd>
-<dt><span class="term"><code class="computeroutput"><span class="identifier">node</span></code></span></dt>
-<dd><p>
- An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>.
- </p></dd>
-<dt><span class="term"><code class="computeroutput"><span class="identifier">const_node</span></code></span></dt>
-<dd><p>
- An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
- </p></dd>
-<dt><span class="term"><code class="computeroutput"><span class="identifier">Data</span></code></span></dt>
-<dd><p>
- The data type of <code class="computeroutput"><span class="identifier">Node</span></code>.
- </p></dd>
-<dt><span class="term"><code class="computeroutput"><span class="identifier">data</span></code></span></dt>
-<dd><p>
- An object of type <code class="computeroutput"><span class="identifier">Data</span> <span class="keyword">const</span><span class="special">&amp;</span></code>.
- </p></dd>
-</dl>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="tree_node.concepts.raci_tree_node.types"></a><a class="link" href="raci_tree_node.html#tree_node.concepts.raci_tree_node.types" title="Associated Types">Associated
- Types</a>
-</h4></div></div></div>
-<p>
- No additional types beyond those defined in the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept; however, the requirements
- for the child iterator types are strengthened:
- </p>
-<pre class="programlisting"><span class="special">*</span> <span class="identifier">Both</span> <span class="identifier">types</span> <span class="identifier">must</span> <span class="identifier">model</span> <span class="identifier">the</span> Random Access Iterator <span class="identifier">concept</span><span class="special">.</span>
-<span class="special">*</span> <span class="identifier">The</span> <span class="identifier">value</span> <span class="identifier">type</span> <span class="identifier">of</span> <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">child_iterator</span><span class="error">`</span> <span class="identifier">must</span> <span class="identifier">be</span> <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span><span class="error">`</span><span class="special">.</span>
-<span class="special">*</span> <span class="identifier">The</span> <span class="identifier">value</span> <span class="identifier">type</span> <span class="identifier">of</span> <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span><span class="error">`</span> <span class="identifier">must</span> <span class="identifier">be</span>
- <span class="error">`</span><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span><span class="error">`</span><span class="special">.</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="tree_node.concepts.raci_tree_node.expressions"></a><a class="link" href="raci_tree_node.html#tree_node.concepts.raci_tree_node.expressions" title="Valid Expressions and Semantics">Valid
- Expressions and Semantics</a>
-</h4></div></div></div>
-<p>
- In addition to the expressions defined in the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept, the following expressions
- must be valid.
- </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
- <p>
- Name
- </p>
- </th>
-<th>
- <p>
- Expression
- </p>
- </th>
-<th>
- <p>
- Type requirements
- </p>
- </th>
-<th>
- <p>
- Return Type
- </p>
- </th>
-<th>
- <p>
- Semantics
- </p>
- </th>
-<th>
- <p>
- <a href="http://en.wikipedia.org/wiki/Amortized_analysis" target="_top">Runtime
- Complexity</a>
- </p>
- </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
- <p>
- Child creation with data
- </p>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child</span><span class="special">(</span><span class="identifier">data</span><span class="special">)</span></code>
- </p>
- </td>
-<td>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
- </p>
- </td>
-<td>
- <p>
- Creates and returns a tree node to be stored in the range of
- children of the invoking node. The node returned will store the
- specified data.
- </p>
- </td>
-<td>
- <p>
- Amortized constant
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Child creation
- </p>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child</span><span class="special">()</span></code>
- </p>
- </td>
-<td>
- <p>
- The data type of <code class="computeroutput"><span class="identifier">Node</span></code>
- must model the Default Constructible concept.
- </p>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
- </p>
- </td>
-<td>
- <p>
- Creates and returns a tree node to be stored in the range of
- children of the invoking node.
- </p>
- </td>
-<td>
- <p>
- Amortized constant
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Child copy creation
- </p>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">add_child</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span></code>
- </p>
- </td>
-<td>
- </td>
-<td>
- <p>
- <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
- </p>
- </td>
-<td>
- <p>
- Creates and returns a deep copy of <code class="computeroutput"><span class="identifier">const_node</span></code>
- to be stored in the range of children of the invoking node.
- </p>
- </td>
-<td>
- <p>
- Linear with respect to the number of descendants of <code class="computeroutput"><span class="identifier">const_node</span></code>
- </p>
- </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="tree_node.concepts.raci_tree_node.models"></a><a class="link" href="raci_tree_node.html#tree_node.concepts.raci_tree_node.models" title="Models">Models</a>
-</h4></div></div></div>
-<pre class="programlisting"><span class="special">*</span> <a class="link" href="../reference/raw_node.html" title="raw_node"><code class="computeroutput"><span class="identifier">raw_node</span></code></a>
-<span class="special">*</span> <a class="link" href="../reference/simple_node.html" title="simple_node"><code class="computeroutput"><span class="identifier">simple_node</span></code></a>
-</pre>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
- Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="associative_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,582 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Tree Node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../concepts.html" title="Concepts">
+<link rel="prev" href="../concepts.html" title="Concepts">
+<link rel="next" href="associative_tree_node.html" title="Associative Tree Node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../concepts.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="associative_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.concepts.tree_node"></a><a class="link" href="tree_node.html" title="Tree Node">Tree Node</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node.description"></a><a class="link" href="tree_node.html#tree_node.concepts.tree_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ All tree node implementations that this library provides model this concept:
+ a structure that maintains information about its data and its immediate
+ parent-child relationships.
+ </p>
+</div>
+<div class="variablelist">
+<p class="title"><b>Notation</b></p>
+<dl>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Node</span></code></span></dt>
+<dd><p>
+ A type that models the <span class="bold"><strong>Tree Node</strong></span> concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">const_node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
+ </p></dd>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node.types"></a><a class="link" href="tree_node.html#tree_node.concepts.tree_node.types" title="Associated Types">Associated Types</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Data type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">data_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of the object stored in a tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Copy Constructible concept, but
+ need not model the Assignable concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a pointer to a <code class="computeroutput"><span class="identifier">Node</span></code>
+ object.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Trivial Iterator concept, it must
+ point to a mutable object, and it must be implicitly convertible
+ to <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer-to-const type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a pointer to a <code class="computeroutput"><span class="identifier">Node</span>
+ <span class="keyword">const</span></code> object.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Trivial Iterator concept, and
+ it must <span class="emphasis"><em>not</em></span> point to a mutable object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of iterator used to iterate through the children of
+ a <code class="computeroutput"><span class="identifier">Node</span></code> object.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Input Iterator concept, and it
+ must be convertible to <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span></code>.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Immutable child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of iterator used to iterate through the children of
+ a <code class="computeroutput"><span class="identifier">Node</span> <span class="keyword">const</span></code>
+ object.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node.expressions"></a><a class="link" href="tree_node.html#tree_node.concepts.tree_node.expressions" title="Valid Expressions and Semantics">Valid Expressions
+ and Semantics</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Return Type
+ </p>
+ </th>
+<th>
+ <p>
+ Semantics
+ </p>
+ </th>
+<th>
+ <p>
+ <a href="http://en.wikipedia.org/wiki/Amortized_analysis" target="_top">Runtime
+ Complexity</a>
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">get_data</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Data</span> <span class="keyword">const</span><span class="special">&amp;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns the object stored in the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">get_data</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Data</span><span class="special">&amp;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns the object stored in the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">get_parent</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns the parent of the tree node, or a null pointer if the
+ node is the root.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">get_parent</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns the parent of the tree node, or a null pointer if the
+ node is the root.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">get_child_begin</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns an iterator pointing to the beginning of the range of
+ children of the tree node. If the range is empty, then the iterator
+ points past-the-end.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">get_child_begin</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns an iterator pointing to the beginning of the range of
+ children of the tree node. If the range is empty, then the iterator
+ points past-the-end.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">get_child_end</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns an iterator pointing past the end of the range of children
+ of the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">get_child_end</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns an iterator pointing past the end of the range of children
+ of the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_node</span><span class="special">-&gt;</span><span class="identifier">get_children</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;Node::const_child_iterator,Node::const_child_iterator&gt;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns a pair <code class="computeroutput"><span class="identifier">p</span></code>
+ such that <code class="computeroutput"><span class="special">[</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span><span class="special">)</span></code> is the range of children of
+ the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">get_children</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;Node::child_iterator,Node::child_iterator&gt;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns a pair <code class="computeroutput"><span class="identifier">p</span></code>
+ such that <code class="computeroutput"><span class="special">[</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span><span class="special">)</span></code> is the range of children of
+ the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove all children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">node</span><span class="special">-&gt;</span><span class="identifier">remove_all_children</span><span class="special">()</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Removes all children from the tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ Linear with respect to the number of children and its descendants
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node.models"></a><a class="link" href="tree_node.html#tree_node.concepts.tree_node.models" title="Models">Models</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <span class="identifier">All</span> <span class="identifier">models</span> <span class="identifier">of</span> <span class="identifier">the</span> <a class="link" href="associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> <span class="identifier">concept</span><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">All</span> <span class="identifier">models</span> <span class="identifier">of</span> <span class="identifier">the</span> <a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a> <span class="identifier">concept</span><span class="special">.</span>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../concepts.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="associative_tree_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node_desc_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node_desc_iterator.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,204 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Tree Node Descendant Iterator</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../concepts.html" title="Concepts">
+<link rel="prev" href="full_tree_node_iterator.html" title="Full Tree Node Iterator">
+<link rel="next" href="../reference.html" title="Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="full_tree_node_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.concepts.tree_node_desc_iterator"></a><a class="link" href="tree_node_desc_iterator.html" title="Tree Node Descendant Iterator">Tree Node
+ Descendant Iterator</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_desc_iterator.description"></a><a class="link" href="tree_node_desc_iterator.html#tree_node.concepts.tree_node_desc_iterator.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This concept may seem redundant at first, especially when iterating through
+ <a class="link" href="non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative
+ Tree Node</strong></span></a> objects; however, for <a class="link" href="associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> objects, models of
+ this concept provide the sole means of accessing the key associated with
+ each node being traversed. (Root nodes are not associated with keys at
+ the tree node level, so models of this concept do not traverse them.)
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_desc_iterator.refinement_of"></a><a class="link" href="tree_node_desc_iterator.html#tree_node.concepts.tree_node_desc_iterator.refinement_of" title="Refinement of">Refinement
+ of</a>
+</h4></div></div></div>
+<p>
+ <a class="link" href="tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree
+ Node Iterator</strong></span></a>
+ </p>
+</div>
+<div class="variablelist">
+<p class="title"><b>Notation</b></p>
+<dl>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Iterator</span></code></span></dt>
+<dd><p>
+ A type that models the <span class="bold"><strong>Tree Node Descendant Iterator</strong></span>
+ concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">itr</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Iterator</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Node</span></code></span></dt>
+<dd><p>
+ A type that models the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">const_node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
+ </p></dd>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_desc_iterator.types"></a><a class="link" href="tree_node_desc_iterator.html#tree_node.concepts.tree_node_desc_iterator.types" title="Associated Types">Associated
+ Types</a>
+</h4></div></div></div>
+<p>
+ No additional types beyond those defined in the <a class="link" href="tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a> concept; however, the
+ requirements for the value type are strengthened: its value type, in turn,
+ must model the Forward Iterator concept.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_desc_iterator.expressions"></a><a class="link" href="tree_node_desc_iterator.html#tree_node.concepts.tree_node_desc_iterator.expressions" title="Valid Expressions and Semantics">Valid
+ Expressions and Semantics</a>
+</h4></div></div></div>
+<p>
+ None beyond those defined in the <a class="link" href="tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a> concept; however, the
+ type requirements for the constructors are strengthened, and their semantics
+ are clarified.
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Type requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Semantics
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Constructor from mutable node
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">Iterator</span><span class="special">(</span><span class="identifier">node</span><span class="special">)</span>
+<span class="identifier">Iterator</span> <span class="identifier">itr</span><span class="special">(</span><span class="identifier">node</span><span class="special">)</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ Constructs an iterator that will iterate through the descendants
+ of the specified node.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from immutable node
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">Iterator</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span>
+<span class="identifier">Iterator</span> <span class="identifier">itr</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ The value type of <code class="computeroutput"><span class="identifier">Iterator</span></code>
+ must be the value type of <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_child_iterator</span></code>.
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs an iterator that will iterate through the descendants
+ of the specified node.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_desc_iterator.models"></a><a class="link" href="tree_node_desc_iterator.html#tree_node.concepts.tree_node_desc_iterator.models" title="Models">Models</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/breadth_first_iterator.html" title="breadth_first_iterator"><code class="computeroutput"><span class="identifier">make_breadth_first_descendant_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/pre_order_iterator.html" title="pre_order_iterator"><code class="computeroutput"><span class="identifier">make_pre_order_descendant_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/post_order_iterator.html" title="post_order_iterator"><code class="computeroutput"><span class="identifier">make_post_order_descendant_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">The</span> <span class="keyword">return</span> <span class="identifier">type</span> <span class="identifier">of</span> <a class="link" href="../reference/depth_first_iterator.html" title="depth_first_iterator"><code class="computeroutput"><span class="identifier">make_depth_first_descendant_iterator</span><span class="special">()</span></code></a><span class="special">.</span>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="full_tree_node_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/concepts/tree_node_iterator.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,274 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Tree Node Iterator</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../concepts.html" title="Concepts">
+<link rel="prev" href="nary_tree_node.html" title="N-ary Tree Node">
+<link rel="next" href="full_tree_node_iterator.html" title="Full Tree Node Iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="nary_tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="full_tree_node_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.concepts.tree_node_iterator"></a><a class="link" href="tree_node_iterator.html" title="Tree Node Iterator">Tree Node Iterator</a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_iterator.description"></a><a class="link" href="tree_node_iterator.html#tree_node.concepts.tree_node_iterator.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ Tree-traversing iterators at the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> level must be created differently
+ from iterators at the Container level. Furthermore, tree node
+ iterators typically store more stateful information than their Container counterparts; requiring two of
+ them to check for dereferenceability may prove somewhat memory-inefficient.
+ This concept provides an alternate means of checking for dereferenceability
+ that requires the use of only the active iterator.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_iterator.refinement_of"></a><a class="link" href="tree_node_iterator.html#tree_node.concepts.tree_node_iterator.refinement_of" title="Refinement of">Refinement
+ of</a>
+</h4></div></div></div>
+<p>
+ Forward Iterator
+ </p>
+</div>
+<div class="variablelist">
+<p class="title"><b>Notation</b></p>
+<dl>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Iterator</span></code></span></dt>
+<dd><p>
+ A type that models the <span class="bold"><strong>Tree Node Iterator</strong></span>
+ concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">itr</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Iterator</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">Node</span></code></span></dt>
+<dd><p>
+ A type that models the <a class="link" href="tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">pointer</span></code>.
+ </p></dd>
+<dt><span class="term"><code class="computeroutput"><span class="identifier">const_node</span></code></span></dt>
+<dd><p>
+ An object of type <code class="computeroutput"><span class="identifier">Node</span><span class="special">::</span><span class="identifier">const_pointer</span></code>.
+ </p></dd>
+</dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_iterator.types"></a><a class="link" href="tree_node_iterator.html#tree_node.concepts.tree_node_iterator.types" title="Associated Types">Associated
+ Types</a>
+</h4></div></div></div>
+<p>
+ No additional types beyond those defined in the Forward Iterator concept; however, the requirements
+ for the value type are strengthened: it must model the Trivial Iterator concept.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_iterator.expressions"></a><a class="link" href="tree_node_iterator.html#tree_node.concepts.tree_node_iterator.expressions" title="Valid Expressions and Semantics">Valid
+ Expressions and Semantics</a>
+</h4></div></div></div>
+<p>
+ In addition to the expressions defined in the Forward Iterator concept, the following
+ expressions must be valid.
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Return Type
+ </p>
+ </th>
+<th>
+ <p>
+ Semantics
+ </p>
+ </th>
+<th>
+ <p>
+ <a href="http://en.wikipedia.org/wiki/Amortized_analysis" target="_top">Runtime
+ Complexity</a>
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">Iterator</span><span class="special">()</span>
+<span class="identifier">Iterator</span> <span class="identifier">itr</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ Constructs a non-dereferenceable (past-the-end) iterator.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from mutable node
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">Iterator</span><span class="special">(</span><span class="identifier">node</span><span class="special">)</span>
+<span class="identifier">Iterator</span> <span class="identifier">itr</span><span class="special">(</span><span class="identifier">node</span><span class="special">)</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ Refinement-specific.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from immutable node
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">Iterator</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span>
+<span class="identifier">Iterator</span> <span class="identifier">itr</span><span class="special">(</span><span class="identifier">const_node</span><span class="special">)</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ <p>
+ Refinement-specific.
+ </p>
+ </td>
+<td>
+ <p>
+ Amortized constant
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Dereferenceability
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">itr</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ A type that can be used in a boolean context.
+ </p>
+ </td>
+<td>
+ <p>
+ Returns a value convertible to <code class="computeroutput"><span class="keyword">true</span></code>
+ if <code class="computeroutput"><span class="identifier">itr</span></code> is dereferenceable,
+ a value convertible to <code class="computeroutput"><span class="keyword">false</span></code>
+ if it is past-the-end.
+ </p>
+ </td>
+<td>
+ <p>
+ Constant
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ The Forward Iterator requirement that the increment
+ operators must exhibit constant time complexity has been relaxed; they
+ now need only exhibit linear time complexity with respect to the number
+ of descendants in the worst case.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.concepts.tree_node_iterator.models"></a><a class="link" href="tree_node_iterator.html#tree_node.concepts.tree_node_iterator.models" title="Models">Models</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <span class="identifier">All</span> <span class="identifier">models</span> <span class="identifier">of</span> <span class="identifier">the</span> <a class="link" href="full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a> <span class="identifier">concept</span><span class="special">.</span>
+<span class="special">*</span> <span class="identifier">All</span> <span class="identifier">models</span> <span class="identifier">of</span> <span class="identifier">the</span> <a class="link" href="tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a> <span class="identifier">concept</span><span class="special">.</span>
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="nary_tree_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="full_tree_node_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,48 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Reference</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="prev" href="concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator">
+<link rel="next" href="reference/raw_binary_node.html" title="raw_binary_node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="concepts/tree_node_desc_iterator.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="reference/raw_binary_node.html"><img src="../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="tree_node.reference"></a><a class="link" href="reference.html" title="Reference">Reference</a>
+</h2></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="reference/raw_binary_node.html" title="raw_binary_node"><code class="computeroutput"><span class="identifier">raw_binary_node</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/raw_node.html" title="raw_node"><code class="computeroutput"><span class="identifier">raw_node</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/simple_node.html" title="simple_node"><code class="computeroutput"><span class="identifier">simple_node</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/raw_associative_node.html" title="raw_associative_node"><code class="computeroutput"><span class="identifier">raw_associative_node</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/simple_associative_node.html" title="simple_associative_node"><code class="computeroutput"><span class="identifier">simple_associative_node</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/breadth_first_iterator.html" title="breadth_first_iterator"><code class="computeroutput"><span class="identifier">breadth_first_iterator</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/pre_order_iterator.html" title="pre_order_iterator"><code class="computeroutput"><span class="identifier">pre_order_iterator</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/post_order_iterator.html" title="post_order_iterator"><code class="computeroutput"><span class="identifier">post_order_iterator</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/depth_first_iterator.html" title="depth_first_iterator"><code class="computeroutput"><span class="identifier">depth_first_iterator</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/in_order_iterator.html" title="in_order_iterator"><code class="computeroutput"><span class="identifier">in_order_iterator</span></code></a>
+<span class="special">*</span> <a class="link" href="reference/traversal_state.html" title="traversal_state"><code class="computeroutput"><span class="identifier">traversal_state</span></code></a>
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="concepts/tree_node_desc_iterator.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="reference/raw_binary_node.html"><img src="../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/breadth_first_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/breadth_first_iterator.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,747 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>breadth_first_iterator</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="simple_associative_node.html" title="simple_associative_node">
+<link rel="next" href="pre_order_iterator.html" title="pre_order_iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="simple_associative_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="pre_order_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.breadth_first_iterator"></a><a class="link" href="breadth_first_iterator.html" title="breadth_first_iterator"><code class="computeroutput"><span class="identifier">breadth_first_iterator</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.breadth_first_iterator.synopsis"></a><a class="link" href="breadth_first_iterator.html#tree_node.reference.breadth_first_iterator.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MimicsChildIterator</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">breadth_first_iterator</span>
+ <span class="special">{</span>
+
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">value_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;</span>
+ <span class="identifier">reference</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span>
+ <span class="identifier">difference_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward_iterator_tag</span>
+ <span class="identifier">iterator_category</span><span class="special">;</span>
+
+ <span class="identifier">breadth_first_iterator</span><span class="special">();</span>
+
+ <span class="keyword">explicit</span> <span class="identifier">breadth_first_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI</span><span class="special">&gt;</span>
+ <span class="identifier">breadth_first_iterator</span><span class="special">(</span>
+ <span class="identifier">breadth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">,</span><span class="identifier">MCI</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">other</span>
+ <span class="special">);</span>
+
+ <span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">breadth_first_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span>
+
+ <span class="identifier">breadth_first_iterator</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span>
+
+ <span class="keyword">operator</span> <span class="identifier">traversal_state</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.breadth_first_iterator.description"></a><a class="link" href="breadth_first_iterator.html#tree_node.reference.breadth_first_iterator.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This iterator traverses the specified root node and all its descendants
+ in breadth-first fashion, e.g. given the following tree representation:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"> <span class="identifier">A</span>
+ <span class="special">|</span>
+ <span class="identifier">C</span><span class="special">---+---</span><span class="identifier">B</span>
+ <span class="special">|</span> <span class="special">|</span>
+<span class="special">+-+-+</span> <span class="special">+-+-+</span>
+<span class="special">|</span> <span class="special">|</span> <span class="special">|</span> <span class="special">|</span>
+<span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+<p>
+ If this iterator is a <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a>, then it will traverse
+ the tree nodes in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">A</span> <span class="identifier">C</span> <span class="identifier">B</span> <span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+<p>
+ If this iterator is a <a class="link" href="../concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a>, then it will
+ traverse the tree nodes in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">C</span> <span class="identifier">B</span> <span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.breadth_first_iterator.definition"></a><a class="link" href="breadth_first_iterator.html#tree_node.reference.breadth_first_iterator.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/breadth_first_iterator.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.breadth_first_iterator.tpl_param"></a><a class="link" href="breadth_first_iterator.html#tree_node.reference.breadth_first_iterator.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">NodePointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a pointer to a tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Trivial Iterator concept, and
+ its value type must model the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">MimicsChildIterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type that determines whether this <code class="computeroutput"><span class="identifier">breadth_first_iterator</span></code>
+ will iterate only through the descendants of a node or will also
+ include the node in its traversal.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Boolean Integral Constant concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.breadth_first_iterator.model_of"></a><a class="link" href="breadth_first_iterator.html#tree_node.reference.breadth_first_iterator.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a> <span class="keyword">if</span> <span class="error">`</span><span class="identifier">MimicsChildIterator</span><span class="special">::</span><span class="identifier">value</span><span class="error">`</span> <span class="identifier">is</span> <span class="error">`</span><span class="keyword">false</span><span class="error">`</span>
+<span class="special">*</span> <a class="link" href="../concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a> <span class="keyword">if</span> <span class="error">`</span><span class="identifier">MimicsChildIterator</span><span class="special">::</span><span class="identifier">value</span><span class="error">`</span> <span class="identifier">is</span> <span class="error">`</span><span class="keyword">true</span><span class="error">`</span>
+<span class="special">*</span> Default Constructible
+<span class="special">*</span> Copy Constructible
+<span class="special">*</span> Assignable
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.breadth_first_iterator.public_bases"></a><a class="link" href="breadth_first_iterator.html#tree_node.reference.breadth_first_iterator.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ None.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.breadth_first_iterator.members"></a><a class="link" href="breadth_first_iterator.html#tree_node.reference.breadth_first_iterator.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Where defined
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Value type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">value_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Reference type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Difference type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">difference_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iterator category
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">iterator_category</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">breadth_first_iterator</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Default Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from im/mutable node
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">breadth_first_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Conversion constructor
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI</span><span class="special">&gt;</span>
+<span class="identifier">breadth_first_iterator</span><span class="special">(</span><span class="identifier">breadth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">,</span><span class="identifier">MCI</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">breadth_first_iterator</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Copy constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">breadth_first_iterator</span><span class="special">(</span><span class="identifier">breadth_first_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Copy Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Assignment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">breadth_first_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">breadth_first_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Assignable
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Dereference operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Indirection operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pre-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">breadth_first_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Post-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">breadth_first_iterator</span>
+ <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Traversal state conversion operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">operator</span> <a class="link" href="traversal_state.html" title="traversal_state">traversal_state</a><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.breadth_first_iterator.non_members"></a><a class="link" href="breadth_first_iterator.html#tree_node.reference.breadth_first_iterator.non_members" title="Non-members">Non-members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">breadth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span><span class="special">&gt;</span>
+ <span class="identifier">make_breadth_first_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">breadth_first_iterator</span></code>
+ that will iterate through the specified node and its descendants.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Descendant iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">breadth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span><span class="special">&gt;</span>
+ <span class="identifier">make_breadth_first_descendant_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">breadth_first_iterator</span></code>
+ that will iterate through the descendants of the specified node.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span>
+ <span class="identifier">breadth_first_iterate</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the specified node and its descendants in breadth-first
+ fashion, passing each node pointer dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Descendant iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span>
+ <span class="identifier">breadth_first_iterate_descendants</span><span class="special">(</span>
+ <span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span>
+ <span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the descendants of the specified node in breadth-first
+ fashion, passing each element dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Equality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+ <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">==(</span>
+ <span class="identifier">breadth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">breadth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Inequality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+ <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">!=(</span>
+ <span class="identifier">breadth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">breadth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="simple_associative_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="pre_order_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/depth_first_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/depth_first_iterator.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,804 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>depth_first_iterator</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="post_order_iterator.html" title="post_order_iterator">
+<link rel="next" href="in_order_iterator.html" title="in_order_iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="post_order_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="in_order_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.depth_first_iterator"></a><a class="link" href="depth_first_iterator.html" title="depth_first_iterator"><code class="computeroutput"><span class="identifier">depth_first_iterator</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.depth_first_iterator.synopsis"></a><a class="link" href="depth_first_iterator.html#tree_node.reference.depth_first_iterator.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MimicsChildIterator</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">depth_first_iterator</span>
+ <span class="special">{</span>
+
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">value_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;</span>
+ <span class="identifier">reference</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span>
+ <span class="identifier">difference_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward_iterator_tag</span>
+ <span class="identifier">iterator_category</span><span class="special">;</span>
+
+ <span class="identifier">depth_first_iterator</span><span class="special">();</span>
+
+ <span class="keyword">explicit</span> <span class="identifier">depth_first_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI</span><span class="special">&gt;</span>
+ <span class="identifier">depth_first_iterator</span><span class="special">(</span>
+ <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">,</span><span class="identifier">MCI</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">other</span>
+ <span class="special">);</span>
+
+ <span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">depth_first_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span>
+
+ <span class="identifier">depth_first_iterator</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span>
+
+ <span class="keyword">operator</span> <span class="identifier">traversal_state</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="special">};</span>
+
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+ <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">==(</span>
+ <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+ <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">!=(</span>
+ <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span><span class="special">&gt;</span>
+ <span class="identifier">make_depth_first_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span><span class="special">&gt;</span>
+ <span class="identifier">make_depth_first_descendant_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">BinaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span> <span class="identifier">depth_first_iterate</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">,</span> <span class="identifier">BinaryFunction</span> <span class="identifier">function</span><span class="special">);</span>
+
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">BinaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span>
+ <span class="identifier">depth_first_iterate_descendants</span><span class="special">(</span>
+ <span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span>
+ <span class="special">,</span> <span class="identifier">BinaryFunction</span> <span class="identifier">function</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.depth_first_iterator.description"></a><a class="link" href="depth_first_iterator.html#tree_node.reference.depth_first_iterator.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This iterator traverses the specified root node and all its descendants
+ in depth-first fashion, e.g. given the following tree representation:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"> <span class="identifier">A</span>
+ <span class="special">|</span>
+ <span class="identifier">C</span><span class="special">---+---</span><span class="identifier">B</span>
+ <span class="special">|</span> <span class="special">|</span>
+<span class="special">+-+-+</span> <span class="special">+-+-+</span>
+<span class="special">|</span> <span class="special">|</span> <span class="special">|</span> <span class="special">|</span>
+<span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+<p>
+ If this iterator is a <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a>, then it will traverse
+ the tree nodes in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">A</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">C</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">D</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">D</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">E</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">E</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">C</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">B</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">F</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">F</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">G</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">G</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">B</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">A</span> <span class="identifier">post_order_traversal</span>
+</pre>
+<p>
+ </p>
+<p>
+ If this iterator is a <a class="link" href="../concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a>, then it will
+ traverse the tree nodes in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">C</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">D</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">D</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">E</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">E</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">C</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">B</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">F</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">F</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">G</span> <span class="identifier">pre_order_traversal</span>
+<span class="identifier">G</span> <span class="identifier">post_order_traversal</span>
+<span class="identifier">B</span> <span class="identifier">post_order_traversal</span>
+</pre>
+<p>
+ </p>
+<p>
+ The traversal state conversion operator of this iterator will yield each
+ value in the column on the right at the appropriate iteration.
+ </p>
+<p>
+ This iterator is ideal for algorithms that need to perform both preprocessing
+ and postprocessing of a tree node, e.g. the copy constructors of the <a class="link" href="raw_node.html" title="raw_node"><code class="computeroutput"><span class="identifier">raw_node</span></code></a>
+ and <a class="link" href="raw_associative_node.html" title="raw_associative_node"><code class="computeroutput"><span class="identifier">raw_associative_node</span></code></a> implementations.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.depth_first_iterator.definition"></a><a class="link" href="depth_first_iterator.html#tree_node.reference.depth_first_iterator.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/depth_first_iterator.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.depth_first_iterator.tpl_param"></a><a class="link" href="depth_first_iterator.html#tree_node.reference.depth_first_iterator.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">NodePointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a pointer to a tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Trivial Iterator concept, and
+ its value type must model the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">MimicsChildIterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type that determines whether this <code class="computeroutput"><span class="identifier">depth_first_iterator</span></code>
+ will iterate only through the descendants of a node or will also
+ include the node in its traversal.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Boolean Integral Constant concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.depth_first_iterator.model_of"></a><a class="link" href="depth_first_iterator.html#tree_node.reference.depth_first_iterator.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a> <span class="keyword">if</span> <span class="error">`</span><span class="identifier">MimicsChildIterator</span><span class="special">::</span><span class="identifier">value</span><span class="error">`</span> <span class="identifier">is</span> <span class="error">`</span><span class="keyword">false</span><span class="error">`</span>
+<span class="special">*</span> <a class="link" href="../concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a> <span class="keyword">if</span> <span class="error">`</span><span class="identifier">MimicsChildIterator</span><span class="special">::</span><span class="identifier">value</span><span class="error">`</span> <span class="identifier">is</span> <span class="error">`</span><span class="keyword">true</span><span class="error">`</span>
+<span class="special">*</span> Default Constructible
+<span class="special">*</span> Copy Constructible
+<span class="special">*</span> Assignable
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.depth_first_iterator.public_bases"></a><a class="link" href="depth_first_iterator.html#tree_node.reference.depth_first_iterator.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ None.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.depth_first_iterator.members"></a><a class="link" href="depth_first_iterator.html#tree_node.reference.depth_first_iterator.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Value type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">value_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Reference type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Forward Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Forward Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Distance type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">difference_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Forward Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iterator category
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">iterator_category</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Forward Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">depth_first_iterator</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Default Constructible concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from im/mutable node
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">depth_first_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Conversion constructor
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI</span><span class="special">&gt;</span>
+<span class="identifier">depth_first_iterator</span><span class="special">(</span><span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">,</span><span class="identifier">MCI</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs a <code class="computeroutput"><span class="identifier">depth_first_iterator</span></code>
+ object that will point to the same element that the specified
+ iterator points to.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Copy constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">depth_first_iterator</span><span class="special">(</span><span class="identifier">depth_first_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Copy Constructible concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Assignment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">depth_first_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">depth_first_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Assignable concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Dereference operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Forward Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Indirection operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Forward Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pre-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">depth_first_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Forward Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Post-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">depth_first_iterator</span>
+ <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined in the Forward Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Traversal state conversion operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">operator</span> <a class="link" href="traversal_state.html" title="traversal_state">traversal_state</a><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Returns <code class="computeroutput"><span class="identifier">pre_order_traversal</span></code>
+ if this iterator has not yet examined the children of the current
+ node, <code class="computeroutput"><span class="identifier">post_order_traversal</span></code>
+ if this iterator has examined all of the children of the current
+ node, or <code class="computeroutput"><span class="identifier">no_traversal</span></code>
+ if this iterator is not dereferenceable.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.depth_first_iterator.non_members"></a><a class="link" href="depth_first_iterator.html#tree_node.reference.depth_first_iterator.non_members" title="Non-members">Non-members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+<span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,</span>boost::mpl::false_<span class="special">&gt;</span>
+ <span class="identifier">make_depth_first_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">depth_first_iterator</span></code>
+ that will iterate through the specified node and its descendants.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Descendant iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+<span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,</span>boost::mpl::true_<span class="special">&gt;</span>
+ <span class="identifier">make_depth_first_descendant_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">depth_first_iterator</span></code>
+ that will iterate through the descendants of the specified node.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+<span class="keyword">void</span>
+ <span class="identifier">depth_first_iterate</span><span class="special">(</span>
+ <span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span>
+ <span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span>
+ <span class="special">);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the specified node and its descendants in depth-first
+ fashion, passing each node pointer dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Descendant iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+<span class="keyword">void</span>
+ <span class="identifier">depth_first_iterate_descendants</span><span class="special">(</span>
+ <span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span>
+ <span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span>
+ <span class="special">);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the descendants of the specified node in depth-first
+ fashion, passing each element dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Equality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+<span class="keyword">typename</span> enable_if<span class="special">&lt;</span>boost::mpl::equal_to<span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">==(</span>
+ <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span>
+ <span class="special">,</span> <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span>
+ <span class="special">);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Inequality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+<span class="keyword">typename</span> enable_if<span class="special">&lt;</span>boost::mpl::equal_to<span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">!=(</span>
+ <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span>
+ <span class="special">,</span> <span class="identifier">depth_first_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span>
+ <span class="special">);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="post_order_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="in_order_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/in_order_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/in_order_iterator.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,767 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>in_order_iterator</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="depth_first_iterator.html" title="depth_first_iterator">
+<link rel="next" href="traversal_state.html" title="traversal_state">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="depth_first_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="traversal_state.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.in_order_iterator"></a><a class="link" href="in_order_iterator.html" title="in_order_iterator"><code class="computeroutput"><span class="identifier">in_order_iterator</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.in_order_iterator.synopsis"></a><a class="link" href="in_order_iterator.html#tree_node.reference.in_order_iterator.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">in_order_iterator</span>
+ <span class="special">{</span>
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="identifier">NodePointer</span> <span class="identifier">value_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">reference</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">bidirectional_iterator_tag</span> <span class="identifier">iterator_category</span><span class="special">;</span>
+
+ <span class="identifier">in_order_iterator</span><span class="special">();</span>
+
+ <span class="identifier">in_order_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">start_left</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">);</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">&gt;</span>
+ <span class="identifier">in_order_iterator</span><span class="special">(</span>
+ <span class="identifier">in_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">other</span>
+ <span class="special">);</span>
+
+ <span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">in_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span>
+
+ <span class="identifier">in_order_iterator</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span>
+
+ <span class="identifier">in_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">--();</span>
+
+ <span class="identifier">in_order_iterator</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">);</span>
+
+ <span class="keyword">operator</span> <span class="identifier">traversal_state</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.in_order_iterator.description"></a><a class="link" href="in_order_iterator.html#tree_node.reference.in_order_iterator.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This iterator traverses the specified root node and all its descendants
+ in in-order fashion, e.g. given the following tree representation:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"> <span class="identifier">A</span>
+ <span class="special">|</span>
+ <span class="identifier">C</span><span class="special">---+---</span><span class="identifier">B</span>
+ <span class="special">|</span> <span class="special">|</span>
+<span class="special">+-+-+</span> <span class="special">+-+-+</span>
+<span class="special">|</span> <span class="special">|</span> <span class="special">|</span> <span class="special">|</span>
+<span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+<p>
+ The tree nodes will be traversed forward in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">D</span> <span class="identifier">C</span> <span class="identifier">E</span> <span class="identifier">A</span> <span class="identifier">F</span> <span class="identifier">B</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+<p>
+ This iterator can also be used to traverse the tree nodes <span class="emphasis"><em>backwards</em></span>:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">G</span> <span class="identifier">B</span> <span class="identifier">F</span> <span class="identifier">A</span> <span class="identifier">E</span> <span class="identifier">C</span> <span class="identifier">D</span>
+</pre>
+<p>
+ </p>
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ This iterator works only on <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a> models.
+ </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.in_order_iterator.definition"></a><a class="link" href="in_order_iterator.html#tree_node.reference.in_order_iterator.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/in_order_iterator.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.in_order_iterator.tpl_param"></a><a class="link" href="in_order_iterator.html#tree_node.reference.in_order_iterator.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">NodePointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a pointer to a tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Trivial Iterator concept, and
+ its value type must model the <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr></tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.in_order_iterator.model_of"></a><a class="link" href="in_order_iterator.html#tree_node.reference.in_order_iterator.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a>
+<span class="special">*</span> Bidirectional Iterator
+<span class="special">*</span> Default Constructible
+<span class="special">*</span> Copy Constructible
+<span class="special">*</span> Assignable
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.in_order_iterator.public_bases"></a><a class="link" href="in_order_iterator.html#tree_node.reference.in_order_iterator.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ None.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.in_order_iterator.members"></a><a class="link" href="in_order_iterator.html#tree_node.reference.in_order_iterator.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Where defined
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Value type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">value_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Reference type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Distance type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">difference_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iterator category
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">iterator_category</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Default Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from im/mutable node
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Conversion constructor
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">&gt;</span>
+<span class="identifier">in_order_iterator</span><span class="special">(</span><span class="identifier">in_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Copy constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span><span class="special">(</span><span class="identifier">in_order_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Copy Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Assignment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">in_order_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Assignable
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Dereference operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Indirection operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pre-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Post-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pre-decrement operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">--();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Reverse Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Post-decrement operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">in_order_iterator</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Reverse Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Traversal state conversion operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">operator</span> <a class="link" href="traversal_state.html" title="traversal_state">traversal_state</a><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.in_order_iterator.non_members"></a><a class="link" href="in_order_iterator.html#tree_node.reference.in_order_iterator.non_members" title="Non-members">Non-members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Forward Iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">in_order_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">make_in_order_forward_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">in_order_iterator</span></code>
+ that will iterate forward through the specified node and its
+ descendants.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Reverse iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">in_order_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">make_in_order_reverse_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">in_order_iterator</span></code>
+ that will iterate in reverse through the specified node and its
+ descendants.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Forward iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span>
+ <span class="identifier">in_order_iterate_forward</span><span class="special">(</span>
+ <span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span>
+ <span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the specified node and its descendants in forward
+ in-order fashion, passing each node pointer dereferenced to the
+ specified Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Reverse iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span>
+ <span class="identifier">in_order_iterate_reverse</span><span class="special">(</span>
+ <span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span>
+ <span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the specified node and its descendants in reverse
+ in-order fashion, passing each element dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Equality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">&gt;</span>
+ <span class="keyword">bool</span>
+ <span class="keyword">operator</span><span class="special">==(</span>
+ <span class="identifier">in_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">in_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Inequality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">&gt;</span>
+ <span class="keyword">bool</span>
+ <span class="keyword">operator</span><span class="special">!=(</span>
+ <span class="identifier">in_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">in_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="depth_first_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="traversal_state.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/post_order_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/post_order_iterator.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,746 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>post_order_iterator</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="pre_order_iterator.html" title="pre_order_iterator">
+<link rel="next" href="depth_first_iterator.html" title="depth_first_iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="pre_order_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="depth_first_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.post_order_iterator"></a><a class="link" href="post_order_iterator.html" title="post_order_iterator"><code class="computeroutput"><span class="identifier">post_order_iterator</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.post_order_iterator.synopsis"></a><a class="link" href="post_order_iterator.html#tree_node.reference.post_order_iterator.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MimicsChildIterator</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">post_order_iterator</span>
+ <span class="special">{</span>
+
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">value_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;</span>
+ <span class="identifier">reference</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span>
+ <span class="identifier">difference_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward_iterator_tag</span>
+ <span class="identifier">iterator_category</span><span class="special">;</span>
+
+ <span class="identifier">post_order_iterator</span><span class="special">();</span>
+
+ <span class="keyword">explicit</span> <span class="identifier">post_order_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI</span><span class="special">&gt;</span>
+ <span class="identifier">post_order_iterator</span><span class="special">(</span>
+ <span class="identifier">post_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">,</span><span class="identifier">MCI</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">other</span>
+ <span class="special">);</span>
+
+ <span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">post_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span>
+
+ <span class="identifier">post_order_iterator</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span>
+
+ <span class="keyword">operator</span> <span class="identifier">traversal_state</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.post_order_iterator.description"></a><a class="link" href="post_order_iterator.html#tree_node.reference.post_order_iterator.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This iterator traverses the specified root node and all its descendants
+ in post-order fashion, e.g. given the following tree representation:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"> <span class="identifier">A</span>
+ <span class="special">|</span>
+ <span class="identifier">C</span><span class="special">---+---</span><span class="identifier">B</span>
+ <span class="special">|</span> <span class="special">|</span>
+<span class="special">+-+-+</span> <span class="special">+-+-+</span>
+<span class="special">|</span> <span class="special">|</span> <span class="special">|</span> <span class="special">|</span>
+<span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+<p>
+ If this iterator is a <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a>, then it will traverse
+ the tree nodes in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">C</span> <span class="identifier">F</span> <span class="identifier">G</span> <span class="identifier">B</span> <span class="identifier">A</span>
+</pre>
+<p>
+ </p>
+<p>
+ If this iterator is a <a class="link" href="../concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a>, then it will
+ traverse the tree nodes in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">C</span> <span class="identifier">F</span> <span class="identifier">G</span> <span class="identifier">B</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.post_order_iterator.definition"></a><a class="link" href="post_order_iterator.html#tree_node.reference.post_order_iterator.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/post_order_iterator.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.post_order_iterator.tpl_param"></a><a class="link" href="post_order_iterator.html#tree_node.reference.post_order_iterator.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">NodePointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a pointer to a tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Trivial Iterator concept, and
+ its value type must model the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">MimicsChildIterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type that determines whether this <code class="computeroutput"><span class="identifier">post_order_iterator</span></code>
+ will iterate only through the descendants of a node or will also
+ include the node in its traversal.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Boolean Integral Constant concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.post_order_iterator.model_of"></a><a class="link" href="post_order_iterator.html#tree_node.reference.post_order_iterator.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a> <span class="keyword">if</span> <span class="error">`</span><span class="identifier">MimicsChildIterator</span><span class="special">::</span><span class="identifier">value</span><span class="error">`</span> <span class="identifier">is</span> <span class="error">`</span><span class="keyword">false</span><span class="error">`</span>
+<span class="special">*</span> <a class="link" href="../concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a> <span class="keyword">if</span> <span class="error">`</span><span class="identifier">MimicsChildIterator</span><span class="special">::</span><span class="identifier">value</span><span class="error">`</span> <span class="identifier">is</span> <span class="error">`</span><span class="keyword">true</span><span class="error">`</span>
+<span class="special">*</span> Default Constructible
+<span class="special">*</span> Copy Constructible
+<span class="special">*</span> Assignable
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.post_order_iterator.public_bases"></a><a class="link" href="post_order_iterator.html#tree_node.reference.post_order_iterator.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ None.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.post_order_iterator.members"></a><a class="link" href="post_order_iterator.html#tree_node.reference.post_order_iterator.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Where defined
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Value type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">value_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Reference type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Distance type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">difference_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iterator category
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">iterator_category</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">post_order_iterator</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Default Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from im/mutable node
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">post_order_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Conversion constructor
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI</span><span class="special">&gt;</span>
+<span class="identifier">post_order_iterator</span><span class="special">(</span><span class="identifier">post_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">,</span><span class="identifier">MCI</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">post_order_iterator</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Copy constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">post_order_iterator</span><span class="special">(</span><span class="identifier">post_order_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Copy Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Assignment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">post_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">post_order_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Assignable
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Dereference operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Indirection operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pre-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">post_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Post-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">post_order_iterator</span>
+ <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Traversal state conversion operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">operator</span> <a class="link" href="traversal_state.html" title="traversal_state">traversal_state</a><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.post_order_iterator.non_members"></a><a class="link" href="post_order_iterator.html#tree_node.reference.post_order_iterator.non_members" title="Non-members">Non-members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">post_order_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span><span class="special">&gt;</span>
+ <span class="identifier">make_post_order_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">post_order_iterator</span></code>
+ that will iterate through the specified node and its descendants.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Descendant iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">post_order_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span><span class="special">&gt;</span>
+ <span class="identifier">make_post_order_descendant_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">post_order_iterator</span></code>
+ that will iterate through the descendants of the specified node.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span> <span class="identifier">post_order_iterate</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the specified node and its descendants in post-order
+ fashion, passing each node pointer dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Descendant iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span>
+ <span class="identifier">post_order_iterate_descendants</span><span class="special">(</span>
+ <span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span>
+ <span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the descendants of the specified node in post-order
+ fashion, passing each element dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Equality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+ <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">==(</span>
+ <span class="identifier">post_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">post_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Inequality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+ <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">!=(</span>
+ <span class="identifier">post_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">post_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="pre_order_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="depth_first_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/pre_order_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/pre_order_iterator.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,746 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>pre_order_iterator</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="breadth_first_iterator.html" title="breadth_first_iterator">
+<link rel="next" href="post_order_iterator.html" title="post_order_iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="breadth_first_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="post_order_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.pre_order_iterator"></a><a class="link" href="pre_order_iterator.html" title="pre_order_iterator"><code class="computeroutput"><span class="identifier">pre_order_iterator</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.pre_order_iterator.synopsis"></a><a class="link" href="pre_order_iterator.html#tree_node.reference.pre_order_iterator.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MimicsChildIterator</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">pre_order_iterator</span>
+ <span class="special">{</span>
+
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">value_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;</span>
+ <span class="identifier">reference</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span>
+ <span class="identifier">difference_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward_iterator_tag</span>
+ <span class="identifier">iterator_category</span><span class="special">;</span>
+
+ <span class="identifier">pre_order_iterator</span><span class="special">();</span>
+
+ <span class="keyword">explicit</span> <span class="identifier">pre_order_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI</span><span class="special">&gt;</span>
+ <span class="identifier">pre_order_iterator</span><span class="special">(</span>
+ <span class="identifier">pre_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">,</span><span class="identifier">MCI</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">other</span>
+ <span class="special">);</span>
+
+ <span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pre_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span>
+
+ <span class="identifier">pre_order_iterator</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span>
+
+ <span class="keyword">operator</span> <span class="identifier">traversal_state</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.pre_order_iterator.description"></a><a class="link" href="pre_order_iterator.html#tree_node.reference.pre_order_iterator.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This iterator traverses the specified root node and all its descendants
+ in pre-order fashion, e.g. given the following tree representation:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"> <span class="identifier">A</span>
+ <span class="special">|</span>
+ <span class="identifier">C</span><span class="special">---+---</span><span class="identifier">B</span>
+ <span class="special">|</span> <span class="special">|</span>
+<span class="special">+-+-+</span> <span class="special">+-+-+</span>
+<span class="special">|</span> <span class="special">|</span> <span class="special">|</span> <span class="special">|</span>
+<span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+<p>
+ If this iterator is a <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a>, then it will traverse
+ the tree nodes in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">A</span> <span class="identifier">C</span> <span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">B</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+<p>
+ If this iterator is a <a class="link" href="../concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a>, then it will
+ traverse the tree nodes in the following order:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">C</span> <span class="identifier">D</span> <span class="identifier">E</span> <span class="identifier">B</span> <span class="identifier">F</span> <span class="identifier">G</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.pre_order_iterator.definition"></a><a class="link" href="pre_order_iterator.html#tree_node.reference.pre_order_iterator.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/pre_order_iterator.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.pre_order_iterator.tpl_param"></a><a class="link" href="pre_order_iterator.html#tree_node.reference.pre_order_iterator.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">NodePointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a pointer to a tree node.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Trivial Iterator concept, and
+ its value type must model the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">MimicsChildIterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type that determines whether this <code class="computeroutput"><span class="identifier">pre_order_iterator</span></code>
+ will iterate only through the descendants of a node or will also
+ include the node in its traversal.
+ </p>
+ </td>
+<td>
+ <p>
+ It must model the Boolean Integral Constant concept.
+ </p>
+ </td>
+<td>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.pre_order_iterator.model_of"></a><a class="link" href="pre_order_iterator.html#tree_node.reference.pre_order_iterator.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../concepts/full_tree_node_iterator.html" title="Full Tree Node Iterator"><span class="bold"><strong>Full Tree Node Iterator</strong></span></a> <span class="keyword">if</span> <span class="error">`</span><span class="identifier">MimicsChildIterator</span><span class="special">::</span><span class="identifier">value</span><span class="error">`</span> <span class="identifier">is</span> <span class="error">`</span><span class="keyword">false</span><span class="error">`</span>
+<span class="special">*</span> <a class="link" href="../concepts/tree_node_desc_iterator.html" title="Tree Node Descendant Iterator"><span class="bold"><strong>Tree Node Descendant Iterator</strong></span></a> <span class="keyword">if</span> <span class="error">`</span><span class="identifier">MimicsChildIterator</span><span class="special">::</span><span class="identifier">value</span><span class="error">`</span> <span class="identifier">is</span> <span class="error">`</span><span class="keyword">true</span><span class="error">`</span>
+<span class="special">*</span> Default Constructible
+<span class="special">*</span> Copy Constructible
+<span class="special">*</span> Assignable
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.pre_order_iterator.public_bases"></a><a class="link" href="pre_order_iterator.html#tree_node.reference.pre_order_iterator.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ None.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.pre_order_iterator.members"></a><a class="link" href="pre_order_iterator.html#tree_node.reference.pre_order_iterator.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Where defined
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Value type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">value_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Reference type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Distance type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">difference_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iterator category
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">iterator_category</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pre_order_iterator</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Default Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor from im/mutable node
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pre_order_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Conversion constructor
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI</span><span class="special">&gt;</span>
+<span class="identifier">pre_order_iterator</span><span class="special">(</span><span class="identifier">pre_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP</span><span class="special">,</span><span class="identifier">MCI</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;);</span>
+</pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pre_order_iterator</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Copy constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pre_order_iterator</span><span class="special">(</span><span class="identifier">pre_order_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Copy Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Assignment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pre_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">pre_order_iterator</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Assignable
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Dereference operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Indirection operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pre-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pre_order_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Post-increment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pre_order_iterator</span>
+ <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Forward Iterator
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Traversal state conversion operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">operator</span> <a class="link" href="traversal_state.html" title="traversal_state">traversal_state</a><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node_iterator.html" title="Tree Node Iterator"><span class="bold"><strong>Tree Node Iterator</strong></span></a>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.pre_order_iterator.non_members"></a><a class="link" href="pre_order_iterator.html#tree_node.reference.pre_order_iterator.non_members" title="Non-members">Non-members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">pre_order_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span><span class="special">&gt;</span>
+ <span class="identifier">make_pre_order_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">pre_order_iterator</span></code>
+ that will iterate through the specified node and its descendants.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Descendant iterator creation
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">&gt;</span>
+ <span class="identifier">pre_order_iterator</span><span class="special">&lt;</span><span class="identifier">NodePointer</span><span class="special">,::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span><span class="special">&gt;</span>
+ <span class="identifier">make_pre_order_descendant_iterator</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Constructs and returns a <code class="computeroutput"><span class="identifier">pre_order_iterator</span></code>
+ that will iterate through the descendants of the specified node.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span> <span class="identifier">pre_order_iterate</span><span class="special">(</span><span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span><span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the specified node and its descendants in pre-order
+ fashion, passing each node pointer dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Descendant iteration
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NodePointer</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">UnaryFunction</span><span class="special">&gt;</span>
+ <span class="keyword">void</span>
+ <span class="identifier">pre_order_iterate_descendants</span><span class="special">(</span>
+ <span class="identifier">NodePointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">node</span>
+ <span class="special">,</span> <span class="identifier">UnaryFunction</span> <span class="identifier">function</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Iterates through the descendants of the specified node in pre-order
+ fashion, passing each element dereferenced to the specified
+ Unary Function object.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Equality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+ <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">==(</span>
+ <span class="identifier">pre_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">pre_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Inequality
+ </p>
+ </td>
+<td>
+ <p>
+
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">NP1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">NP2</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">MCI2</span><span class="special">&gt;</span>
+ <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">MCI1</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;,</span><span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="keyword">operator</span><span class="special">!=(</span>
+ <span class="identifier">pre_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP1</span><span class="special">,</span><span class="identifier">MCI1</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">lhs</span>
+ <span class="special">,</span> <span class="identifier">pre_order_iterator</span><span class="special">&lt;</span><span class="identifier">NP2</span><span class="special">,</span><span class="identifier">MCI2</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span>
+ <span class="special">);</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the Input Iterator concept.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="breadth_first_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="post_order_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_associative_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_associative_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,842 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>raw_associative_node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="simple_node.html" title="simple_node">
+<link rel="next" href="simple_associative_node.html" title="simple_associative_node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="simple_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="simple_associative_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.raw_associative_node"></a><a class="link" href="raw_associative_node.html" title="raw_associative_node"><code class="computeroutput"><span class="identifier">raw_associative_node</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_associative_node.synopsis"></a><a class="link" href="raw_associative_node.html#tree_node.reference.raw_associative_node.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span>
+ <span class="keyword">typename</span> <span class="identifier">Key</span>
+ <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Data</span>
+ <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">AssociativeContainerSelector</span> <span class="special">=</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mapS</span>
+ <span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">raw_associative_node</span>
+ <span class="special">{</span>
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="identifier">Key</span>
+ <span class="identifier">key_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">Data</span>
+ <span class="identifier">data_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">raw_associative_node</span><span class="special">*</span>
+ <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">raw_associative_node</span> <span class="keyword">const</span><span class="special">*</span>
+ <span class="identifier">const_pointer</span><span class="special">;</span>
+
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">child_iterator</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">const_child_iterator</span><span class="special">;</span>
+
+ <span class="identifier">raw_associative_node</span><span class="special">();</span>
+
+ <span class="keyword">explicit</span> <span class="identifier">raw_associative_node</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">raw_associative_node</span><span class="special">(</span><span class="identifier">raw_associative_node</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">raw_associative_node</span><span class="special">&amp;</span>
+ <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">raw_associative_node</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="special">~</span><span class="identifier">raw_associative_node</span><span class="special">();</span>
+
+ <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">data_type</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">();</span>
+
+ <span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">,</span> <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">,</span> <span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_child_iterator</span><span class="special">,</span><span class="identifier">const_child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">child_iterator</span><span class="special">,</span><span class="identifier">child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">();</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">);</span>
+
+ <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_child_iterator</span><span class="special">,</span><span class="identifier">const_child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">find_children</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">child_iterator</span><span class="special">,</span><span class="identifier">child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">find_children</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">);</span>
+
+ <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">remove_children</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">);</span>
+
+ <span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span>
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_associative_node.description"></a><a class="link" href="raw_associative_node.html#tree_node.reference.raw_associative_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This class template is suitable for classes or algorithms that need to
+ map keys to child nodes in a tree node data structure that does not need
+ to be exposed to external code. Objects of this type can be stored by value,
+ and their children can be accessed by their associated keys for fast lookup.
+ </p>
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ This component depends on Boost.Utility.ContainerGen, which is not
+ yet a part of Boost. For now, you must perform a Subversion checkout
+ from the SVN Trac.
+ </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_associative_node.definition"></a><a class="link" href="raw_associative_node.html#tree_node.reference.raw_associative_node.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/raw_associative_node.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_associative_node.tpl_param"></a><a class="link" href="raw_associative_node.html#tree_node.reference.raw_associative_node.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Key</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a key object to be associated with a child of a
+ <code class="computeroutput"><span class="identifier">raw_associative_node</span></code>.
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Data</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of the object to be stored in a <code class="computeroutput"><span class="identifier">raw_associative_node</span></code>.
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">AssociativeContainerSelector</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type that determines the internal map types whose mapped
+ types are the same as the pointer type.
+ </p>
+ </td>
+<td>
+ <p>
+ It must be a type for which associative_container_gen
+ returns a valid container.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">mapS</span></code>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_associative_node.model_of"></a><a class="link" href="raw_associative_node.html#tree_node.reference.raw_associative_node.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+<span class="special">*</span> Default Constructible <span class="keyword">if</span> <span class="error">`</span><span class="identifier">Data</span><span class="error">`</span> <span class="identifier">is</span> Default Constructible
+<span class="special">*</span> Copy Constructible
+<span class="special">*</span> Assignable <span class="keyword">if</span> <span class="error">`</span><span class="identifier">Data</span><span class="error">`</span> <span class="identifier">is</span> Assignable
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_associative_node.public_bases"></a><a class="link" href="raw_associative_node.html#tree_node.reference.raw_associative_node.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ None.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_associative_node.members"></a><a class="link" href="raw_associative_node.html#tree_node.reference.raw_associative_node.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Where defined
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Key type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">key_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer-to-const type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Immutable child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_associative_node</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Default Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">explicit</span> <span class="identifier">raw_associative_node</span><span class="special">(</span><span class="identifier">data_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_associative_node</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Copy constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_associative_node</span><span class="special">(</span><span class="identifier">raw_associative_node</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Copy Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Assignment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_associative_node</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">raw_associative_node</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Assignable
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span><span class="special">&amp;</span>
+ <span class="identifier">get_data</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key_type</span>
+ <span class="keyword">const</span><span class="special">&amp;,</span>
+ <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">key_type</span>
+ <span class="keyword">const</span><span class="special">&amp;,</span>
+ <span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_begin</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_end</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;const_child_iterator,const_child_iterator&gt;
+ get_children() const;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;child_iterator,child_iterator&gt;
+ get_children();</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;const_child_iterator,const_child_iterator&gt;
+ find_children(key_type const&amp;) const;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;child_iterator,child_iterator&gt;
+ find_children(key_type const&amp;);</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">remove_children</span><span class="special">(</span><span class="identifier">key_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove all children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_associative_node.example"></a><a class="link" href="raw_associative_node.html#tree_node.reference.raw_associative_node.example" title="Example">Example</a>
+</h4></div></div></div>
+<p>
+ &lt;example/raw_associative_node.cpp&gt;
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="simple_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="simple_associative_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_binary_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_binary_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,871 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>raw_binary_node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="../reference.html" title="Reference">
+<link rel="next" href="raw_node.html" title="raw_node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../reference.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="raw_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.raw_binary_node"></a><a class="link" href="raw_binary_node.html" title="raw_binary_node"><code class="computeroutput"><span class="identifier">raw_binary_node</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_binary_node.synopsis"></a><a class="link" href="raw_binary_node.html#tree_node.reference.raw_binary_node.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">raw_binary_node</span>
+ <span class="special">{</span>
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="identifier">T</span>
+ <span class="identifier">data_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">raw_binary_node</span><span class="special">*</span>
+ <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">raw_binary_node</span> <span class="keyword">const</span><span class="special">*</span>
+ <span class="identifier">const_pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">child_iterator</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">const_child_iterator</span><span class="special">;</span>
+
+ <span class="identifier">raw_binary_node</span><span class="special">();</span>
+
+ <span class="keyword">explicit</span> <span class="identifier">raw_binary_node</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">raw_binary_node</span><span class="special">(</span><span class="identifier">raw_binary_node</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">raw_binary_node</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">raw_binary_node</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="special">~</span><span class="identifier">raw_binary_node</span><span class="special">();</span>
+
+ <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">data_type</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">();</span>
+
+ <span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_left_child</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_left_child</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_left_child_copy</span><span class="special">(</span><span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_right_child</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_right_child</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_right_child_copy</span><span class="special">(</span><span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">const_pointer</span> <span class="identifier">get_left_child</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">get_left_child</span><span class="special">();</span>
+
+ <span class="identifier">const_pointer</span> <span class="identifier">get_right_child</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">get_right_child</span><span class="special">();</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_child_iterator</span><span class="special">,</span><span class="identifier">const_child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">child_iterator</span><span class="special">,</span><span class="identifier">child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">rotate_left</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">rotate_right</span><span class="special">();</span>
+
+ <span class="keyword">void</span> <span class="identifier">remove_left_child</span><span class="special">();</span>
+
+ <span class="keyword">void</span> <span class="identifier">remove_right_child</span><span class="special">();</span>
+
+ <span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span>
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_binary_node.description"></a><a class="link" href="raw_binary_node.html#tree_node.reference.raw_binary_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This class template is suitable for classes or algorithms that require
+ a binary tree node data structure but do not need to expose it to external
+ code. Objects of this type can be stored by value.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_binary_node.definition"></a><a class="link" href="raw_binary_node.html#tree_node.reference.raw_binary_node.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/raw_binary_node.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_binary_node.tpl_param"></a><a class="link" href="raw_binary_node.html#tree_node.reference.raw_binary_node.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">T</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of the object to be stored in a <code class="computeroutput"><span class="identifier">raw_binary_node</span></code>.
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ </td>
+</tr></tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_binary_node.model_of"></a><a class="link" href="raw_binary_node.html#tree_node.reference.raw_binary_node.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+<span class="special">*</span> Default Constructible <span class="keyword">if</span> <span class="error">`</span><span class="identifier">T</span><span class="error">`</span> <span class="identifier">is</span> Default Constructible
+<span class="special">*</span> Copy Constructible
+<span class="special">*</span> Assignable <span class="keyword">if</span> <span class="error">`</span><span class="identifier">T</span><span class="error">`</span> <span class="identifier">is</span> Assignable
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_binary_node.public_bases"></a><a class="link" href="raw_binary_node.html#tree_node.reference.raw_binary_node.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ None.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_binary_node.members"></a><a class="link" href="raw_binary_node.html#tree_node.reference.raw_binary_node.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Where defined
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Data type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer-to-const type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Immutable child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_binary_node</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Default Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">explicit</span> <span class="identifier">raw_binary_node</span><span class="special">(</span><span class="identifier">data_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_binary_node</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Copy constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_binary_node</span><span class="special">(</span><span class="identifier">raw_binary_node</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Copy Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Assignment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_binary_node</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">raw_binary_node</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Assignable
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span><span class="special">&amp;</span>
+ <span class="identifier">get_data</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_left_child</span><span class="special">(</span><span class="identifier">data_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_left_child</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_left_child_copy</span><span class="special">(</span><span class="identifier">const_pointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_right_child</span><span class="special">(</span><span class="identifier">data_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_right_child</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_right_child_copy</span><span class="special">(</span><span class="identifier">const_pointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span> <span class="identifier">get_left_child</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Left child access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">get_left_child</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span> <span class="identifier">get_right_child</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Right child access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">get_right_child</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_begin</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_end</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;const_child_iterator,const_child_iterator&gt;
+ get_children() const;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;child_iterator,child_iterator&gt;
+ get_children();</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Rotate left
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">rotate_left</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Rotate right
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">rotate_right</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove left child
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">remove_left_child</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove right child
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">remove_right_child</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/binary_tree_node.html" title="Binary Tree Node"><span class="bold"><strong>Binary Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove all children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_binary_node.example"></a><a class="link" href="raw_binary_node.html#tree_node.reference.raw_binary_node.example" title="Example">Example</a>
+</h4></div></div></div>
+<p>
+ &lt;example/raw_binary_node.cpp&gt;
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../reference.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="raw_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/raw_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,697 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>raw_node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="raw_binary_node.html" title="raw_binary_node">
+<link rel="next" href="simple_node.html" title="simple_node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="raw_binary_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="simple_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.raw_node"></a><a class="link" href="raw_node.html" title="raw_node"><code class="computeroutput"><span class="identifier">raw_node</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_node.synopsis"></a><a class="link" href="raw_node.html#tree_node.reference.raw_node.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Selector</span> <span class="special">=</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">dequeS</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">raw_node</span>
+ <span class="special">{</span>
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="identifier">T</span>
+ <span class="identifier">data_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">raw_node</span><span class="special">*</span>
+ <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">raw_node</span> <span class="keyword">const</span><span class="special">*</span>
+ <span class="identifier">const_pointer</span><span class="special">;</span>
+
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">child_iterator</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">const_child_iterator</span><span class="special">;</span>
+
+ <span class="identifier">raw_node</span><span class="special">();</span>
+
+ <span class="keyword">explicit</span> <span class="identifier">raw_node</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">raw_node</span><span class="special">(</span><span class="identifier">raw_node</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">raw_node</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">raw_node</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="special">~</span><span class="identifier">raw_node</span><span class="special">();</span>
+
+ <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">data_type</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">();</span>
+
+ <span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_child_iterator</span><span class="special">,</span><span class="identifier">const_child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">child_iterator</span><span class="special">,</span><span class="identifier">child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">();</span>
+
+ <span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span>
+
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_node.description"></a><a class="link" href="raw_node.html#tree_node.reference.raw_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This class template is suitable for classes or algorithms that require
+ a tree node data structure that can handle an arbitrary number of children
+ but does not need to be exposed to external code. Objects of this type
+ can be stored by value.
+ </p>
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ This component depends on Boost.Utility.ContainerGen, which is not
+ yet a part of Boost. For now, you must perform a Subversion checkout
+ from the SVN Trac.
+ </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_node.definition"></a><a class="link" href="raw_node.html#tree_node.reference.raw_node.definition" title="Where defined">Where defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/raw_node.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_node.tpl_param"></a><a class="link" href="raw_node.html#tree_node.reference.raw_node.tpl_param" title="Template Parameters">Template Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">T</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of the object to be stored in a <code class="computeroutput"><span class="identifier">raw_node</span></code>.
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Selector</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type that determines the internal container types whose value
+ types are the same as the pointer type.
+ </p>
+ </td>
+<td>
+ <p>
+ It must be a type for which container_gen returns
+ a valid container.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">dequeS</span></code>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_node.model_of"></a><a class="link" href="raw_node.html#tree_node.reference.raw_node.model_of" title="Model of">Model of</a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="special">*</span> <a class="link" href="../concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary Tree Node</strong></span></a>
+<span class="special">*</span> Default Constructible <span class="keyword">if</span> <span class="error">`</span><span class="identifier">T</span><span class="error">`</span> <span class="identifier">is</span> Default Constructible
+<span class="special">*</span> Copy Constructible
+<span class="special">*</span> Assignable <span class="keyword">if</span> <span class="error">`</span><span class="identifier">T</span><span class="error">`</span> <span class="identifier">is</span> Assignable
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_node.public_bases"></a><a class="link" href="raw_node.html#tree_node.reference.raw_node.public_bases" title="Public Base Classes">Public Base
+ Classes</a>
+</h4></div></div></div>
+<p>
+ None.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_node.members"></a><a class="link" href="raw_node.html#tree_node.reference.raw_node.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Where defined
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Data type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer-to-const type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Immutable child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Default constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_node</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Default Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Constructor with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">explicit</span> <span class="identifier">raw_node</span><span class="special">(</span><span class="identifier">data_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_node</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Copy constructor
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_node</span><span class="special">(</span><span class="identifier">raw_node</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Copy Constructible
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Assignment operator
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">raw_node</span><span class="special">&amp;</span>
+ <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">raw_node</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Assignable
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span><span class="special">&amp;</span>
+ <span class="identifier">get_data</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">data_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary
+ Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary
+ Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">const_pointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary
+ Tree Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_begin</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_end</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;const_child_iterator,const_child_iterator&gt;
+ get_children() const;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;child_iterator,child_iterator&gt;
+ get_children();</code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove all children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree
+ Node</strong></span></a>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.raw_node.example"></a><a class="link" href="raw_node.html#tree_node.reference.raw_node.example" title="Example">Example</a>
+</h4></div></div></div>
+<p>
+ &lt;example/raw_node.cpp&gt;
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="raw_binary_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="simple_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/simple_associative_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/simple_associative_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,816 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>simple_associative_node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="raw_associative_node.html" title="raw_associative_node">
+<link rel="next" href="breadth_first_iterator.html" title="breadth_first_iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="raw_associative_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="breadth_first_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.simple_associative_node"></a><a class="link" href="simple_associative_node.html" title="simple_associative_node"><code class="computeroutput"><span class="identifier">simple_associative_node</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_associative_node.synopsis"></a><a class="link" href="simple_associative_node.html#tree_node.reference.simple_associative_node.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span>
+ <span class="keyword">typename</span> <span class="identifier">Key</span>
+ <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Data</span>
+ <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">AssociativeContainerSelector</span> <span class="special">=</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mapS</span>
+ <span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">simple_associative_node</span>
+ <span class="special">:</span> <span class="keyword">public</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">enable_shared_from_this</span><span class="special">&lt;</span>
+ <span class="identifier">simple_associative_node</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span><span class="identifier">Data</span><span class="special">,</span><span class="identifier">AssociativeContainerSelector</span><span class="special">&gt;</span>
+ <span class="special">&gt;</span>
+ <span class="special">,</span> <span class="keyword">private</span> <span class="identifier">noncopyable</span>
+ <span class="special">{</span>
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="identifier">Key</span>
+ <span class="identifier">key_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="identifier">Data</span>
+ <span class="identifier">data_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">simple_associative_node</span><span class="special">&gt;</span>
+ <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">simple_associative_node</span> <span class="keyword">const</span><span class="special">&gt;</span>
+ <span class="identifier">const_pointer</span><span class="special">;</span>
+
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">child_iterator</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">const_child_iterator</span><span class="special">;</span>
+
+ <span class="special">~</span><span class="identifier">simple_associative_node</span><span class="special">();</span>
+
+ <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">data_type</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">();</span>
+
+ <span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">,</span> <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">,</span> <span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_child_iterator</span><span class="special">,</span><span class="identifier">const_child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">child_iterator</span><span class="special">,</span><span class="identifier">child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">();</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">);</span>
+
+ <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_child_iterator</span><span class="special">,</span><span class="identifier">const_child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">find_children</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">child_iterator</span><span class="special">,</span><span class="identifier">child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">find_children</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">);</span>
+
+ <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">remove_children</span><span class="special">(</span><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">key</span><span class="special">);</span>
+
+ <span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span>
+
+ <span class="keyword">static</span> <span class="identifier">pointer</span> <span class="identifier">create</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="keyword">static</span> <span class="identifier">pointer</span> <span class="identifier">create</span><span class="special">();</span>
+
+ <span class="keyword">static</span> <span class="identifier">pointer</span> <span class="identifier">create_copy</span><span class="special">(</span><span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">);</span>
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_associative_node.description"></a><a class="link" href="simple_associative_node.html#tree_node.reference.simple_associative_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This class template is suitable for classes or algorithms that need to
+ map keys to child nodes in a tree node data structure that must be exposed
+ to external code. Objects of this type must be stored by <code class="computeroutput"><span class="identifier">simple_associative_node</span><span class="special">::</span><span class="identifier">pointer</span></code> and can only be instantiated
+ through the <code class="computeroutput"><span class="keyword">static</span></code> creation
+ methods that this class template provides. Their children can be accessed
+ by their associated keys for fast lookup.
+ </p>
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ This component depends on Boost.Utility.ContainerGen, which is not
+ yet a part of Boost. For now, you must perform a Subversion checkout
+ from the SVN Trac.
+ </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_associative_node.definition"></a><a class="link" href="simple_associative_node.html#tree_node.reference.simple_associative_node.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/simple_associative_node.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_associative_node.tpl_param"></a><a class="link" href="simple_associative_node.html#tree_node.reference.simple_associative_node.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Key</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of a key object to be associated with a child of a
+ <code class="computeroutput"><span class="identifier">simple_associative_node</span></code>.
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Data</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of the object to be stored in a <code class="computeroutput"><span class="identifier">simple_associative_node</span></code>.
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">AssociativeContainerSelector</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type that determines the internal map types whose mapped
+ types are the same as the pointer type.
+ </p>
+ </td>
+<td>
+ <p>
+ It must be a type for which associative_container_gen
+ returns a valid container.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">mapS</span></code>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_associative_node.model_of"></a><a class="link" href="simple_associative_node.html#tree_node.reference.simple_associative_node.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<p>
+ <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative
+ Tree Node</strong></span></a>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_associative_node.public_bases"></a><a class="link" href="simple_associative_node.html#tree_node.reference.simple_associative_node.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ std::tr1::enable_shared_from_this
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_associative_node.members"></a><a class="link" href="simple_associative_node.html#tree_node.reference.simple_associative_node.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Key type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">key_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer-to-const type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Immutable child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Node creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">static</span> <span class="identifier">pointer</span>
+ <span class="identifier">create</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates a <code class="computeroutput"><span class="identifier">simple_associative_node</span></code>
+ object with the specified data and returns a pointer to it.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Node creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">static</span> <span class="identifier">pointer</span>
+ <span class="identifier">create</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates a <code class="computeroutput"><span class="identifier">simple_associative_node</span></code>
+ object and returns a pointer to it.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Node copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">static</span> <span class="identifier">pointer</span>
+ <span class="identifier">create_copy</span><span class="special">(</span><span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates a deep copy of the specified node. Returns a pointer
+ to the new node.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span><span class="special">&amp;</span>
+ <span class="identifier">get_data</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key_type</span>
+ <span class="keyword">const</span><span class="special">&amp;,</span>
+ <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">key_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">key_type</span>
+ <span class="keyword">const</span><span class="special">&amp;,</span>
+ <span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_begin</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_end</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;const_child_iterator,const_child_iterator&gt;
+ get_children() const;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;child_iterator,child_iterator&gt;
+ get_children();</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">find_child</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;const_child_iterator,const_child_iterator&gt;
+ find_children(key_type const&amp;) const;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child search range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;child_iterator,child_iterator&gt;
+ find_children(key_type const&amp;);</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">remove_children</span><span class="special">(</span><span class="identifier">key_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/associative_tree_node.html" title="Associative Tree Node"><span class="bold"><strong>Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove all children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_associative_node.example"></a><a class="link" href="simple_associative_node.html#tree_node.reference.simple_associative_node.example" title="Example">Example</a>
+</h4></div></div></div>
+<p>
+ &lt;example/simple_associative_node.cpp&gt;
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="raw_associative_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="breadth_first_iterator.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/simple_node.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/simple_node.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,669 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>simple_node</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="raw_node.html" title="raw_node">
+<link rel="next" href="raw_associative_node.html" title="raw_associative_node">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="raw_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="raw_associative_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.simple_node"></a><a class="link" href="simple_node.html" title="simple_node"><code class="computeroutput"><span class="identifier">simple_node</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_node.synopsis"></a><a class="link" href="simple_node.html#tree_node.reference.simple_node.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Selector</span> <span class="special">=</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">dequeS</span><span class="special">&gt;</span>
+ <span class="keyword">class</span> <span class="identifier">simple_node</span>
+ <span class="special">:</span> <span class="keyword">public</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">enable_shared_from_this</span><span class="special">&lt;</span><span class="identifier">simple_node</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span>
+ <span class="special">,</span> <span class="keyword">private</span> <span class="identifier">noncopyable</span>
+ <span class="special">{</span>
+ <span class="keyword">public</span><span class="special">:</span>
+ <span class="keyword">typedef</span> <span class="identifier">T</span>
+ <span class="identifier">data_type</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">simple_node</span><span class="special">&gt;</span>
+ <span class="identifier">pointer</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">simple_node</span> <span class="keyword">const</span><span class="special">&gt;</span>
+ <span class="identifier">const_pointer</span><span class="special">;</span>
+
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">child_iterator</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="comment">// implementation_defined
+</span> <span class="identifier">const_child_iterator</span><span class="special">;</span>
+
+ <span class="special">~</span><span class="identifier">simple_node</span><span class="special">();</span>
+
+ <span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">data_type</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">();</span>
+
+ <span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">();</span>
+
+ <span class="identifier">pointer</span> <span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">copy</span><span class="special">);</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span>
+
+ <span class="identifier">const_child_iterator</span> <span class="identifier">get_child_end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_child_iterator</span><span class="special">,</span><span class="identifier">const_child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">child_iterator</span><span class="special">,</span><span class="identifier">child_iterator</span><span class="special">&gt;</span>
+ <span class="identifier">get_children</span><span class="special">();</span>
+
+ <span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span>
+
+ <span class="keyword">static</span> <span class="identifier">pointer</span> <span class="identifier">create</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">);</span>
+
+ <span class="keyword">static</span> <span class="identifier">pointer</span> <span class="identifier">create</span><span class="special">();</span>
+
+ <span class="keyword">static</span> <span class="identifier">pointer</span> <span class="identifier">create_copy</span><span class="special">(</span><span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">);</span>
+
+ <span class="special">};</span>
+
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_node.description"></a><a class="link" href="simple_node.html#tree_node.reference.simple_node.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This class template is suitable for classes or algorithms that require
+ a tree node data structure that can handle an arbitrary number of children
+ and must be exposed to external code. Objects of this type must be stored
+ by <code class="computeroutput"><span class="identifier">simple_node</span><span class="special">::</span><span class="identifier">pointer</span></code> and can only be instantiated
+ through the <code class="computeroutput"><span class="keyword">static</span></code> creation
+ methods that this class template provides.
+ </p>
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+ This component depends on Boost.Utility.ContainerGen, which is not
+ yet a part of Boost. For now, you must perform a Subversion checkout
+ from the SVN Trac.
+ </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_node.definition"></a><a class="link" href="simple_node.html#tree_node.reference.simple_node.definition" title="Where defined">Where defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/simple_node.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_node.tpl_param"></a><a class="link" href="simple_node.html#tree_node.reference.simple_node.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+<th>
+ <p>
+ Requirements
+ </p>
+ </th>
+<th>
+ <p>
+ Default
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">T</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type of the object to be stored in a <code class="computeroutput"><span class="identifier">simple_node</span></code>.
+ </p>
+ </td>
+<td>
+ </td>
+<td>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">Selector</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ The type that determines the internal container types whose value
+ types are the same as the pointer type.
+ </p>
+ </td>
+<td>
+ <p>
+ It must be a type for which container_gen returns
+ a valid container.
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">dequeS</span></code>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_node.model_of"></a><a class="link" href="simple_node.html#tree_node.reference.simple_node.model_of" title="Model of">Model of</a>
+</h4></div></div></div>
+<p>
+ <a class="link" href="../concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary
+ Tree Node</strong></span></a>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_node.public_bases"></a><a class="link" href="simple_node.html#tree_node.reference.simple_node.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+<p>
+ std::tr1::enable_shared_from_this
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_node.members"></a><a class="link" href="simple_node.html#tree_node.reference.simple_node.members" title="Members">Members</a>
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Name
+ </p>
+ </th>
+<th>
+ <p>
+ Expression
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Data type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Pointer-to-const type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Immutable child iterator type
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/non_assoc_tree_node.html" title="Non-Associative Tree Node"><span class="bold"><strong>Non-Associative Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Node creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">static</span> <span class="identifier">pointer</span>
+ <span class="identifier">create</span><span class="special">(</span><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates a <code class="computeroutput"><span class="identifier">simple_node</span></code>
+ object with the specified data and returns a pointer to it.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Node creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">static</span> <span class="identifier">pointer</span>
+ <span class="identifier">create</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates a <code class="computeroutput"><span class="identifier">simple_node</span></code>
+ object and returns a pointer to it.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Node copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">static</span> <span class="identifier">pointer</span>
+ <span class="identifier">create_copy</span><span class="special">(</span><span class="identifier">const_pointer</span> <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Creates a deep copy of the specified node. Returns a pointer
+ to the new node.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Data access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">data_type</span><span class="special">&amp;</span>
+ <span class="identifier">get_data</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_pointer</span> <span class="identifier">get_parent</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Parent access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">get_parent</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation with data
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">(</span><span class="identifier">data_type</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Child copy creation
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">pointer</span> <span class="identifier">add_child_copy</span><span class="special">(</span><span class="identifier">const_pointer</span>
+ <span class="keyword">const</span><span class="special">&amp;);</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/nary_tree_node.html" title="N-ary Tree Node"><span class="bold"><strong>N-ary Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_begin</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range begin access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_begin</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">const_child_iterator</span>
+ <span class="identifier">get_child_end</span><span class="special">()</span>
+ <span class="keyword">const</span><span class="special">;</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range past-the-end access
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="identifier">child_iterator</span> <span class="identifier">get_child_end</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;const_child_iterator,const_child_iterator&gt;
+ get_children() const;</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Children range
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="literal">std::pair&lt;child_iterator,child_iterator&gt;
+ get_children();</code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Remove all children
+ </p>
+ </td>
+<td>
+ <p>
+ <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">remove_all_children</span><span class="special">();</span></code>
+ </p>
+ </td>
+<td>
+ <p>
+ Defined by the <a class="link" href="../concepts/tree_node.html" title="Tree Node"><span class="bold"><strong>Tree Node</strong></span></a> concept.
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.simple_node.example"></a><a class="link" href="simple_node.html#tree_node.reference.simple_node.example" title="Example">Example</a>
+</h4></div></div></div>
+<p>
+ &lt;example/simple_node.cpp&gt;
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="raw_node.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="raw_associative_node.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/traversal_state.html
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/html/tree_node/reference/traversal_state.html 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,87 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>traversal_state</title>
+<link rel="stylesheet" href="../../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;tree_node 0.1">
+<link rel="up" href="../reference.html" title="Reference">
+<link rel="prev" href="in_order_iterator.html" title="in_order_iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="in_order_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="tree_node.reference.traversal_state"></a><a class="link" href="traversal_state.html" title="traversal_state"><code class="computeroutput"><span class="identifier">traversal_state</span></code></a>
+</h3></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.traversal_state.synopsis"></a><a class="link" href="traversal_state.html#tree_node.reference.traversal_state.synopsis" title="Synopsis">Synopsis</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">tree_node</span> <span class="special">{</span>
+
+ <span class="keyword">enum</span> <span class="identifier">traversal_state</span>
+ <span class="special">{</span>
+ <span class="identifier">no_traversal</span>
+ <span class="special">,</span> <span class="identifier">pre_order_traversal</span>
+ <span class="special">,</span> <span class="identifier">post_order_traversal</span>
+ <span class="special">,</span> <span class="identifier">breadth_first_traversal</span>
+ <span class="special">,</span> <span class="identifier">in_order_traversal</span>
+ <span class="special">};</span>
+<span class="special">}}</span> <span class="comment">// namespace boost::tree_node
+</span></pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.traversal_state.description"></a><a class="link" href="traversal_state.html#tree_node.reference.traversal_state.description" title="Description">Description</a>
+</h4></div></div></div>
+<p>
+ This enumeration type is the return type of the dereferenceability expression
+ defined by each iterator type that this library provides. The <code class="computeroutput"><span class="identifier">no_traversal</span></code> value corresponds to <code class="computeroutput"><span class="keyword">false</span></code> in a boolean context, enabling the
+ iterator types to fulfill their runtime requirements for dereferenceability.
+ The <code class="computeroutput"><span class="identifier">pre_order_traversal</span></code>
+ and <code class="computeroutput"><span class="identifier">post_order_traversal</span></code>
+ values are significant because the <a class="link" href="depth_first_iterator.html" title="depth_first_iterator"><code class="computeroutput"><span class="identifier">depth_first_iterator</span></code></a> traverses
+ each node twice, so algorithms must be able to distinguish which state
+ the iterator is in when it traverses a tree node. The <code class="computeroutput"><span class="identifier">breadth_first_traversal</span></code>
+ and <code class="computeroutput"><span class="identifier">in_order_traversal</span></code>
+ values are defined for completeness.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="tree_node.reference.traversal_state.definition"></a><a class="link" href="traversal_state.html#tree_node.reference.traversal_state.definition" title="Where defined">Where
+ defined</a>
+</h4></div></div></div>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span>boost/tree_node/traversal_state.hpp<span class="special">&gt;</span>
+</pre>
+<p>
+ </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2011 Cromwell D. Enage<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="in_order_iterator.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a>
+</div>
+</body>
+</html>

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_breadth_first_iterator.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_breadth_first_iterator.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,224 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:breadth_first_iterator `breadth_first_iterator`]
-
-[section Synopsis]
-[reference__breadth_first_iterator]
-[endsect]
-
-[section Description]
-This iterator traverses the specified root node and all its descendants in
-breadth-first fashion, e.g. given the following tree representation:
-
-``
- A
- |
- C---+---B
- | |
-+-+-+ +-+-+
-| | | |
-D E F G
-``
-
-If this iterator is a __Full_Tree_Node_Iterator__, then it will traverse the
-tree nodes in the following order:
-
-``
-A C B D E F G
-``
-
-If this iterator is a __Tree_Node_Descendant_Iterator__, then it will traverse
-the tree nodes in the following order:
-
-``
-C B D E F G
-``
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_breadth_first_iterator_hpp__>
-``
-[endsect]
-
-[section:tpl_param Template Parameters]
-[table
- [[Parameter][Description][Requirements][Default]]
- [
- [`NodePointer`]
- [The type of a pointer to a tree node.]
- [
- It must model the __Trivial_Iterator__ concept, and its value type
- must model the __Tree_Node__ concept.
- ]
- []
- ]
- [
- [`MimicsChildIterator`]
- [
- The type that determines whether this `breadth_first_iterator` will
- iterate only through the descendants of a node or will also include
- the node in its traversal.
- ]
- [It must model the __Boolean_Integral_Constant__ concept.]
- []
- ]
-]
-[endsect]
-
-[section:model_of Model of]
-
- * __Full_Tree_Node_Iterator__ if `MimicsChildIterator::value` is `false`
- * __Tree_Node_Descendant_Iterator__ if `MimicsChildIterator::value` is `true`
- * __Default_Constructible__
- * __Copy_Constructible__
- * __Assignable__
-
-[endsect]
-
-[section:public_bases Public Base Classes]
-None.
-[endsect]
-
-[section Members]
-[table
- [[Name][Expression][Where defined]]
- [
- [Value type]
- [`value_type`]
- [__Tree_Node_Iterator__]
- ]
- [
- [Reference type]
- [`reference`]
- [__Forward_Iterator__]
- ]
- [
- [Pointer type]
- [`pointer`]
- [__Forward_Iterator__]
- ]
- [
- [Distance type]
- [`distance`]
- [__Forward_Iterator__]
- ]
- [
- [Iterator category]
- [`iterator_category`]
- [__Forward_Iterator__]
- ]
- [
- [Default constructor]
- [`breadth_first_iterator();`]
- [__Default_Constructible__]
- ]
- [
- [Constructor from im/mutable node]
- [`breadth_first_iterator(NodePointer const&);`]
- [__Tree_Node_Iterator__]
- ]
- [
- [Conversion constructor]
- [``
- template <typename NP, typename MCI>
- breadth_first_iterator(breadth_first_iterator<NP,MCI> const&);
- ``]
- [`breadth_first_iterator`]
- ]
- [
- [Copy constructor]
- [`breadth_first_iterator(breadth_first_iterator const&);`]
- [__Copy_Constructible__]
- ]
- [
- [Assignment operator]
- [`breadth_first_iterator& operator=(breadth_first_iterator const&);`]
- [__Assignable__]
- ]
- [
- [Dereference operator]
- [`reference operator*() const;`]
- [__Forward_Iterator__]
- ]
- [
- [Indirection operator]
- [`pointer operator->() const;`]
- [__Forward_Iterator__]
- ]
- [
- [Pre-increment operator]
- [`breadth_first_iterator& operator++();`]
- [__Forward_Iterator__]
- ]
- [
- [Post-increment operator]
- [`breadth_first_iterator operator++(int);`]
- [__Forward_Iterator__]
- ]
- [
- [Traversal state conversion operator]
- [`operator _traversal_state_() const;`]
- [__Tree_Node_Iterator__]
- ]
-]
-[endsect] [/ Members]
-
-[section:non_members Non-members]
-[table
- [[Name][Expression][Description]]
- [
- [Iterator creation]
- [[reference__make_breadth_first_iterator]]
- [
- Constructs and returns a `breadth_first_iterator` that will iterate
- through the specified node and its descendants.
- ]
- ]
- [
- [Descendant iterator creation]
- [[reference__make_breadth_first_descendant_iterator]]
- [
- Constructs and returns a `breadth_first_iterator` that will iterate
- through the descendants of the specified node.
- ]
- ]
- [
- [Iteration]
- [[reference__breadth_first_iterate]]
- [
- Iterates through the specified node and its descendants in
- breadth-first fashion, passing each node pointer dereferenced to
- the specified __Unary_Function__ object.
- ]
- ]
- [
- [Descendant iteration]
- [[reference__breadth_first_iterate_descendants]]
- [
- Iterates through the descendants of the specified node in
- breadth-first fashion, passing each element dereferenced to
- the specified __Unary_Function__ object.
- ]
- ]
- [
- [Equality]
- [[reference__breadth_first_iterator__operator_equals]]
- [Defined by the __Input_Iterator__ concept.]
- ]
- [
- [Inequality]
- [[reference__breadth_first_iterator__operator_not_equal]]
- [Defined by the __Input_Iterator__ concept.]
- ]
-]
-[endsect] [/ Non-members]
-
-[endsect] [/ breadth_first_iterator]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_depth_first_iterator.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_depth_first_iterator.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,299 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:depth_first_iterator `depth_first_iterator`]
-
-[section Synopsis]
-[reference__depth_first_iterator]
-[endsect]
-
-[section Description]
-This iterator traverses the specified root node and all its descendants in
-depth-first fashion, e.g. given the following tree representation:
-
-``
- A
- |
- C---+---B
- | |
-+-+-+ +-+-+
-| | | |
-D E F G
-``
-
-If this iterator is a __Full_Tree_Node_Iterator__, then it will traverse the
-tree nodes in the following order:
-
-``
-A pre_order_traversal
-C pre_order_traversal
-D pre_order_traversal
-D post_order_traversal
-E pre_order_traversal
-E post_order_traversal
-C post_order_traversal
-B pre_order_traversal
-F pre_order_traversal
-F post_order_traversal
-G pre_order_traversal
-G post_order_traversal
-B post_order_traversal
-A post_order_traversal
-``
-
-If this iterator is a __Tree_Node_Descendant_Iterator__, then it will traverse
-the tree nodes in the following order:
-
-``
-C pre_order_traversal
-D pre_order_traversal
-D post_order_traversal
-E pre_order_traversal
-E post_order_traversal
-C post_order_traversal
-B pre_order_traversal
-F pre_order_traversal
-F post_order_traversal
-G pre_order_traversal
-G post_order_traversal
-B post_order_traversal
-``
-
-The traversal state conversion operator of this iterator will yield each value
-in the column on the right at the appropriate iteration.
-
-This iterator is ideal for algorithms that need to perform both preprocessing
-and postprocessing of a tree node, e.g. the copy constructors of the
-__raw_node__ and __raw_associative_node__ implementations.
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_depth_first_iterator_hpp__>
-``
-[endsect]
-
-[section:tpl_param Template Parameters]
-[table
- [[Parameter][Description][Requirements][Default]]
- [
- [`NodePointer`]
- [The type of a pointer to a tree node.]
- [
- It must model the __Trivial_Iterator__ concept, and its value type
- must model the __Tree_Node__ concept.
- ]
- []
- ]
- [
- [`MimicsChildIterator`]
- [
- The type that determines whether this `depth_first_iterator` will
- iterate only through the descendants of a node or will also include
- the node in its traversal.
- ]
- [It must model the __Boolean_Integral_Constant__ concept.]
- []
- ]
-]
-[endsect]
-
-[section:model_of Model of]
-
- * __Full_Tree_Node_Iterator__ if `MimicsChildIterator::value` is `false`
- * __Tree_Node_Descendant_Iterator__ if `MimicsChildIterator::value` is `true`
- * __Default_Constructible__
- * __Copy_Constructible__
- * __Assignable__
-
-[endsect]
-
-[section:public_bases Public Base Classes]
-None.
-[endsect]
-
-[section Members]
-[table
- [[Name][Expression][Description]]
- [
- [Value type]
- [`value_type`]
- [Defined in the __Tree_Node_Iterator__ concept.]
- ]
- [
- [Reference type]
- [`reference`]
- [Defined in the __Forward_Iterator__ concept.]
- ]
- [
- [Pointer type]
- [`pointer`]
- [Defined in the __Forward_Iterator__ concept.]
- ]
- [
- [Distance type]
- [`distance`]
- [Defined in the __Forward_Iterator__ concept.]
- ]
- [
- [Iterator category]
- [`iterator_category`]
- [Defined in the __Forward_Iterator__ concept.]
- ]
- [
- [Default constructor]
- [`depth_first_iterator();`]
- [Defined in the __Default_Constructible__ concept.]
- ]
- [
- [Constructor from im/mutable node]
- [`depth_first_iterator(NodePointer const&);`]
- [Defined in the __Tree_Node_Iterator__ concept.]
- ]
- [
- [Conversion constructor]
- [``
- template <typename NP, typename MCI>
- depth_first_iterator(depth_first_iterator<NP,MCI> const&);
- ``]
- [
- Constructs a `depth_first_iterator` object that will point to the
- same element that the specified iterator points to.
- ]
- ]
- [
- [Copy constructor]
- [`depth_first_iterator(depth_first_iterator const&);`]
- [Defined in the __Copy_Constructible__ concept.]
- ]
- [
- [Assignment operator]
- [`depth_first_iterator& operator=(depth_first_iterator const&);`]
- [Defined in the __Assignable__ concept.]
- ]
- [
- [Dereference operator]
- [`reference operator*() const;`]
- [Defined in the __Forward_Iterator__ concept.]
- ]
- [
- [Indirection operator]
- [`pointer operator->() const;`]
- [Defined in the __Forward_Iterator__ concept.]
- ]
- [
- [Pre-increment operator]
- [`depth_first_iterator& operator++();`]
- [Defined in the __Forward_Iterator__ concept.]
- ]
- [
- [Post-increment operator]
- [`depth_first_iterator operator++(int);`]
- [Defined in the __Forward_Iterator__ concept.]
- ]
- [
- [Traversal state conversion operator]
- [`operator _traversal_state_() const;`]
- [
- Returns `pre_order_traversal` if this iterator has not yet examined
- the children of the current node, `post_order_traversal` if this
- iterator has examined all of the children of the current node, or
- `no_traversal` if this iterator is not dereferenceable.
- ]
- ]
-]
-[endsect] [/ Members]
-
-[section:non_members Non-members]
-[table
- [[Name][Expression][Description]]
- [
- [Iterator creation]
- [``
- template <typename NodePointer>
- depth_first_iterator<NodePointer,_mpl_false_>
- make_depth_first_iterator(NodePointer const& node);
- ``]
- [
- Constructs and returns a `depth_first_iterator` that will iterate
- through the specified node and its descendants.
- ]
- ]
- [
- [Descendant iterator creation]
- [``
- template <typename NodePointer>
- depth_first_iterator<NodePointer,_mpl_true_>
- make_depth_first_descendant_iterator(NodePointer const& node);
- ``]
- [
- Constructs and returns a `depth_first_iterator` that will iterate
- through the descendants of the specified node.
- ]
- ]
- [
- [Iteration]
- [``
- template <typename NodePointer, typename UnaryFunction>
- void
- depth_first_iterate(
- NodePointer const& node
- , UnaryFunction function
- );
- ``]
- [
- Iterates through the specified node and its descendants in
- depth-first fashion, passing each node pointer dereferenced to
- the specified __Unary_Function__ object.
- ]
- ]
- [
- [Descendant iteration]
- [``
- template <typename NodePointer, typename UnaryFunction>
- void
- depth_first_iterate_descendants(
- NodePointer const& node
- , UnaryFunction function
- );
- ``]
- [
- Iterates through the descendants of the specified node in
- depth-first fashion, passing each element dereferenced to
- the specified __Unary_Function__ object.
- ]
- ]
- [
- [Equality]
- [``
- template <typename NP1, typename NP2, typename MCI1, typename MCI2>
- typename _enable_if_<_mpl_equal_to_<MCI1,MCI2>,bool>::type
- operator==(
- depth_first_iterator<NP1,MCI1> const&
- , depth_first_iterator<NP2,MCI2> const&
- );
- ``]
- [Defined by the __Input_Iterator__ concept.]
- ]
- [
- [Inequality]
- [``
- template <typename NP1, typename NP2, typename MCI1, typename MCI2>
- typename _enable_if_<_mpl_equal_to_<MCI1,MCI2>,bool>::type
- operator!=(
- depth_first_iterator<NP1,MCI1> const&
- , depth_first_iterator<NP2,MCI2> const&
- );
- ``]
- [Defined by the __Input_Iterator__ concept.]
- ]
-]
-[endsect] [/ Non-members]
-
-[endsect] [/ depth_first_iterator]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_post_order_iterator.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_post_order_iterator.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,224 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:post_order_iterator `post_order_iterator`]
-
-[section Synopsis]
-[reference__post_order_iterator]
-[endsect]
-
-[section Description]
-This iterator traverses the specified root node and all its descendants in
-post-order fashion, e.g. given the following tree representation:
-
-``
- A
- |
- C---+---B
- | |
-+-+-+ +-+-+
-| | | |
-D E F G
-``
-
-If this iterator is a __Full_Tree_Node_Iterator__, then it will traverse the
-tree nodes in the following order:
-
-``
-D E C F G B A
-``
-
-If this iterator is a __Tree_Node_Descendant_Iterator__, then it will traverse
-the tree nodes in the following order:
-
-``
-D E C F G B
-``
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_post_order_iterator_hpp__>
-``
-[endsect]
-
-[section:tpl_param Template Parameters]
-[table
- [[Parameter][Description][Requirements][Default]]
- [
- [`NodePointer`]
- [The type of a pointer to a tree node.]
- [
- It must model the __Trivial_Iterator__ concept, and its value type
- must model the __Tree_Node__ concept.
- ]
- []
- ]
- [
- [`MimicsChildIterator`]
- [
- The type that determines whether this `post_order_iterator` will
- iterate only through the descendants of a node or will also include
- the node in its traversal.
- ]
- [It must model the __Boolean_Integral_Constant__ concept.]
- []
- ]
-]
-[endsect]
-
-[section:model_of Model of]
-
- * __Full_Tree_Node_Iterator__ if `MimicsChildIterator::value` is `false`
- * __Tree_Node_Descendant_Iterator__ if `MimicsChildIterator::value` is `true`
- * __Default_Constructible__
- * __Copy_Constructible__
- * __Assignable__
-
-[endsect]
-
-[section:public_bases Public Base Classes]
-None.
-[endsect]
-
-[section Members]
-[table
- [[Name][Expression][Where defined]]
- [
- [Value type]
- [`value_type`]
- [__Tree_Node_Iterator__]
- ]
- [
- [Reference type]
- [`reference`]
- [__Forward_Iterator__]
- ]
- [
- [Pointer type]
- [`pointer`]
- [__Forward_Iterator__]
- ]
- [
- [Distance type]
- [`distance`]
- [__Forward_Iterator__]
- ]
- [
- [Iterator category]
- [`iterator_category`]
- [__Forward_Iterator__]
- ]
- [
- [Default constructor]
- [`post_order_iterator();`]
- [__Default_Constructible__]
- ]
- [
- [Constructor from im/mutable node]
- [`post_order_iterator(NodePointer const&);`]
- [__Tree_Node_Iterator__]
- ]
- [
- [Conversion constructor]
- [``
- template <typename NP, typename MCI>
- post_order_iterator(post_order_iterator<NP,MCI> const&);
- ``]
- [`post_order_iterator`]
- ]
- [
- [Copy constructor]
- [`post_order_iterator(post_order_iterator const&);`]
- [__Copy_Constructible__]
- ]
- [
- [Assignment operator]
- [`post_order_iterator& operator=(post_order_iterator const&);`]
- [__Assignable__]
- ]
- [
- [Dereference operator]
- [`reference operator*() const;`]
- [__Forward_Iterator__]
- ]
- [
- [Indirection operator]
- [`pointer operator->() const;`]
- [__Forward_Iterator__]
- ]
- [
- [Pre-increment operator]
- [`post_order_iterator& operator++();`]
- [__Forward_Iterator__]
- ]
- [
- [Post-increment operator]
- [`post_order_iterator operator++(int);`]
- [__Forward_Iterator__]
- ]
- [
- [Traversal state conversion operator]
- [`operator _traversal_state_() const;`]
- [__Tree_Node_Iterator__]
- ]
-]
-[endsect] [/ Members]
-
-[section:non_members Non-members]
-[table
- [[Name][Expression][Description]]
- [
- [Iterator creation]
- [[reference__make_post_order_iterator]]
- [
- Constructs and returns a `post_order_iterator` that will iterate
- through the specified node and its descendants.
- ]
- ]
- [
- [Descendant iterator creation]
- [[reference__make_post_order_descendant_iterator]]
- [
- Constructs and returns a `post_order_iterator` that will iterate
- through the descendants of the specified node.
- ]
- ]
- [
- [Iteration]
- [[reference__post_order_iterate]]
- [
- Iterates through the specified node and its descendants in
- post-order fashion, passing each node pointer dereferenced to
- the specified __Unary_Function__ object.
- ]
- ]
- [
- [Descendant iteration]
- [[reference__post_order_iterate_descendants]]
- [
- Iterates through the descendants of the specified node in
- post-order fashion, passing each element dereferenced to
- the specified __Unary_Function__ object.
- ]
- ]
- [
- [Equality]
- [[reference__post_order_iterator__operator_equals]]
- [Defined by the __Input_Iterator__ concept.]
- ]
- [
- [Inequality]
- [[reference__post_order_iterator__operator_not_equal]]
- [Defined by the __Input_Iterator__ concept.]
- ]
-]
-[endsect] [/ Non-members]
-
-[endsect] [/ post_order_iterator]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_pre_order_iterator.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_pre_order_iterator.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,224 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:pre_order_iterator `pre_order_iterator`]
-
-[section Synopsis]
-[reference__pre_order_iterator]
-[endsect]
-
-[section Description]
-This iterator traverses the specified root node and all its descendants in
-pre-order fashion, e.g. given the following tree representation:
-
-``
- A
- |
- C---+---B
- | |
-+-+-+ +-+-+
-| | | |
-D E F G
-``
-
-If this iterator is a __Full_Tree_Node_Iterator__, then it will traverse the
-tree nodes in the following order:
-
-``
-A C D E B F G
-``
-
-If this iterator is a __Tree_Node_Descendant_Iterator__, then it will traverse
-the tree nodes in the following order:
-
-``
-C D E B F G
-``
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_pre_order_iterator_hpp__>
-``
-[endsect]
-
-[section:tpl_param Template Parameters]
-[table
- [[Parameter][Description][Requirements][Default]]
- [
- [`NodePointer`]
- [The type of a pointer to a tree node.]
- [
- It must model the __Trivial_Iterator__ concept, and its value type
- must model the __Tree_Node__ concept.
- ]
- []
- ]
- [
- [`MimicsChildIterator`]
- [
- The type that determines whether this `pre_order_iterator` will
- iterate only through the descendants of a node or will also include
- the node in its traversal.
- ]
- [It must model the __Boolean_Integral_Constant__ concept.]
- []
- ]
-]
-[endsect]
-
-[section:model_of Model of]
-
- * __Full_Tree_Node_Iterator__ if `MimicsChildIterator::value` is `false`
- * __Tree_Node_Descendant_Iterator__ if `MimicsChildIterator::value` is `true`
- * __Default_Constructible__
- * __Copy_Constructible__
- * __Assignable__
-
-[endsect]
-
-[section:public_bases Public Base Classes]
-None.
-[endsect]
-
-[section Members]
-[table
- [[Name][Expression][Where defined]]
- [
- [Value type]
- [`value_type`]
- [__Tree_Node_Iterator__]
- ]
- [
- [Reference type]
- [`reference`]
- [__Forward_Iterator__]
- ]
- [
- [Pointer type]
- [`pointer`]
- [__Forward_Iterator__]
- ]
- [
- [Distance type]
- [`distance`]
- [__Forward_Iterator__]
- ]
- [
- [Iterator category]
- [`iterator_category`]
- [__Forward_Iterator__]
- ]
- [
- [Default constructor]
- [`pre_order_iterator();`]
- [__Default_Constructible__]
- ]
- [
- [Constructor from im/mutable node]
- [`pre_order_iterator(NodePointer const&);`]
- [__Tree_Node_Iterator__]
- ]
- [
- [Conversion constructor]
- [``
- template <typename NP, typename MCI>
- pre_order_iterator(pre_order_iterator<NP,MCI> const&);
- ``]
- [`pre_order_iterator`]
- ]
- [
- [Copy constructor]
- [`pre_order_iterator(pre_order_iterator const&);`]
- [__Copy_Constructible__]
- ]
- [
- [Assignment operator]
- [`pre_order_iterator& operator=(pre_order_iterator const&);`]
- [__Assignable__]
- ]
- [
- [Dereference operator]
- [`reference operator*() const;`]
- [__Forward_Iterator__]
- ]
- [
- [Indirection operator]
- [`pointer operator->() const;`]
- [__Forward_Iterator__]
- ]
- [
- [Pre-increment operator]
- [`pre_order_iterator& operator++();`]
- [__Forward_Iterator__]
- ]
- [
- [Post-increment operator]
- [`pre_order_iterator operator++(int);`]
- [__Forward_Iterator__]
- ]
- [
- [Traversal state conversion operator]
- [`operator _traversal_state_() const;`]
- [__Tree_Node_Iterator__]
- ]
-]
-[endsect] [/ Members]
-
-[section:non_members Non-members]
-[table
- [[Name][Expression][Description]]
- [
- [Iterator creation]
- [[reference__make_pre_order_iterator]]
- [
- Constructs and returns a `pre_order_iterator` that will iterate
- through the specified node and its descendants.
- ]
- ]
- [
- [Descendant iterator creation]
- [[reference__make_pre_order_descendant_iterator]]
- [
- Constructs and returns a `pre_order_iterator` that will iterate
- through the descendants of the specified node.
- ]
- ]
- [
- [Iteration]
- [[reference__pre_order_iterate]]
- [
- Iterates through the specified node and its descendants in
- pre-order fashion, passing each node pointer dereferenced to
- the specified __Unary_Function__ object.
- ]
- ]
- [
- [Descendant iteration]
- [[reference__pre_order_iterate_descendants]]
- [
- Iterates through the descendants of the specified node in
- pre-order fashion, passing each element dereferenced to
- the specified __Unary_Function__ object.
- ]
- ]
- [
- [Equality]
- [[reference__pre_order_iterator__operator_equals]]
- [Defined by the __Input_Iterator__ concept.]
- ]
- [
- [Inequality]
- [[reference__pre_order_iterator__operator_not_equal]]
- [Defined by the __Input_Iterator__ concept.]
- ]
-]
-[endsect] [/ Non-members]
-
-[endsect] [/ pre_order_iterator]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_raw_associative_node.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_raw_associative_node.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,232 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:raw_associative_node `raw_associative_node`]
-
-[section Synopsis]
-[reference__raw_associative_node]
-[endsect]
-
-[section Description]
-This class template is suitable for classes or algorithms that need to map keys
-to child nodes in a tree node data structure that does not need to be exposed
-to external code. Objects of this type can be stored by value, and their
-children can be accessed by their associated keys for fast lookup.
-
-[important
- This component depends on __Boost_Utility_ContainerGen__, which is not yet
- a part of Boost. For now, you must perform a Subversion checkout from the
- __SVN_Trac__.
-]
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_raw_associative_node_hpp__>
-``
-[endsect]
-
-[section:tpl_param Template Parameters]
-[table
- [[Parameter][Description][Requirements][Default]]
- [
- [`Key`]
- [
- The type of a key object to be associated with a child of a
- `raw_associative_node`.
- ]
- []
- []
- ]
- [
- [`Data`]
- [The type of the object to be stored in a `raw_associative_node`.]
- []
- []
- ]
- [
- [`AssociativeContainerSelector`]
- [
- The type that determines the internal map types whose mapped types
- are the same as the pointer type.
- ]
- [
- It must be a type for which __associative_container_gen__ returns
- a valid container.
- ]
- [`mapS`]
- ]
-]
-[endsect]
-
-[section:model_of Model of]
-
- * __Associative_Tree_Node__
- * __Default_Constructible__ if `Data` is __Default_Constructible__
- * __Copy_Constructible__
- * __Assignable__ if `Data` is __Assignable__
-
-[endsect]
-
-[section:public_bases Public Base Classes]
-None.
-[endsect]
-
-[section Members]
-[table
- [[Name][Expression][Where defined]]
- [
- [Key type]
- [`key_type`]
- [__Tree_Node__]
- ]
- [
- [Data type]
- [`data_type`]
- [__Tree_Node__]
- ]
- [
- [Pointer type]
- [`pointer`]
- [__Tree_Node__]
- ]
- [
- [Pointer-to-const type]
- [`const_pointer`]
- [__Tree_Node__]
- ]
- [
- [Child iterator type]
- [`child_iterator`]
- [__Associative_Tree_Node__]
- ]
- [
- [Immutable child iterator type]
- [`const_child_iterator`]
- [__Associative_Tree_Node__]
- ]
- [
- [Default constructor]
- [`raw_associative_node();`]
- [__Default_Constructible__]
- ]
- [
- [Constructor with data]
- [`explicit raw_associative_node(data_type const&);`]
- [`raw_associative_node`]
- ]
- [
- [Copy constructor]
- [`raw_associative_node(raw_associative_node const&);`]
- [__Copy_Constructible__]
- ]
- [
- [Assignment operator]
- [`raw_associative_node& operator=(raw_associative_node const&);`]
- [__Assignable__]
- ]
- [
- [Data access]
- [`data_type const& get_data() const;`]
- [__Tree_Node__]
- ]
- [
- [Data access]
- [`data_type& get_data();`]
- [__Tree_Node__]
- ]
- [
- [Parent access]
- [`const_pointer get_parent() const;`]
- [__Tree_Node__]
- ]
- [
- [Parent access]
- [`pointer get_parent();`]
- [__Tree_Node__]
- ]
- [
- [Child creation with data]
- [`pointer add_child(key_type const&, data_type const&);`]
- [__Associative_Tree_Node__]
- ]
- [
- [Child creation]
- [`pointer add_child(key_type const&);`]
- [__Associative_Tree_Node__]
- ]
- [
- [Child copy creation]
- [`pointer add_child(key_type const&, const_pointer const&);`]
- [__Associative_Tree_Node__]
- ]
- [
- [Children range begin access]
- [`const_child_iterator get_child_begin() const;`]
- [__Tree_Node__]
- ]
- [
- [Children range begin access]
- [`child_iterator get_child_begin();`]
- [__Tree_Node__]
- ]
- [
- [Children range past-the-end access]
- [`const_child_iterator get_child_end() const;`]
- [__Tree_Node__]
- ]
- [
- [Children range past-the-end access]
- [`child_iterator get_child_end();`]
- [__Tree_Node__]
- ]
- [
- [Child search]
- [`const_child_iterator find_child(key_type const&) const;`]
- [__Associative_Tree_Node__]
- ]
- [
- [Child search]
- [`child_iterator find_child(key_type const&);`]
- [__Associative_Tree_Node__]
- ]
- [
- [Child search range]
- [
- [^_std_pair_<Node::const_child_iterator,Node::const_child_iterator>
- find_children(key_type const&) const;]
- ]
- [__Associative_Tree_Node__]
- ]
- [
- [Child search range]
- [
- [^_std_pair_<Node::child_iterator,Node::child_iterator>
- find_children(key_type const&);]
- ]
- [__Associative_Tree_Node__]
- ]
- [
- [Remove children]
- [`std::size_t remove_children(key_type const&);`]
- [__Associative_Tree_Node__]
- ]
- [
- [Remove all children]
- [`void remove_all_children();`]
- [__Tree_Node__]
- ]
-]
-[endsect] [/ Members]
-
-[section Example]
-<__example_raw_associative_node_cpp__>
-[endsect]
-
-[endsect] [/ raw_associative_node]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_raw_node.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_raw_node.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,169 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:raw_node `raw_node`]
-
-[section Synopsis]
-[reference__raw_node]
-[endsect]
-
-[section Description]
-This class template is suitable for classes or algorithms that require a tree
-node data structure but do not need to expose it to external code. Objects
-of this type can be stored by value, and their children can be accessed by
-offsetting the start of the range with a numerical index for fast lookup.
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_raw_node_hpp__>
-``
-[endsect]
-
-[section:tpl_param Template Parameters]
-[table
- [[Parameter][Description][Requirements][Default]]
- [
- [`T`]
- [The type of the object to be stored in a `raw_node`.]
- []
- []
- ]
-]
-[endsect]
-
-[section:model_of Model of]
-
- * __Random_Access_Child_Iterator_Tree_Node__
- * __Default_Constructible__ if `T` is __Default_Constructible__
- * __Copy_Constructible__
- * __Assignable__ if `T` is __Assignable__
-
-[endsect]
-
-[section:public_bases Public Base Classes]
-None.
-[endsect]
-
-[section Members]
-[table
- [[Name][Expression][Where defined]]
- [
- [Data type]
- [`data_type`]
- [__Tree_Node__]
- ]
- [
- [Pointer type]
- [`pointer`]
- [__Tree_Node__]
- ]
- [
- [Pointer-to-const type]
- [`const_pointer`]
- [__Tree_Node__]
- ]
- [
- [Child iterator type]
- [`child_iterator`]
- [__Random_Access_Child_Iterator_Tree_Node__]
- ]
- [
- [Immutable child iterator type]
- [`const_child_iterator`]
- [__Random_Access_Child_Iterator_Tree_Node__]
- ]
- [
- [Default constructor]
- [`raw_node();`]
- [__Default_Constructible__]
- ]
- [
- [Constructor with data]
- [`explicit raw_node(data_type const&);`]
- [`raw_node`]
- ]
- [
- [Copy constructor]
- [`raw_node(raw_node const&);`]
- [__Copy_Constructible__]
- ]
- [
- [Assignment operator]
- [`raw_node& operator=(raw_node const&);`]
- [__Assignable__]
- ]
- [
- [Data access]
- [`data_type const& get_data() const;`]
- [__Tree_Node__]
- ]
- [
- [Data access]
- [`data_type& get_data();`]
- [__Tree_Node__]
- ]
- [
- [Parent access]
- [`const_pointer get_parent() const;`]
- [__Tree_Node__]
- ]
- [
- [Parent access]
- [`pointer get_parent();`]
- [__Tree_Node__]
- ]
- [
- [Child creation with data]
- [`pointer add_child(data_type const&);`]
- [__Random_Access_Child_Iterator_Tree_Node__]
- ]
- [
- [Child creation]
- [`pointer add_child();`]
- [__Random_Access_Child_Iterator_Tree_Node__]
- ]
- [
- [Child copy creation]
- [`pointer add_child(const_pointer const&);`]
- [__Random_Access_Child_Iterator_Tree_Node__]
- ]
- [
- [Children range begin access]
- [`const_child_iterator get_child_begin() const;`]
- [__Tree_Node__]
- ]
- [
- [Children range begin access]
- [`child_iterator get_child_begin();`]
- [__Tree_Node__]
- ]
- [
- [Children range past-the-end access]
- [`const_child_iterator get_child_end() const;`]
- [__Tree_Node__]
- ]
- [
- [Children range past-the-end access]
- [`child_iterator get_child_end();`]
- [__Tree_Node__]
- ]
- [
- [Remove all children]
- [`void remove_all_children();`]
- [__Tree_Node__]
- ]
-]
-[endsect] [/ Members]
-
-[section Example]
-<__example_raw_node_cpp__>
-[endsect]
-
-[endsect] [/ raw_node]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_simple_associative_node.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_simple_associative_node.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,233 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:simple_associative_node `simple_associative_node`]
-
-[section Synopsis]
-[reference__simple_associative_node]
-[endsect]
-
-[section Description]
-This class template is suitable for classes or algorithms that need to map keys
-to child nodes in a tree node data structure that must be exposed to external
-code. Objects of this type must be stored by
-`simple_associative_node::pointer` and can only be instantiated through
-the `static` creation methods that this class template provides. Their
-children can be accessed by their associated keys for fast lookup.
-
-[important
- This component depends on __Boost_Utility_ContainerGen__, which is not yet
- a part of Boost. For now, you must perform a Subversion checkout from the
- __SVN_Trac__.
-]
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_simple_associative_node_hpp__>
-``
-[endsect]
-
-[section:tpl_param Template Parameters]
-[table
- [[Parameter][Description][Requirements][Default]]
- [
- [`Key`]
- [
- The type of a key object to be associated with a child of a
- `raw_associative_node`.
- ]
- []
- []
- ]
- [
- [`Data`]
- [The type of the object to be stored in a `simple_associative_node`.]
- []
- []
- ]
- [
- [`AssociativeContainerSelector`]
- [
- The type that determines the internal map types whose mapped types
- are the same as the pointer type.
- ]
- [
- It must be a type for which __associative_container_gen__ returns
- a valid container.
- ]
- [`mapS`]
- ]
-]
-[endsect]
-
-[section:model_of Model of]
-__Associative_Tree_Node__
-[endsect]
-
-[section:public_bases Public Base Classes]
-__tr1_enable_shared_from_this__
-[endsect]
-
-[section Members]
-[table
- [[Name][Expression][Description]]
- [
- [Data type]
- [`data_type`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Data type]
- [`data_type`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Pointer type]
- [`pointer`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Pointer-to-const type]
- [`const_pointer`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Child iterator type]
- [`child_iterator`]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Immutable child iterator type]
- [`const_child_iterator`]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Node creation with data]
- [`static pointer create(data_type const&);`]
- [
- Creates a `simple_associative_node` object with the specified data
- and returns a pointer to it.
- ]
- ]
- [
- [Node creation]
- [`static pointer create();`]
- [
- Creates a `simple_associative_node` object and returns a pointer to
- it.
- ]
- ]
- [
- [Node copy creation]
- [`static pointer create_copy(const_pointer const&);`]
- [
- Creates a deep copy of the specified node. Returns a pointer to
- the new node.
- ]
- ]
- [
- [Data access]
- [`data_type const& get_data() const;`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Data access]
- [`data_type& get_data();`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Parent access]
- [`const_pointer get_parent() const;`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Parent access]
- [`pointer get_parent();`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Child creation with data]
- [`pointer add_child(key_type const&, data_type const&);`]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Child creation]
- [`pointer add_child(key_type const&);`]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Child copy creation]
- [`pointer add_child(key_type const&, const_pointer const&);`]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Children range begin access]
- [`const_child_iterator get_child_begin() const;`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Children range begin access]
- [`child_iterator get_child_begin();`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Children range past-the-end access]
- [`const_child_iterator get_child_end() const;`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Children range past-the-end access]
- [`child_iterator get_child_end();`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Child search]
- [`const_child_iterator find_child(key_type const&) const;`]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Child search]
- [`child_iterator find_child(key_type const&);`]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Child search range]
- [
- [^_std_pair_<Node::const_child_iterator,Node::const_child_iterator>
- find_children(key_type const&) const;]
- ]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Child search range]
- [
- [^_std_pair_<Node::child_iterator,Node::child_iterator>
- find_children(key_type const&);]
- ]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Remove children]
- [`std::size_t remove_children(key_type const&);`]
- [Defined by the __Associative_Tree_Node__ concept.]
- ]
- [
- [Remove all children]
- [`void remove_all_children();`]
- [Defined by the __Tree_Node__ concept.]
- ]
-]
-[endsect] [/ Members]
-
-[section Example]
-<__example_simple_associative_node_cpp__>
-[endsect]
-
-[endsect] [/ simple_associative_node]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_simple_node.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_simple_node.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,167 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:simple_node `simple_node`]
-
-[section Synopsis]
-[reference__simple_node]
-[endsect]
-
-[section Description]
-This class template is suitable for classes or algorithms that require a tree
-node data structure that must be exposed to external code. Objects of this
-type must be stored by `simple_node::pointer` and can only be instantiated
-through the `static` creation methods that this class template provides. Their
-children can be accessed by offsetting the start of the range with a numerical
-index for fast lookup.
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_simple_node_hpp__>
-``
-[endsect]
-
-[section:tpl_param Template Parameters]
-[table
- [[Parameter][Description][Requirements][Default]]
- [
- [`T`]
- [The type of the object to be stored in a `simple_node`.]
- []
- []
- ]
-]
-[endsect]
-
-[section:model_of Model of]
-__Random_Access_Child_Iterator_Tree_Node__
-[endsect]
-
-[section:public_bases Public Base Classes]
-__tr1_enable_shared_from_this__
-[endsect]
-
-[section Members]
-[table
- [[Name][Expression][Description]]
- [
- [Data type]
- [`data_type`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Pointer type]
- [`pointer`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Pointer-to-const type]
- [`const_pointer`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Child iterator type]
- [`child_iterator`]
- [Defined by the __Random_Access_Child_Iterator_Tree_Node__ concept.]
- ]
- [
- [Immutable child iterator type]
- [`const_child_iterator`]
- [Defined by the __Random_Access_Child_Iterator_Tree_Node__ concept.]
- ]
- [
- [Node creation with data]
- [`static pointer create(data_type const&);`]
- [
- Creates a `simple_node` object with the specified data and returns
- a pointer to it.
- ]
- ]
- [
- [Node creation]
- [`static pointer create();`]
- [Creates a `simple_node` object and returns a pointer to it.]
- ]
- [
- [Node copy creation]
- [`static pointer create_copy(const_pointer const&);`]
- [
- Creates a deep copy of the specified node. Returns a pointer to
- the new node.
- ]
- ]
- [
- [Data access]
- [`data_type const& get_data() const;`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Data access]
- [`data_type& get_data();`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Parent access]
- [`const_pointer get_parent() const;`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Parent access]
- [`pointer get_parent();`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Child creation with data]
- [`pointer add_child(data_type const&);`]
- [Defined by the __Random_Access_Child_Iterator_Tree_Node__ concept.]
- ]
- [
- [Child creation]
- [`pointer add_child();`]
- [Defined by the __Random_Access_Child_Iterator_Tree_Node__ concept.]
- ]
- [
- [Child copy creation]
- [`pointer add_child(const_pointer const&);`]
- [Defined by the __Random_Access_Child_Iterator_Tree_Node__ concept.]
- ]
- [
- [Children range begin access]
- [`const_child_iterator get_child_begin() const;`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Children range begin access]
- [`child_iterator get_child_begin();`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Children range past-the-end access]
- [`const_child_iterator get_child_end() const;`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Children range past-the-end access]
- [`child_iterator get_child_end();`]
- [Defined by the __Tree_Node__ concept.]
- ]
- [
- [Remove all children]
- [`void remove_all_children();`]
- [Defined by the __Tree_Node__ concept.]
- ]
-]
-[endsect] [/ Members]
-
-[section Example]
-<__example_simple_node_cpp__>
-[endsect]
-
-[endsect] [/ simple_node]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/ref_traversal_state.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/ref_traversal_state.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section:traversal_state `traversal_state`]
-
-[section Synopsis]
-[reference__traversal_state]
-[endsect]
-
-[section Description]
-This enumeration type is the return type of the dereferenceability expression
-defined by each iterator type that this library provides. The `no_traversal`
-value corresponds to `false` in a boolean context, enabling the iterator types
-to fulfill their runtime requirements for dereferenceability. The
-`pre_order_traversal` and `post_order_traversal` values are significant because
-the __depth_first_iterator__ traverses each node twice, so algorithms must be
-able to distinguish which state the iterator is in when it traverses a tree
-node. The `breadth_first_traversal` value is defined for completeness.
-[endsect]
-
-[section:definition Where defined]
-``
-#include <__boost_tree_node_traversal_state_hpp__>
-``
-[endsect]
-
-[endsect] [/ traversal_state]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/reference.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/reference.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,32 +0,0 @@
-[/=============================================================================
- Copyright (C) 2011 Cromwell D. Enage
-
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
-=============================================================================/]
-
-[section Reference]
-
-[include ref_raw_node.qbk]
-[include ref_simple_node.qbk]
-[include ref_raw_associative_node.qbk]
-[include ref_simple_associative_node.qbk]
-[include ref_breadth_first_iterator.qbk]
-[include ref_pre_order_iterator.qbk]
-[include ref_post_order_iterator.qbk]
-[include ref_depth_first_iterator.qbk]
-[include ref_traversal_state.qbk]
-
- * __raw_node__
- * __simple_node__
- * __raw_associative_node__
- * __simple_associative_node__
- * __breadth_first_iterator__
- * __pre_order_iterator__
- * __post_order_iterator__
- * __depth_first_iterator__
- * __traversal_state__
-
-[endsect] [/ Reference]
-

Deleted: sandbox/tree_node/libs/tree_node/doc/tree_node.qbk
==============================================================================
--- sandbox/tree_node/libs/tree_node/doc/tree_node.qbk 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
+++ (empty file)
@@ -1,146 +0,0 @@
-[library tree_node
- [quickbook 1.5]
- [version 0.1]
- [authors [Enage, Cromwell D.]]
- [copyright 2011 Cromwell D. Enage]
- [purpose Low-level tree node framework]
- [license
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- [@http://www.boost.org/LICENSE_1_0.txt])
- ]
-]
-
-[/ General links.]
-[def __Runtime_Complexity__ [@http://en.wikipedia.org/wiki/Amortized_analysis Runtime Complexity]]
-
-[/ General concept links.]
-[def __Default_Constructible__ [@http://www.sgi.com/tech/stl/DefaultConstructible.html [*Default Constructible]]]
-[def __Trivial_Iterator__ [@http://www.sgi.com/tech/stl/trivial.html [*Trivial Iterator]]]
-[def __Input_Iterator__ [@http://www.sgi.com/tech/stl/InputIterator.html [*Input Iterator]]]
-[def __Forward_Iterator__ [@http://www.sgi.com/tech/stl/ForwardIterator.html [*Forward Iterator]]]
-[def __Random_Access_Iterator__ [@http://www.sgi.com/tech/stl/RandomAccessIterator.html [*Random Access Iterator]]]
-[def __Container__ [@http://www.sgi.com/tech/stl/Container.html [*Container]]]
-[def __Unary_Function__ [@http://www.sgi.com/tech/stl/UnaryFunction.html [*Unary Function]]]
-
-[/ STL reference links.]
-[def __std_pair__ [@http://www.sgi.com/tech/stl/pair.html `std::pair`]]
-[def _std_pair_ [@http://www.sgi.com/tech/stl/pair.html std::pair]]
-
-[/ Boost library and installation links.]
-[def __Build__ [@boost:more/getting_started.html Build]]
-[def __build__ [@boost:more/getting_started.html build]]
-[def __Boost_Test__ [@boost:libs/test/doc/index.html [*Boost.Test]]]
-[def __SVN_Trac__ [@http://svn.boost.org/ SVN Trac]]
-[def __Boost_Utility_ContainerGen__ [@http://svn.boost.org/svn/boost/sandbox/utility-container_gen/libs/utility/container_gen/doc/html/index.html [*Boost.Utility.ContainerGen]]]
-
-[/ Boost concept links.]
-[def __Copy_Constructible__ [@boost:libs/utility/CopyConstructible.html [*Copy Constructible]]]
-[def __Assignable__ [@boost:libs/utility/Assignable.html [*Assignable]]]
-[def __Boolean_Integral_Constant__ [@boost:libs/mpl/doc/refmanual/integral-constant.html [*Boolean Integral Constant]]]
-
-[/ Boost reference links in text.]
-
-[/ Boost reference links in code.]
-[def __tr1_enable_shared_from_this__ [@boost:libs/smart_ptr/enable_shared_from_this.html `std::tr1::enable_shared_from_this`]]
-[def __mpl_true__ [@boost:libs/mpl/doc/refmanual/bool.html `boost::mpl::true_`]]
-[def _mpl_true_ [@boost:libs/mpl/doc/refmanual/bool.html boost::mpl::true_]]
-[def __mpl_false__ [@boost:libs/mpl/doc/refmanual/bool.html `boost::mpl::false_`]]
-[def _mpl_false_ [@boost:libs/mpl/doc/refmanual/bool.html boost::mpl::false_]]
-[def _mpl_equal_to_ [@boost:libs/mpl/doc/refmanual/equal_to.html boost::mpl::equal_to]]
-[def _enable_if_ [@boost:libs/utility/enable_if.html `enable_if`]]
-[def __associative_container_gen__ [@http://svn.boost.org/svn/boost/sandbox/utility-container_gen/libs/utility/container_gen/doc/html/container_gen/reference/associative_container_gen.html `associative_container_gen`]]
-
-[/ Boost.TreeNode tutorial source file links.]
-[def __example_raw_node_cpp__ [@../../example/raw_node.cpp example/raw_node.cpp]]
-[def __example_simple_node_cpp__ [@../../example/simple_node.cpp example/simple_node.cpp]]
-[def __example_raw_associative_node_cpp__ [@../../example/raw_associative_node.cpp example/raw_associative_node.cpp]]
-[def __example_simple_associative_node_cpp__ [@../../example/simple_associative_node.cpp example/simple_associative_node.cpp]]
-
-[/ Boost.TreeNode reference header file links.]
-[def __boost_tree_node_raw_node_hpp__ [@../../../../boost/tree_node/raw_node.hpp boost/tree_node/raw_node.hpp]]
-[def __boost_tree_node_simple_node_hpp__ [@../../../../boost/tree_node/simple_node.hpp boost/tree_node/simple_node.hpp]]
-[def __boost_tree_node_raw_associative_node_hpp__ [@../../../../boost/tree_node/raw_associative_node.hpp boost/tree_node/raw_associative_node.hpp]]
-[def __boost_tree_node_simple_associative_node_hpp__ [@../../../../boost/tree_node/simple_associative_node.hpp boost/tree_node/simple_associative_node.hpp]]
-[def __boost_tree_node_breadth_first_iterator_hpp__ [@../../../../boost/tree_node/breadth_first_iterator.hpp boost/tree_node/breadth_first_iterator.hpp]]
-[def __boost_tree_node_pre_order_iterator_hpp__ [@../../../../boost/tree_node/pre_order_iterator.hpp boost/tree_node/pre_order_iterator.hpp]]
-[def __boost_tree_node_post_order_iterator_hpp__ [@../../../../boost/tree_node/post_order_iterator.hpp boost/tree_node/post_order_iterator.hpp]]
-[def __boost_tree_node_depth_first_iterator_hpp__ [@../../../../boost/tree_node/depth_first_iterator.hpp boost/tree_node/depth_first_iterator.hpp]]
-[def __boost_tree_node_traversal_state_hpp__ [@../../../../boost/tree_node/traversal_state.hpp boost/tree_node/traversal_state.hpp]]
-[def __example_raw_node_cpp__ [@../../example/raw_node.cpp example/raw_node.cpp]]
-[def __example_simple_node_cpp__ [@../../example/simple_node.cpp example/simple_node.cpp]]
-[def __example_raw_associative_node_cpp__ [@../../example/raw_associative_node.cpp example/raw_associative_node.cpp]]
-[def __example_simple_associative_node_cpp__ [@../../example/simple_associative_node.cpp example/simple_associative_node.cpp]]
-
-[/ Boost.TreeNode concept links.]
-[def __Tree_Node__ [link tree_node.concepts.tree_node [*Tree Node]]]
-[def __Random_Access_Child_Iterator_Tree_Node__ [link tree_node.concepts.raci_tree_node [*Random Access Child Iterator Tree Node]]]
-[def __Associative_Tree_Node__ [link tree_node.concepts.associative_tree_node [*Associative Tree Node]]]
-[def __Tree_Node_Iterator__ [link tree_node.concepts.tree_node_iterator [*Tree Node Iterator]]]
-[def __Full_Tree_Node_Iterator__ [link tree_node.concepts.full_tree_node_iterator [*Full Tree Node Iterator]]]
-[def __Tree_Node_Descendant_Iterator__ [link tree_node.concepts.tree_node_desc_iterator [*Tree Node Descendant Iterator]]]
-
-[/ Boost.TreeNode reference links.]
-[def __raw_node__ [link tree_node.reference.raw_node `raw_node`]]
-[def _raw_node_ [link tree_node.reference.raw_node raw_node]]
-[def __simple_node__ [link tree_node.reference.simple_node `simple_node`]]
-[def _simple_node_ [link tree_node.reference.simple_node simple_node]]
-[def __raw_associative_node__ [link tree_node.reference.raw_associative_node `raw_associative_node`]]
-[def _raw_associative_node_ [link tree_node.reference.raw_associative_node raw_associative_node]]
-[def __simple_associative_node__ [link tree_node.reference.simple_associative_node `simple_associative_node`]]
-[def _simple_associative_node_ [link tree_node.reference.simple_associative_node simple_associative_node]]
-[def __breadth_first_iterator__ [link tree_node.reference.breadth_first_iterator `breadth_first_iterator`]]
-[def __make_breadth_first_iterator__ [link tree_node.reference.breadth_first_iterator `make_breadth_first_iterator()`]]
-[def __make_breadth_first_descendant_iterator__ [link tree_node.reference.breadth_first_iterator `make_breadth_first_descendant_iterator()`]]
-[def _breadth_first_iterator_ [link tree_node.reference.breadth_first_iterator breadth_first_iterator]]
-[def __pre_order_iterator__ [link tree_node.reference.pre_order_iterator `pre_order_iterator`]]
-[def __make_pre_order_iterator__ [link tree_node.reference.pre_order_iterator `make_pre_order_iterator()`]]
-[def __make_pre_order_descendant_iterator__ [link tree_node.reference.pre_order_iterator `make_pre_order_descendant_iterator()`]]
-[def _pre_order_iterator_ [link tree_node.reference.pre_order_iterator pre_order_iterator]]
-[def __post_order_iterator__ [link tree_node.reference.post_order_iterator `post_order_iterator`]]
-[def __make_post_order_iterator__ [link tree_node.reference.post_order_iterator `make_post_order_iterator()`]]
-[def __make_post_order_descendant_iterator__ [link tree_node.reference.post_order_iterator `make_post_order_descendant_iterator()`]]
-[def _post_order_iterator_ [link tree_node.reference.post_order_iterator post_order_iterator]]
-[def __depth_first_iterator__ [link tree_node.reference.depth_first_iterator `depth_first_iterator`]]
-[def __make_depth_first_iterator__ [link tree_node.reference.depth_first_iterator `make_depth_first_iterator()`]]
-[def __make_depth_first_descendant_iterator__ [link tree_node.reference.depth_first_iterator `make_depth_first_descendant_iterator()`]]
-[def _depth_first_iterator_ [link tree_node.reference.depth_first_iterator depth_first_iterator]]
-[def __traversal_state__ [link tree_node.reference.traversal_state `traversal_state`]]
-[def _traversal_state_ [link tree_node.reference.traversal_state traversal_state]]
-
-[/ Autogenerate concept and reference documentation directly from code.]
-[/ Bypass Doxygen.]
-[import ../../../boost/tree_node/raw_node.hpp]
-[import ../../../boost/tree_node/simple_node.hpp]
-[import ../../../boost/tree_node/raw_associative_node.hpp]
-[import ../../../boost/tree_node/simple_associative_node.hpp]
-[import ../../../boost/tree_node/breadth_first_iterator.hpp]
-[import ../../../boost/tree_node/pre_order_iterator.hpp]
-[import ../../../boost/tree_node/post_order_iterator.hpp]
-[import ../../../boost/tree_node/depth_first_iterator.hpp]
-[import ../../../boost/tree_node/traversal_state.hpp]
-[import ../example/default_unconstructible_type.hpp] [/ example__default_unconstructible_type]
-[import ../example/default_unconstructible_type.cpp] [/ example__default_unconstructible_type__definitions]
-[import ../example/raw_node.cpp]
-[import ../example/simple_node.cpp]
-[import ../example/raw_associative_node.cpp]
-[import ../example/simple_associative_node.cpp]
-
-[/ index.html Start]
-
-[heading Rationale]
-Over the course of reimplementing a decision tree learning algorithm to use
-modern C++ techniques, the need for a generic tree library became evident. The
-in-house data structures in use at the time were undergoing modification as
-well. It was found that the core operations occurred at the node level rather
-than at the tree level, which stored only high-level algorithms. Efforts went
-underway to retrofit these algorithms to use iterators and to further factor
-out generic data structures from the decision tree components and other
-application-specific utilities. This library represents the Boostified
-culmination of these efforts.
-
-[/ index.html End]
-
-[include concepts.qbk]
-[include reference.qbk]
-

Added: sandbox/tree_node/libs/tree_node/example/default_unconstructible_type.cpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/default_unconstructible_type.cpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,20 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include "default_unconstructible_type.hpp"
+
+//[example__default_unconstructible_type__definitions
+default_unconstructible_example_type::default_unconstructible_example_type()
+{
+}
+
+default_unconstructible_example_type create_instance(std::size_t n)
+{
+ default_unconstructible_example_type instance;
+ instance.number = n;
+ return instance;
+}
+//]
+

Added: sandbox/tree_node/libs/tree_node/example/default_unconstructible_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/default_unconstructible_type.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,27 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef LIBS_TREE_NODE_EXAMPLE_DEFAULT_UNCONSTRUCTIBLE_TYPE_HPP_INCLUDED
+#define LIBS_TREE_NODE_EXAMPLE_DEFAULT_UNCONSTRUCTIBLE_TYPE_HPP_INCLUDED
+
+#include <vector>
+
+//[example__default_unconstructible_type
+class default_unconstructible_example_type
+{
+ default_unconstructible_example_type();
+
+ friend default_unconstructible_example_type
+ create_instance(std::size_t n);
+
+ public:
+ std::size_t number;
+};
+//]
+
+default_unconstructible_example_type create_instance(std::size_t n);
+
+#endif // LIBS_TREE_NODE_EXAMPLE_DEFAULT_UNCONSTRUCTIBLE_TYPE_HPP_INCLUDED
+

Added: sandbox/tree_node/libs/tree_node/example/raw_associative_node.cpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/raw_associative_node.cpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,234 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+#include <boost/assert.hpp>
+#include <boost/tr1/tuple.hpp>
+#include <boost/tree_node/typeof.hpp>
+#include "default_unconstructible_type.hpp"
+#include "show_functions.hpp"
+#include "showcase_descendant_iterators.hpp"
+
+typedef boost::tree_node::raw_associative_node<
+ char const*
+ , default_unconstructible_example_type
+ , boost::multimapS
+ >
+ DNode;
+typedef boost::tree_node::raw_associative_node<
+ char const*
+ , char*
+ , boost::hash_multimapS
+ >
+ ANode;
+
+int main()
+{
+ char const* names[] = {"able", "baker", "charlie", "dog", "easy", "fox"};
+ DNode d_root(create_instance(5));
+ ANode a_root;
+
+ BOOST_ASSERT(
+ !d_root.get_parent()
+ && "Parent member uninitialized."
+ );
+ BOOST_ASSERT(
+ !a_root.get_data()
+ && "Data member not default-constructed."
+ );
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_breadth_first_iterator(&d_root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ std::size_t const count = (*itr)->get_data().number;
+
+ if (1 < count)
+ {
+ for (std::size_t i = 0; i < count; ++i)
+ {
+ for (std::size_t j = 0; j + i < count; ++j)
+ {
+ DNode::pointer child(
+ (*itr)->add_child(names[j], create_instance(i))
+ );
+ DNode::const_pointer const_child(child);
+
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ BOOST_ASSERT(
+ (child->get_parent() == const_child->get_parent())
+ && "Why are these pointers different?"
+ );
+ }
+ }
+ }
+ }
+
+ {
+ boost::tree_node::depth_first_iterate(&d_root, show_number_tree());
+ std::cout << std::endl;
+ }
+
+ std::cout << "After d_root tree construction," << std::endl;
+ showcase_descendant_iterators(
+ DNode::const_pointer(&d_root)
+ , show_key_and_number<char const*,DNode::const_pointer>
+ , show_key_and_number_tree()
+ );
+
+ {
+ DNode::pointer d_child = d_root.find_child(
+ names[2]
+ )->second->add_child_copy(names[5], &d_root);
+
+ std::cout << "After add_child_copy call," << std::endl;
+ showcase_descendant_iterators(
+ DNode::const_pointer(&d_root)
+ , show_key_and_number<char const*,DNode::const_pointer>
+ , show_key_and_number_tree()
+ );
+
+ d_root = *d_child;
+ std::cout << "After assignment to descendant," << std::endl;
+ showcase_descendant_iterators(
+ DNode::const_pointer(&d_root)
+ , show_key_and_number<char const*,DNode::const_pointer>
+ , show_key_and_number_tree()
+ );
+ }
+
+ *(d_root.find_child(names[4])->second) = d_root;
+ std::cout << "After assignment to ancestor," << std::endl;
+ showcase_descendant_iterators(
+ DNode::const_pointer(&d_root)
+ , show_key_and_number<char const*,DNode::const_pointer>
+ , show_key_and_number_tree()
+ );
+
+ {
+ char* root_data = new char[2];
+
+ root_data[0] = '5';
+ root_data[1] = '\0';
+ a_root.get_data() = root_data;
+ }
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_breadth_first_iterator(&a_root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ char digit = (*itr)->get_data()[0];
+
+ if ('1' < digit)
+ {
+ char numchar = digit;
+
+ while (numchar != '0')
+ {
+ --numchar;
+
+ for (char j = 0; numchar + j < digit; ++j)
+ {
+ ANode::pointer child((*itr)->add_child(names[j]));
+ char*& data = child->get_data();
+
+ BOOST_ASSERT(
+ !data
+ && "Data member not default-constructed."
+ );
+ data = new char[2];
+ data[0] = numchar;
+ data[1] = '\0';
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ }
+ }
+ }
+ }
+
+ std::cout << "After a_root tree construction," << std::endl;
+ showcase_descendant_iterators(
+ ANode::const_pointer(&a_root)
+ , show_key_and_data<char const*,ANode::const_pointer>
+ , show_key_and_data_tree()
+ );
+
+ {
+ ANode::pointer a_child(
+ a_root.find_child(names[2])->second->add_child(names[5])
+ );
+
+ a_child->get_data() = new char[2];
+ a_child->get_data()[0] = '7';
+ a_child->get_data()[1] = '\0';
+ std::cout << "After a_child construction," << std::endl;
+ showcase_descendant_iterators(
+ ANode::const_pointer(&a_root)
+ , show_key_and_data<char const*,ANode::const_pointer>
+ , show_key_and_data_tree()
+ );
+ }
+
+ {
+ ANode::pointer to_be_pruned = a_root.get_child_begin()->second;
+ ANode::child_iterator c_itr, c_end;
+
+ for (
+ std::tr1::tie(c_itr, c_end) = to_be_pruned->find_children(
+ names[1]
+ );
+ c_itr != c_end;
+ ++c_itr
+ )
+ {
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_pre_order_iterator(c_itr->second)
+ );
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+ }
+
+ to_be_pruned->remove_children(names[1]);
+ std::cout << "After remove_children call," << std::endl;
+ showcase_descendant_iterators(
+ ANode::const_pointer(&a_root)
+ , show_key_and_data<char const*,ANode::const_pointer>
+ , show_key_and_data_tree()
+ );
+ }
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_post_order_iterator(&a_root));
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+
+ return 0;
+}
+

Added: sandbox/tree_node/libs/tree_node/example/raw_binary_node.cpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/raw_binary_node.cpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,272 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+#include <boost/assert.hpp>
+#include <boost/tree_node/typeof.hpp>
+#include "default_unconstructible_type.hpp"
+#include "show_functions.hpp"
+#include "showcase_iterators.hpp"
+
+typedef boost::tree_node::raw_binary_node<default_unconstructible_example_type>
+ DNode;
+typedef boost::tree_node::raw_binary_node<char*>
+ ANode;
+
+int main()
+{
+ DNode d_root(create_instance(5));
+ ANode a_root;
+
+ BOOST_ASSERT(
+ !d_root.get_parent()
+ && "Parent member uninitialized."
+ );
+ BOOST_ASSERT(
+ !a_root.get_data()
+ && "Data member not default-constructed."
+ );
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_breadth_first_iterator(&d_root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ std::size_t const count = (*itr)->get_data().number;
+
+ if (1 < count)
+ {
+ DNode::pointer child(
+ (*itr)->add_left_child(create_instance(count - 2))
+ );
+ DNode::const_pointer const_child(child);
+
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ BOOST_ASSERT(
+ (child->get_parent() == const_child->get_parent())
+ && "Why are these pointers different?"
+ );
+
+ child = (*itr)->add_right_child(create_instance(count - 1));
+ const_child = child;
+
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ BOOST_ASSERT(
+ (child->get_parent() == const_child->get_parent())
+ && "Why are these pointers different?"
+ );
+ }
+ }
+
+ std::cout << "After d_root tree construction," << std::endl;
+ showcase_in_order_iterator(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ );
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ {
+ DNode::pointer p = d_root.get_left_child()->get_left_child();
+ DNode::pointer p_child = p->add_left_child_copy(&d_root);
+
+ std::cout << "After add_left_child_copy call," << std::endl;
+ showcase_in_order_iterator(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ );
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ d_root = *p_child;
+ std::cout << "After assignment to descendant," << std::endl;
+ showcase_in_order_iterator(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ );
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+ }
+
+ *(d_root.get_right_child()) = d_root;
+ std::cout << "After assignment to ancestor," << std::endl;
+ showcase_in_order_iterator(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ );
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ d_root.get_right_child()->rotate_left();
+ std::cout << "After rotate_left call," << std::endl;
+ showcase_in_order_iterator(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ );
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ char* root_data = new char[2];
+
+ root_data[0] = '5';
+ root_data[1] = '\0';
+ a_root.get_data() = root_data;
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_breadth_first_iterator(&a_root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ char digit = (*itr)->get_data()[0];
+
+ if ('1' < digit)
+ {
+ {
+ ANode::pointer child((*itr)->add_left_child());
+ char*& data = child->get_data();
+
+ BOOST_ASSERT(
+ !data
+ && "Data member not default-constructed."
+ );
+ data = new char[2];
+ data[0] = digit - 1;
+ data[1] = '\0';
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ }
+
+ {
+ ANode::pointer child((*itr)->add_right_child());
+ char*& data = child->get_data();
+
+ BOOST_ASSERT(
+ !data
+ && "Data member not default-constructed."
+ );
+ data = new char[2];
+ data[0] = digit - 2;
+ data[1] = '\0';
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ }
+ }
+ }
+
+ std::cout << "After a_root tree construction," << std::endl;
+ showcase_in_order_iterator(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ );
+ showcase_iterators(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+
+ {
+ ANode::pointer p = a_root.get_right_child()->get_right_child();
+ ANode::pointer p_child = p->add_right_child();
+
+ p_child->get_data() = new char[2];
+ p_child->get_data()[0] = '7';
+ p_child->get_data()[1] = '\0';
+ std::cout << "After add_right_child call," << std::endl;
+ showcase_in_order_iterator(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ );
+ showcase_iterators(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+ }
+
+ a_root.get_left_child()->rotate_right();
+ std::cout << "After rotate_right call," << std::endl;
+ showcase_in_order_iterator(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ );
+ showcase_iterators(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+
+ {
+ ANode::pointer leaf = *a_root.get_child_begin();
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_pre_order_descendant_iterator(leaf)
+ );
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+
+ leaf->remove_all_children();
+ std::cout << "After remove_all_children call," << std::endl;
+ showcase_in_order_iterator(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ );
+ showcase_iterators(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+ }
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_post_order_iterator(&a_root));
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+
+ return 0;
+}
+

Added: sandbox/tree_node/libs/tree_node/example/raw_node.cpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/raw_node.cpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,206 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+#include <boost/assert.hpp>
+#include <boost/tree_node/typeof.hpp>
+#include "default_unconstructible_type.hpp"
+#include "show_functions.hpp"
+#include "showcase_iterators.hpp"
+
+typedef boost::tree_node::raw_node<default_unconstructible_example_type> DNode;
+typedef boost::tree_node::raw_node<char*> ANode;
+
+int main()
+{
+ DNode d_root(create_instance(5));
+ ANode a_root;
+
+ BOOST_ASSERT(
+ !d_root.get_parent()
+ && "Parent member uninitialized."
+ );
+ BOOST_ASSERT(
+ !a_root.get_data()
+ && "Data member not default-constructed."
+ );
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_breadth_first_iterator(&d_root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ std::size_t const count = (*itr)->get_data().number;
+
+ if (1 < count)
+ {
+ for (std::size_t i = 0; i < count; ++i)
+ {
+ DNode::pointer child((*itr)->add_child(create_instance(i)));
+ DNode::const_pointer const_child(child);
+
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ BOOST_ASSERT(
+ (child == *((*itr)->get_child_begin() + i))
+ && "Ctor not linking parent to child."
+ );
+ BOOST_ASSERT(
+ (child->get_parent() == const_child->get_parent())
+ && "Why are these pointers different?"
+ );
+ }
+ }
+ }
+
+ std::cout << "After d_root tree construction," << std::endl;
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ {
+ DNode::pointer d_child = (
+ *(d_root.get_child_begin() + 2)
+ )->add_child_copy(&d_root);
+
+ std::cout << "After add_child_copy call," << std::endl;
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ d_root = *d_child;
+ std::cout << "After assignment to descendant," << std::endl;
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+ }
+
+ *(*(d_root.get_child_begin() + 4)) = d_root;
+ std::cout << "After assignment to ancestor," << std::endl;
+ showcase_iterators(
+ DNode::const_pointer(&d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ char* root_data = new char[2];
+
+ root_data[0] = '5';
+ root_data[1] = '\0';
+ a_root.get_data() = root_data;
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_breadth_first_iterator(&a_root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ char digit = (*itr)->get_data()[0];
+
+ if ('1' < digit)
+ {
+ char numchar = digit;
+
+ while (numchar != '0')
+ {
+ ANode::pointer child((*itr)->add_child());
+ char*& data = child->get_data();
+
+ BOOST_ASSERT(
+ !data
+ && "Data member not default-constructed."
+ );
+ data = new char[2];
+ data[0] = --numchar;
+ data[1] = '\0';
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ BOOST_ASSERT(
+ (
+ child
+ == *((*itr)->get_child_begin() + (digit - (numchar + 1)))
+ )
+ && "Ctor not linking parent to child."
+ );
+ }
+ }
+ }
+
+ std::cout << "After a_root tree construction," << std::endl;
+ showcase_iterators(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+
+ {
+ ANode::pointer a_child(
+ (*(a_root.get_child_begin() + 2))->add_child()
+ );
+
+ a_child->get_data() = new char[2];
+ a_child->get_data()[0] = '7';
+ a_child->get_data()[1] = '\0';
+ std::cout << "After a_child construction," << std::endl;
+ showcase_iterators(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+ }
+
+ {
+ ANode::pointer leaf = *a_root.get_child_begin();
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_pre_order_descendant_iterator(leaf)
+ );
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+
+ leaf->remove_all_children();
+ std::cout << "After remove_all_children call," << std::endl;
+ showcase_iterators(
+ ANode::const_pointer(&a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+ }
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_post_order_iterator(&a_root));
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+
+ return 0;
+}
+

Added: sandbox/tree_node/libs/tree_node/example/show_functions.cpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/show_functions.cpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,60 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include "show_functions.hpp"
+
+//[example__show_tabs
+void
+ show_tabs(
+ boost::tree_node::traversal_state state
+ , unsigned int& depth_limit
+ )
+{
+ switch (state)
+ {
+ case boost::tree_node::pre_order_traversal:
+ {
+ ++depth_limit;
+
+ for (unsigned int depth = 0; depth < depth_limit; ++depth)
+ {
+ std::cout << " ";
+ }
+
+ std::cout << "Pre-order: ";
+ break;
+ }
+
+ case boost::tree_node::post_order_traversal:
+ {
+ for (unsigned int depth = 0; depth < depth_limit; ++depth)
+ {
+ std::cout << " ";
+ }
+
+ std::cout << "Post-order: ";
+ --depth_limit;
+ break;
+ }
+ }
+}
+//]
+
+show_number_tree::show_number_tree() : depth_limit(1)
+{
+}
+
+show_key_and_number_tree::show_key_and_number_tree() : depth_limit(1)
+{
+}
+
+show_data_tree::show_data_tree() : depth_limit(1)
+{
+}
+
+show_key_and_data_tree::show_key_and_data_tree() : depth_limit(1)
+{
+}
+

Added: sandbox/tree_node/libs/tree_node/example/show_functions.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/show_functions.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,137 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef LIBS_TREE_NODE_EXAMPLE_SHOW_FUNCTIONS_HPP_INCLUDED
+#define LIBS_TREE_NODE_EXAMPLE_SHOW_FUNCTIONS_HPP_INCLUDED
+
+#include <iostream>
+#include <boost/tree_node/traversal_state.hpp>
+
+void
+ show_tabs(
+ boost::tree_node::traversal_state state
+ , unsigned int& depth_limit
+ );
+
+//[example__show_number
+template <typename NodePointer>
+void show_number(NodePointer const& node)
+{
+ std::cout << ' ' << node->get_data().number;
+}
+//]
+
+//[example__show_number_tree
+class show_number_tree
+{
+ unsigned int depth_limit;
+
+ public:
+ show_number_tree();
+
+ template <typename NodePointer>
+ void
+ operator()(
+ NodePointer const& node
+ , boost::tree_node::traversal_state state
+ )
+ {
+ show_tabs(state, depth_limit);
+ std::cout << node->get_data().number << std::endl;
+ }
+};
+//]
+
+//[example__show_key_and_number
+template <typename Key, typename NodePointer>
+void show_key_and_number(Key const& key, NodePointer const& node)
+{
+ std::cout << " [" << key << ", " << node->get_data().number << ']';
+}
+//]
+
+//[example__show_key_and_number_tree
+class show_key_and_number_tree
+{
+ unsigned int depth_limit;
+
+ public:
+ show_key_and_number_tree();
+
+ template <typename Iterator>
+ void
+ operator()(
+ Iterator const& itr
+ , boost::tree_node::traversal_state state
+ )
+ {
+ show_tabs(state, depth_limit);
+ show_key_and_number(itr->first, itr->second);
+ std::cout << std::endl;
+ }
+};
+//]
+
+//[example__show_data
+template <typename NodePointer>
+void show_data(NodePointer const& node)
+{
+ std::cout << ' ' << node->get_data();
+}
+//]
+
+//[example__show_data_tree
+class show_data_tree
+{
+ unsigned int depth_limit;
+
+ public:
+ show_data_tree();
+
+ template <typename NodePointer>
+ void
+ operator()(
+ NodePointer const& node
+ , boost::tree_node::traversal_state state
+ )
+ {
+ show_tabs(state, depth_limit);
+ std::cout << node->get_data() << std::endl;
+ }
+};
+//]
+
+//[example__show_key_and_data
+template <typename Key, typename NodePointer>
+void show_key_and_data(Key const& key, NodePointer const& node)
+{
+ std::cout << " [" << key << ", " << node->get_data() << ']';
+}
+//]
+
+//[example__show_key_and_data_tree
+class show_key_and_data_tree
+{
+ unsigned int depth_limit;
+
+ public:
+ show_key_and_data_tree();
+
+ template <typename Iterator>
+ void
+ operator()(
+ Iterator const& itr
+ , boost::tree_node::traversal_state state
+ )
+ {
+ show_tabs(state, depth_limit);
+ show_key_and_data(itr->first, itr->second);
+ std::cout << std::endl;
+ }
+};
+//]
+
+#endif // LIBS_TREE_NODE_EXAMPLE_SHOW_FUNCTIONS_HPP_INCLUDED
+

Added: sandbox/tree_node/libs/tree_node/example/showcase_descendant_iterators.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/showcase_descendant_iterators.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,82 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef LIBS_TREE_NODE_EXAMPLE_SHOWCASE_DESCENDANT_ITERATORS_HPP_INCLUDED
+#define LIBS_TREE_NODE_EXAMPLE_SHOWCASE_DESCENDANT_ITERATORS_HPP_INCLUDED
+
+#include <iostream>
+#include <boost/tree_node/typeof.hpp>
+
+//[example__showcase_descendant_iterators
+template <typename NodePointer, typename Function1, typename Function2>
+void
+ showcase_descendant_iterators(
+ NodePointer const& root
+ , Function1 show1
+ , Function2 show2
+ )
+{
+ std::cout << " Breadth-first traversal:";
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_breadth_first_descendant_iterator(root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ show1(itr->first, itr->second);
+ }
+
+ std::cout << std::endl << " Pre-order traversal:";
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_pre_order_descendant_iterator(root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ show1(itr->first, itr->second);
+ }
+
+ std::cout << std::endl << " Post-order traversal:";
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_post_order_descendant_iterator(root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ show1(itr->first, itr->second);
+ }
+
+ std::cout << std::endl << " Depth-first traversal:" << std::endl;
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_depth_first_descendant_iterator(root)
+ );
+ itr;
+ ++itr
+ )
+ {
+ show2(itr, boost::tree_node::traversal_state(itr));
+ }
+
+ std::cout << std::endl;
+}
+//]
+
+#endif // LIBS_TREE_NODE_EXAMPLE_SHOWCASE_DESCENDANT_ITERATORS_HPP_INCLUDED
+

Added: sandbox/tree_node/libs/tree_node/example/showcase_iterators.hpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/showcase_iterators.hpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,58 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef LIBS_TREE_NODE_EXAMPLE_SHOWCASE_ITERATORS_HPP_INCLUDED
+#define LIBS_TREE_NODE_EXAMPLE_SHOWCASE_ITERATORS_HPP_INCLUDED
+
+#include <iostream>
+#include <boost/tree_node/breadth_first_iterator.hpp>
+#include <boost/tree_node/pre_order_iterator.hpp>
+#include <boost/tree_node/post_order_iterator.hpp>
+#include <boost/tree_node/depth_first_iterator.hpp>
+#include <boost/tree_node/in_order_iterator.hpp>
+
+//[example__showcase_iterators
+template <typename NodePointer, typename Function1, typename Function2>
+void
+ showcase_iterators(
+ NodePointer const& root
+ , Function1 show1
+ , Function2 show2
+ )
+{
+ std::cout << " Breadth-first: ";
+ boost::tree_node::breadth_first_iterate(root, show1);
+ std::cout << std::endl << " sans root: ";
+ boost::tree_node::breadth_first_iterate_descendants(root, show1);
+ std::cout << std::endl << " Pre-order: ";
+ boost::tree_node::pre_order_iterate(root, show1);
+ std::cout << std::endl << " sans root: ";
+ boost::tree_node::pre_order_iterate_descendants(root, show1);
+ std::cout << std::endl << " Post-order: ";
+ boost::tree_node::post_order_iterate(root, show1);
+ std::cout << std::endl << " sans root: ";
+ boost::tree_node::post_order_iterate_descendants(root, show1);
+ std::cout << std::endl << " Depth-first:" << std::endl;
+ boost::tree_node::depth_first_iterate(root, show2);
+ std::cout << std::endl << " sans root:" << std::endl;
+ boost::tree_node::depth_first_iterate_descendants(root, show2);
+ std::cout << std::endl;
+}
+//]
+
+//[example__showcase_in_order_iterator
+template <typename NodePointer, typename Function>
+void showcase_in_order_iterator(NodePointer const& node, Function show)
+{
+ std::cout << " In-order fwd: ";
+ boost::tree_node::in_order_iterate_forward(node, show);
+ std::cout << std::endl << " In-order bck: ";
+ boost::tree_node::in_order_iterate_reverse(node, show);
+ std::cout << std::endl;
+}
+//]
+
+#endif // LIBS_TREE_NODE_EXAMPLE_SHOWCASE_ITERATORS_HPP_INCLUDED
+

Added: sandbox/tree_node/libs/tree_node/example/simple_associative_node.cpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/simple_associative_node.cpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,211 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+#include <boost/assert.hpp>
+#include <boost/tr1/tuple.hpp>
+#include <boost/tree_node/typeof.hpp>
+#include "default_unconstructible_type.hpp"
+#include "show_functions.hpp"
+#include "showcase_descendant_iterators.hpp"
+
+typedef boost::tree_node::simple_associative_node<
+ char const*
+ , default_unconstructible_example_type
+ , boost::multimapS
+ >
+ DNode;
+typedef boost::tree_node::simple_associative_node<
+ char const*
+ , char*
+ , boost::hash_multimapS
+ >
+ ANode;
+
+int main()
+{
+ char const* names[] = {"able", "baker", "charlie", "dog", "easy", "fox"};
+ DNode::pointer d_root(DNode::create(create_instance(5)));
+ ANode::pointer a_root(ANode::create());
+
+ BOOST_ASSERT(
+ !d_root->get_parent()
+ && "Parent member uninitialized."
+ );
+ BOOST_ASSERT(
+ !a_root->get_data()
+ && "Data member not default-constructed."
+ );
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_breadth_first_iterator(d_root));
+ itr;
+ ++itr
+ )
+ {
+ std::size_t const count = (*itr)->get_data().number;
+
+ if (1 < count)
+ {
+ for (std::size_t i = 0; i < count; ++i)
+ {
+ for (std::size_t j = 0; j + i < count; ++j)
+ {
+ DNode::pointer child(
+ (*itr)->add_child(names[j], create_instance(i))
+ );
+ DNode::const_pointer const_child(child);
+
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ BOOST_ASSERT(
+ (child->get_parent() == const_child->get_parent())
+ && "Why are these pointers different?"
+ );
+ }
+ }
+ }
+ }
+
+ {
+ boost::tree_node::depth_first_iterate(d_root, show_number_tree());
+ std::cout << std::endl;
+ }
+
+ std::cout << "After d_root tree construction," << std::endl;
+ showcase_descendant_iterators(
+ DNode::const_pointer(d_root)
+ , show_key_and_number<char const*,DNode::const_pointer>
+ , show_key_and_number_tree()
+ );
+
+ {
+ d_root->find_child(
+ names[2]
+ )->second->add_child_copy(names[5], d_root);
+ std::cout << "After add_child_copy call," << std::endl;
+ showcase_descendant_iterators(
+ DNode::const_pointer(d_root)
+ , show_key_and_number<char const*,DNode::const_pointer>
+ , show_key_and_number_tree()
+ );
+ }
+
+ {
+ char* root_data = new char[2];
+
+ root_data[0] = '5';
+ root_data[1] = '\0';
+ a_root->get_data() = root_data;
+ }
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_breadth_first_iterator(a_root));
+ itr;
+ ++itr
+ )
+ {
+ char digit = (*itr)->get_data()[0];
+
+ if ('1' < digit)
+ {
+ char numchar = digit;
+
+ while (numchar != '0')
+ {
+ --numchar;
+
+ for (char j = 0; numchar + j < digit; ++j)
+ {
+ ANode::pointer child((*itr)->add_child(names[j]));
+ char*& data = child->get_data();
+
+ BOOST_ASSERT(
+ !data
+ && "Data member not default-constructed."
+ );
+ data = new char[2];
+ data[0] = numchar;
+ data[1] = '\0';
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ }
+ }
+ }
+ }
+
+ std::cout << "After a_root tree construction," << std::endl;
+ showcase_descendant_iterators(
+ ANode::const_pointer(a_root)
+ , show_key_and_data<char const*,ANode::const_pointer>
+ , show_key_and_data_tree()
+ );
+
+ {
+ ANode::pointer a_child(
+ a_root->find_child(names[2])->second->add_child(names[5])
+ );
+
+ a_child->get_data() = new char[2];
+ a_child->get_data()[0] = '7';
+ a_child->get_data()[1] = '\0';
+ std::cout << "After a_child construction," << std::endl;
+ showcase_descendant_iterators(
+ ANode::const_pointer(a_root)
+ , show_key_and_data<char const*,ANode::const_pointer>
+ , show_key_and_data_tree()
+ );
+ }
+
+ {
+ ANode::pointer to_be_pruned = a_root->get_child_begin()->second;
+ ANode::child_iterator c_itr, c_end;
+
+ for (
+ std::tr1::tie(c_itr, c_end) = to_be_pruned->find_children(
+ names[1]
+ );
+ c_itr != c_end;
+ ++c_itr
+ )
+ {
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_pre_order_iterator(c_itr->second)
+ );
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+ }
+
+ to_be_pruned->remove_children(names[1]);
+ std::cout << "After remove_children call," << std::endl;
+ showcase_descendant_iterators(
+ ANode::const_pointer(a_root)
+ , show_key_and_data<char const*,ANode::const_pointer>
+ , show_key_and_data_tree()
+ );
+ }
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_post_order_iterator(a_root));
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+
+ return 0;
+}
+

Added: sandbox/tree_node/libs/tree_node/example/simple_node.cpp
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/example/simple_node.cpp 2011-10-16 12:01:21 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,191 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+#include <boost/assert.hpp>
+#include <boost/tree_node/typeof.hpp>
+#include "default_unconstructible_type.hpp"
+#include "show_functions.hpp"
+#include "showcase_iterators.hpp"
+
+typedef boost::tree_node::simple_node<default_unconstructible_example_type>
+ DNode;
+typedef boost::tree_node::simple_node<char*>
+ ANode;
+
+int main()
+{
+ DNode::pointer d_root(DNode::create(create_instance(5)));
+ ANode::pointer a_root(ANode::create());
+
+ BOOST_ASSERT(
+ !d_root->get_parent()
+ && "Parent member uninitialized."
+ );
+ BOOST_ASSERT(
+ !a_root->get_data()
+ && "Data member not default-constructed."
+ );
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_breadth_first_iterator(d_root));
+ itr;
+ ++itr
+ )
+ {
+ std::size_t const count = (*itr)->get_data().number;
+
+ if (1 < count)
+ {
+ for (std::size_t i = 0; i < count; ++i)
+ {
+ DNode::pointer child((*itr)->add_child(create_instance(i)));
+ DNode::const_pointer const_child(child);
+
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ BOOST_ASSERT(
+ (child == *((*itr)->get_child_begin() + i))
+ && "Ctor not linking parent to child."
+ );
+ BOOST_ASSERT(
+ (child->get_parent() == const_child->get_parent())
+ && "Why are these pointers different?"
+ );
+ }
+ }
+ }
+
+ std::cout << "After d_root tree construction," << std::endl;
+ showcase_iterators(
+ DNode::const_pointer(d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ {
+ (*(d_root->get_child_begin() + 2))->add_child_copy(d_root);
+ std::cout << "After add_child_copy call," << std::endl;
+ showcase_iterators(
+ DNode::const_pointer(d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+ }
+
+ (*(d_root->get_child_begin() + 4))->remove_all_children();
+ std::cout << "After remove_all_children call," << std::endl;
+ showcase_iterators(
+ DNode::const_pointer(d_root)
+ , show_number<DNode::const_pointer>
+ , show_number_tree()
+ );
+
+ char* root_data = new char[2];
+
+ root_data[0] = '5';
+ root_data[1] = '\0';
+ a_root->get_data() = root_data;
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_breadth_first_iterator(a_root));
+ itr;
+ ++itr
+ )
+ {
+ char digit = (*itr)->get_data()[0];
+
+ if ('1' < digit)
+ {
+ char numchar = digit;
+
+ while (numchar != '0')
+ {
+ ANode::pointer child((*itr)->add_child());
+ char*& data = child->get_data();
+
+ BOOST_ASSERT(
+ !data
+ && "Data member not default-constructed."
+ );
+ data = new char[2];
+ data[0] = --numchar;
+ data[1] = '\0';
+ BOOST_ASSERT(
+ (child->get_parent() == *itr)
+ && "Ctor not linking child to parent."
+ );
+ BOOST_ASSERT(
+ (
+ child
+ == *((*itr)->get_child_begin() + (digit - (numchar + 1)))
+ )
+ && "Ctor not linking parent to child."
+ );
+ }
+ }
+ }
+
+ std::cout << "After a_root tree construction," << std::endl;
+ showcase_iterators(
+ ANode::const_pointer(a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+
+ {
+ ANode::pointer a_child(
+ (*(a_root->get_child_begin() + 2))->add_child()
+ );
+
+ a_child->get_data() = new char[2];
+ a_child->get_data()[0] = '7';
+ a_child->get_data()[1] = '\0';
+ std::cout << "After a_child construction," << std::endl;
+ showcase_iterators(
+ ANode::const_pointer(a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+ }
+
+ {
+ ANode::pointer leaf = *a_root->get_child_begin();
+
+ for (
+ BOOST_AUTO(
+ itr
+ , boost::tree_node::make_pre_order_descendant_iterator(leaf)
+ );
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+
+ leaf->remove_all_children();
+ std::cout << "After remove_all_children call," << std::endl;
+ showcase_iterators(
+ ANode::const_pointer(a_root)
+ , show_data<ANode::const_pointer>
+ , show_data_tree()
+ );
+ }
+
+ for (
+ BOOST_AUTO(itr, boost::tree_node::make_post_order_iterator(a_root));
+ itr;
+ ++itr
+ )
+ {
+ delete[] (*itr)->get_data();
+ }
+
+ return 0;
+}
+

Date view Thread view Subject view Author view