[Boost-commit] svn:boost r74971 - sandbox/tree_node/libs/tree_node/doc

Subject: [Boost-commit] svn:boost r74971 - sandbox/tree_node/libs/tree_node/doc
From: sponage_at_[hidden]
Date: 2011-10-16 12:08:28

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

Log:
Boost.TreeNode candidate library: re-added Quickbook source files.
Added:
   sandbox/tree_node/libs/tree_node/doc/concept_assoc_tree_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/concept_binary_tree_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/concept_descendant_iterator.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/concept_full_iterator.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/concept_iterator.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/concept_nary_tree_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/concept_non_assoc_tree_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/concept_tree_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/concepts.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_breadth_first_iterator.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_depth_first_iterator.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_in_order_iterator.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_post_order_iterator.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_pre_order_iterator.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_raw_associative_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_raw_binary_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_raw_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_simple_associative_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_simple_node.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/ref_traversal_state.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/reference.qbk   (contents, props changed)
   sandbox/tree_node/libs/tree_node/doc/tree_node.qbk   (contents, props changed)

Added: sandbox/tree_node/libs/tree_node/doc/concept_assoc_tree_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concept_assoc_tree_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,171 @@
+[/=============================================================================
+    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)`]
+        [`Data` 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_copy(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]
+

Added: sandbox/tree_node/libs/tree_node/doc/concept_binary_tree_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concept_binary_tree_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,224 @@
+[/=============================================================================
+    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:binary_tree_node Binary Tree Node]
+
+[section Description]
+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.
+[endsect]
+
+[section Refinement of]
+__Non_Associative_Tree_Node__
+[endsect]
+
+[variablelist Notation
+    [
+        [`Node`]
+        [A type that models the [*Binary 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 __Non_Associative_Tree_Node__
+concept.
+[endsect]
+
+[section:expressions Valid Expressions and Semantics]
+In addition to the expressions defined in the __Non_Associative_Tree_Node__
+concept, the following expressions must be valid.
+
+[table
+    [
+        [Name]
+        [Expression]
+        [Type requirements]
+        [Return Type]
+        [Semantics]
+        [__Runtime_Complexity__]
+    ]
+    [
+        [Left child creation with data]
+        [`node->add_left_child(data)`]
+        []
+        [`Node::pointer`]
+        [
+            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.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Left child creation]
+        [`node->add_left_child()`]
+        [`Data` must model the __Default_Constructible__ concept.]
+        [`Node::pointer`]
+        [
+            Creates and returns a tree node to be stored as the left child of
+            the invoking node.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Left child copy creation]
+        [`node->add_left_child_copy(const_node)`]
+        []
+        [`Node::pointer`]
+        [
+            Creates and returns a deep copy of `const_node` to be stored as the
+            left child of the invoking node.
+        ]
+        [Linear with respect to the number of descendants of `const_node`]
+    ]
+    [
+        [Right child creation with data]
+        [`node->add_right_child(data)`]
+        []
+        [`Node::pointer`]
+        [
+            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.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Right child creation]
+        [`node->add_right_child()`]
+        [`Data` must model the __Default_Constructible__ concept.]
+        [`Node::pointer`]
+        [
+            Creates and returns a tree node to be stored as the right child of
+            the invoking node.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Right child copy creation]
+        [`node->add_right_child_copy(const_node)`]
+        []
+        [`Node::pointer`]
+        [
+            Creates and returns a deep copy of `const_node` to be stored as the
+            right child of the invoking node.
+        ]
+        [Linear with respect to the number of descendants of `const_node`]
+    ]
+    [
+        [Left child access]
+        [`const_node->get_left_child()`]
+        []
+        [`Node::const_pointer`]
+        [
+            Returns the left child of the tree node, or a null pointer if no
+            such tree node exists.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Left child access]
+        [`node->get_left_child()`]
+        []
+        [`Node::pointer`]
+        [
+            Returns the left child of the tree node, or a null pointer if no
+            such tree node exists.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Right child access]
+        [`const_node->get_right_child()`]
+        []
+        [`Node::const_pointer`]
+        [
+            Returns the right child of the tree node, or a null pointer if no
+            such tree node exists.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Right child access]
+        [`node->get_right_child()`]
+        []
+        [`Node::pointer`]
+        [
+            Returns the right child of the tree node, or a null pointer if no
+            such tree node exists.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Rotate left]
+        [`node->rotate_left()`]
+        []
+        [`Node::pointer`]
+        [
+            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.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Rotate right]
+        [`node->rotate_right()`]
+        []
+        [`Node::pointer`]
+        [
+            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.
+        ]
+        [Amortized constant]
+    ]
+    [
+        [Remove left child]
+        [`node->remove_left_child()`]
+        []
+        [`void`]
+        [Removes the left child from the tree node.]
+        [Linear with respect to the number of descendants of the left child]
+    ]
+    [
+        [Remove right child]
+        [`node->remove_right_child()`]
+        []
+        [`void`]
+        [Removes the right child from the tree node.]
+        [Linear with respect to the number of descendants of the right child]
+    ]
+]
+[endsect]
+
+[section Models]
+
+  * __raw_binary_node__
+
+[endsect]
+
+[endsect] [/ Binary Tree Node]
+

Added: sandbox/tree_node/libs/tree_node/doc/concept_descendant_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concept_descendant_iterator.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,104 @@
+[/=============================================================================
+    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
+__Non_Associative_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]
+

Added: sandbox/tree_node/libs/tree_node/doc/concept_full_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concept_full_iterator.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,85 @@
+[/=============================================================================
+    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__.
+  * The return type of __make_in_order_forward_iterator__.
+  * The return type of __make_in_order_reverse_iterator__.
+
+[endsect]
+
+[endsect] [/ Tree Node Iterator]
+

Added: sandbox/tree_node/libs/tree_node/doc/concept_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concept_iterator.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,106 @@
+[/=============================================================================
+    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]
+

Added: sandbox/tree_node/libs/tree_node/doc/concept_nary_tree_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concept_nary_tree_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,106 @@
+[/=============================================================================
+    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:nary_tree_node N-ary Tree Node]
+
+[section Description]
+Models of this concept store arbitrary numbers of children and provide simple
+child insertion expressions.
+[endsect]
+
+[section Refinement of]
+__Non_Associative_Tree_Node__
+[endsect]
+
+[variablelist Notation
+    [
+        [`Node`]
+        [A type that models the [*N-ary 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 __Non_Associative_Tree_Node__
+concept.
+[endsect]
+
+[section:expressions Valid Expressions and Semantics]
+In addition to the expressions defined in the __Non_Associative_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.
+        ]
+        [Logarithmic]
+    ]
+    [
+        [Child creation]
+        [`node->add_child()`]
+        [`Data` 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.
+        ]
+        [Logarithmic]
+    ]
+    [
+        [Child copy creation]
+        [`node->add_child_copy(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] [/ N-ary Tree Node]
+

Added: sandbox/tree_node/libs/tree_node/doc/concept_non_assoc_tree_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concept_non_assoc_tree_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,42 @@
+[/=============================================================================
+    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:non_assoc_tree_node Non-Associative Tree Node]
+
+[section Description]
+Models of this concept provide access to their child nodes via iterator
+dereferencing.
+[endsect]
+
+[section Refinement of]
+__Tree_Node__
+[endsect]
+
+[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:
+
+  * 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]
+None beyond those defined in the __Tree_Node__ concept.
+[endsect]
+
+[section Models]
+
+  * All models of the __Binary_Tree_Node__ concept.
+  * All models of the __N_ary_Tree_Node__ concept.
+
+[endsect]
+
+[endsect] [/ Non-Associative Tree Node]
+

Added: sandbox/tree_node/libs/tree_node/doc/concept_tree_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concept_tree_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,197 @@
+[/=============================================================================
+    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:
+a structure that maintains information about its data and its immediate
+parent-child relationships.
+[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.
+        ]
+    ]
+]
+[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]
+    ]
+    [
+        [Children range]
+        [`const_node->get_children()`]
+        [[^_std_pair_<Node::const_child_iterator,Node::const_child_iterator>]]
+        [
+            Returns a pair `p` such that `[p.first, p.second)` is the range of
+            children of the tree node.
+        ]
+        [Constant]
+    ]
+    [
+        [Children range]
+        [`node->get_children()`]
+        [[^_std_pair_<Node::child_iterator,Node::child_iterator>]]
+        [
+            Returns a pair `p` such that `[p.first, p.second)` is 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 and its descendants]
+    ]
+]
+[endsect] [/ Valid Expressions and Semantics]
+
+[section Models]
+
+  * All models of the __Associative_Tree_Node__ concept.
+  * All models of the __Non_Associative_Tree_Node__ concept.
+
+[endsect]
+
+[endsect] [/ Tree Node]
+

Added: sandbox/tree_node/libs/tree_node/doc/concepts.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/concepts.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,32 @@
+[/=============================================================================
+    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_assoc_tree_node.qbk]
+[include concept_non_assoc_tree_node.qbk]
+[include concept_binary_tree_node.qbk]
+[include concept_nary_tree_node.qbk]
+[include concept_iterator.qbk]
+[include concept_full_iterator.qbk]
+[include concept_descendant_iterator.qbk]
+
+[heading Core Concepts]
+
+  * __Tree_Node__
+      * __Associative_Tree_Node__
+      * __Non_Associative_Tree_Node__
+          * __Binary_Tree_Node__
+          * __N_ary_Tree_Node__
+  * __Tree_Node_Iterator__
+      * __Full_Tree_Node_Iterator__
+      * __Tree_Node_Descendant_Iterator__
+
+[endsect] [/ Concepts]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_breadth_first_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_breadth_first_iterator.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,224 @@
+[/=============================================================================
+    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__]
+    ]
+    [
+        [Difference type]
+        [`difference_type`]
+        [__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]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_depth_first_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_depth_first_iterator.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,299 @@
+[/=============================================================================
+    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]
+        [`difference_type`]
+        [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]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_in_order_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_in_order_iterator.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,226 @@
+[/=============================================================================
+    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:in_order_iterator `in_order_iterator`]
+
+[section Synopsis]
+[reference__in_order_iterator]
+[endsect]
+
+[section Description]
+This iterator traverses the specified root node and all its descendants in
+in-order fashion, e.g. given the following tree representation:
+
+``
+      A
+      |
+  C---+---B
+  |       |
++-+-+   +-+-+
+|   |   |   |
+D   E   F   G
+``
+
+The tree nodes will be traversed forward in the following order:
+
+``
+D C E A F B G
+``
+
+This iterator can also be used to traverse the tree nodes /backwards/:
+
+``
+G B F A E C D
+``
+
+[important
+    This iterator works only on __Binary_Tree_Node__ models.
+]
+[endsect]
+
+[section:definition Where defined]
+``
+#include <__boost_tree_node_in_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 __Binary_Tree_Node__ concept.
+        ]
+        []
+    ]
+]
+[endsect]
+
+[section:model_of Model of]
+
+  * __Full_Tree_Node_Iterator__
+  * __Bidirectional_Iterator__
+  * __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]
+        [`difference_type`]
+        [__Forward_Iterator__]
+    ]
+    [
+        [Iterator category]
+        [`iterator_category`]
+        [__Forward_Iterator__]
+    ]
+    [
+        [Default constructor]
+        [`in_order_iterator();`]
+        [__Default_Constructible__]
+    ]
+    [
+        [Constructor from im/mutable node]
+        [`in_order_iterator(NodePointer const&);`]
+        [__Tree_Node_Iterator__]
+    ]
+    [
+        [Conversion constructor]
+        [``
+            template <typename NP>
+            in_order_iterator(in_order_iterator<NP> const&);
+        ``]
+        [`in_order_iterator`]
+    ]
+    [
+        [Copy constructor]
+        [`in_order_iterator(in_order_iterator const&);`]
+        [__Copy_Constructible__]
+    ]
+    [
+        [Assignment operator]
+        [`in_order_iterator& operator=(in_order_iterator const&);`]
+        [__Assignable__]
+    ]
+    [
+        [Dereference operator]
+        [`reference operator*() const;`]
+        [__Forward_Iterator__]
+    ]
+    [
+        [Indirection operator]
+        [`pointer operator->() const;`]
+        [__Forward_Iterator__]
+    ]
+    [
+        [Pre-increment operator]
+        [`in_order_iterator& operator++();`]
+        [__Forward_Iterator__]
+    ]
+    [
+        [Post-increment operator]
+        [`in_order_iterator operator++(int);`]
+        [__Forward_Iterator__]
+    ]
+    [
+        [Pre-decrement operator]
+        [`in_order_iterator& operator--();`]
+        [__Reverse_Iterator__]
+    ]
+    [
+        [Post-decrement operator]
+        [`in_order_iterator operator--(int);`]
+        [__Reverse_Iterator__]
+    ]
+    [
+        [Traversal state conversion operator]
+        [`operator _traversal_state_() const;`]
+        [__Tree_Node_Iterator__]
+    ]
+]
+[endsect] [/ Members]
+
+[section:non_members Non-members]
+[table
+    [[Name][Expression][Description]]
+    [
+        [Forward Iterator creation]
+        [[reference__make_in_order_forward_iterator]]
+        [
+            Constructs and returns a `in_order_iterator` that will iterate
+            forward through the specified node and its descendants.
+        ]
+    ]
+    [
+        [Reverse iterator creation]
+        [[reference__make_in_order_reverse_iterator]]
+        [
+            Constructs and returns a `in_order_iterator` that will iterate
+            in reverse through the specified node and its descendants.
+        ]
+    ]
+    [
+        [Forward iteration]
+        [[reference__in_order_iterate_forward]]
+        [
+            Iterates through the specified node and its descendants in forward
+            in-order fashion, passing each node pointer dereferenced to
+            the specified __Unary_Function__ object.
+        ]
+    ]
+    [
+        [Reverse iteration]
+        [[reference__in_order_iterate_reverse]]
+        [
+            Iterates through the specified node and its descendants in reverse
+            in-order fashion, passing each element dereferenced to
+            the specified __Unary_Function__ object.
+        ]
+    ]
+    [
+        [Equality]
+        [[reference__in_order_iterator__operator_equals]]
+        [Defined by the __Input_Iterator__ concept.]
+    ]
+    [
+        [Inequality]
+        [[reference__in_order_iterator__operator_not_equal]]
+        [Defined by the __Input_Iterator__ concept.]
+    ]
+]
+[endsect] [/ Non-members]
+
+[endsect] [/ in_order_iterator]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_post_order_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_post_order_iterator.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,224 @@
+[/=============================================================================
+    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]
+        [`difference_type`]
+        [__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]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_pre_order_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_pre_order_iterator.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,224 @@
+[/=============================================================================
+    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]
+        [`difference_type`]
+        [__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]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_raw_associative_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_raw_associative_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,248 @@
+[/=============================================================================
+    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`]
+        [__Associative_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_copy(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__]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<const_child_iterator,const_child_iterator>
+            get_children() const;]
+        ]
+        [__Tree_Node__]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<child_iterator,child_iterator>
+            get_children();]
+        ]
+        [__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_<const_child_iterator,const_child_iterator>
+            find_children(key_type const&) const;]
+        ]
+        [__Associative_Tree_Node__]
+    ]
+    [
+        [Child search range]
+        [
+            [^_std_pair_<child_iterator,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]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_raw_binary_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_raw_binary_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,239 @@
+[/=============================================================================
+    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_binary_node `raw_binary_node`]
+
+[section Synopsis]
+[reference__raw_binary_node]
+[endsect]
+
+[section Description]
+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.
+[endsect]
+
+[section:definition Where defined]
+``
+#include <__boost_tree_node_raw_binary_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_binary_node`.]
+        []
+        []
+    ]
+]
+[endsect]
+
+[section:model_of Model of]
+
+  * __Binary_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`]
+        [__Non_Associative_Tree_Node__]
+    ]
+    [
+        [Immutable child iterator type]
+        [`const_child_iterator`]
+        [__Non_Associative_Tree_Node__]
+    ]
+    [
+        [Default constructor]
+        [`raw_binary_node();`]
+        [__Default_Constructible__]
+    ]
+    [
+        [Constructor with data]
+        [`explicit raw_binary_node(data_type const&);`]
+        [`raw_binary_node`]
+    ]
+    [
+        [Copy constructor]
+        [`raw_binary_node(raw_binary_node const&);`]
+        [__Copy_Constructible__]
+    ]
+    [
+        [Assignment operator]
+        [`raw_binary_node& operator=(raw_binary_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__]
+    ]
+    [
+        [Left child creation with data]
+        [`pointer add_left_child(data_type const&);`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Left child creation]
+        [`pointer add_left_child();`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Left child copy creation]
+        [`pointer add_left_child_copy(const_pointer const&);`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Right child creation with data]
+        [`pointer add_right_child(data_type const&);`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Right child creation]
+        [`pointer add_right_child();`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Right child copy creation]
+        [`pointer add_right_child_copy(const_pointer const&);`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Left child access]
+        [`const_pointer get_left_child() const;`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Left child access]
+        [`pointer get_left_child();`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Right child access]
+        [`const_pointer get_right_child() const;`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Right child access]
+        [`pointer get_right_child();`]
+        [__Binary_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__]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<const_child_iterator,const_child_iterator>
+            get_children() const;]
+        ]
+        [__Tree_Node__]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<child_iterator,child_iterator>
+            get_children();]
+        ]
+        [__Tree_Node__]
+    ]
+    [
+        [Rotate left]
+        [`pointer rotate_left();`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Rotate right]
+        [`pointer rotate_right();`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Remove left child]
+        [`void remove_left_child();`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Remove right child]
+        [`void remove_right_child();`]
+        [__Binary_Tree_Node__]
+    ]
+    [
+        [Remove all children]
+        [`void remove_all_children();`]
+        [__Tree_Node__]
+    ]
+]
+[endsect] [/ Members]
+
+[section Example]
+<__example_raw_binary_node_cpp__>
+[endsect]
+
+[endsect] [/ raw_binary_node]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_raw_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_raw_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,203 @@
+[/=============================================================================
+    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 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.
+
+[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_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`.]
+        []
+        []
+    ]
+    [
+        [`Selector`]
+        [
+            The type that determines the internal container types whose value
+            types are the same as the pointer type.
+        ]
+        [
+            It must be a type for which __container_gen__ returns a valid
+            container.
+        ]
+        [`dequeS`]
+    ]
+]
+[endsect]
+
+[section:model_of Model of]
+
+  * __N_ary_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`]
+        [__Non_Associative_Tree_Node__]
+    ]
+    [
+        [Immutable child iterator type]
+        [`const_child_iterator`]
+        [__Non_Associative_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&);`]
+        [__N_ary_Tree_Node__]
+    ]
+    [
+        [Child creation]
+        [`pointer add_child();`]
+        [__N_ary_Tree_Node__]
+    ]
+    [
+        [Child copy creation]
+        [`pointer add_child_copy(const_pointer const&);`]
+        [__N_ary_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__]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<const_child_iterator,const_child_iterator>
+            get_children() const;]
+        ]
+        [__Tree_Node__]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<child_iterator,child_iterator>
+            get_children();]
+        ]
+        [__Tree_Node__]
+    ]
+    [
+        [Remove all children]
+        [`void remove_all_children();`]
+        [__Tree_Node__]
+    ]
+]
+[endsect] [/ Members]
+
+[section Example]
+<__example_raw_node_cpp__>
+[endsect]
+
+[endsect] [/ raw_node]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_simple_associative_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_simple_associative_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,249 @@
+[/=============================================================================
+    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
+            `simple_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]]
+    [
+        [Key type]
+        [`key_type`]
+        [Defined by the __Associative_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_copy(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.]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<const_child_iterator,const_child_iterator>
+            get_children() const;]
+        ]
+        [Defined by the __Tree_Node__ concept.]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<child_iterator,child_iterator>
+            get_children();]
+        ]
+        [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_<const_child_iterator,const_child_iterator>
+            find_children(key_type const&) const;]
+        ]
+        [Defined by the __Associative_Tree_Node__ concept.]
+    ]
+    [
+        [Child search range]
+        [
+            [^_std_pair_<child_iterator,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]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_simple_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_simple_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,200 @@
+[/=============================================================================
+    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 can handle an arbitrary number of children and 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.
+
+[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_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`.]
+        []
+        []
+    ]
+    [
+        [`Selector`]
+        [
+            The type that determines the internal container types whose value
+            types are the same as the pointer type.
+        ]
+        [
+            It must be a type for which __container_gen__ returns a valid
+            container.
+        ]
+        [`dequeS`]
+    ]
+]
+[endsect]
+
+[section:model_of Model of]
+__N_ary_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 __Non_Associative_Tree_Node__ concept.]
+    ]
+    [
+        [Immutable child iterator type]
+        [`const_child_iterator`]
+        [Defined by the __Non_Associative_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 __N_ary_Tree_Node__ concept.]
+    ]
+    [
+        [Child creation]
+        [`pointer add_child();`]
+        [Defined by the __N_ary_Tree_Node__ concept.]
+    ]
+    [
+        [Child copy creation]
+        [`pointer add_child_copy(const_pointer const&);`]
+        [Defined by the __N_ary_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.]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<const_child_iterator,const_child_iterator>
+            get_children() const;]
+        ]
+        [Defined by the __Tree_Node__ concept.]
+    ]
+    [
+        [Children range]
+        [
+            [^_std_pair_<child_iterator,child_iterator>
+            get_children();]
+        ]
+        [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]
+

Added: sandbox/tree_node/libs/tree_node/doc/ref_traversal_state.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/ref_traversal_state.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,34 @@
+[/=============================================================================
+    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` and `in_order_traversal` values are
+defined for completeness.
+[endsect]
+
+[section:definition Where defined]
+``
+#include <__boost_tree_node_traversal_state_hpp__>
+``
+[endsect]
+
+[endsect] [/ traversal_state]
+

Added: sandbox/tree_node/libs/tree_node/doc/reference.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/reference.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,36 @@
+[/=============================================================================
+    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_binary_node.qbk]
+[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_in_order_iterator.qbk]
+[include ref_traversal_state.qbk]
+
+  * __raw_binary_node__
+  * __raw_node__
+  * __simple_node__
+  * __raw_associative_node__
+  * __simple_associative_node__
+  * __breadth_first_iterator__
+  * __pre_order_iterator__
+  * __post_order_iterator__
+  * __depth_first_iterator__
+  * __in_order_iterator__
+  * __traversal_state__
+
+[endsect] [/ Reference]
+

Added: sandbox/tree_node/libs/tree_node/doc/tree_node.qbk
==============================================================================
--- (empty file)
+++ sandbox/tree_node/libs/tree_node/doc/tree_node.qbk	2011-10-16 12:08:25 EDT (Sun, 16 Oct 2011)
@@ -0,0 +1,161 @@
+[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 __Reverse_Iterator__ [@http://www.sgi.com/tech/stl/ReverseIterator.html [*Reverse Iterator]]]
+[def __Bidirectional_Iterator__ [@http://www.sgi.com/tech/stl/BidirectionalIterator.html [*Bidirectional 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 __container_gen__ [@http://svn.boost.org/svn/boost/sandbox/utility-container_gen/libs/utility/container_gen/doc/html/container_gen/reference/container_gen.html `container_gen`]]
+[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 header and source file links.]
+[def __boost_tree_node_raw_binary_node_hpp__ [@../../../../boost/tree_node/raw_binary_node.hpp boost/tree_node/raw_binary_node.hpp]]
+[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_in_order_iterator_hpp__ [@../../../../boost/tree_node/in_order_iterator.hpp boost/tree_node/in_order_iterator.hpp]]
+[def __boost_tree_node_traversal_state_hpp__ [@../../../../boost/tree_node/traversal_state.hpp boost/tree_node/traversal_state.hpp]]
+[def __example_default_unconstructible_type_hpp__ [@../../example/default_unconstructible_type.hpp example/default_unconstructible_type.hpp]]
+[def __example_default_unconstructible_type_cpp__ [@../../example/default_unconstructible_type.cpp example/default_unconstructible_type.cpp]]
+[def __example_show_functions_hpp__ [@../../example/show_functions.hpp example/show_functions.hpp]]
+[def __example_show_functions_cpp__ [@../../example/show_functions.cpp example/show_functions.cpp]]
+[def __example_showcase_iterators_hpp__ [@../../example/showcase_iterators.hpp example/showcase_iterators.hpp]]
+[def __example_raw_binary_node_cpp__ [@../../example/raw_binary_node.cpp example/raw_binary_node.cpp]]
+[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 __Associative_Tree_Node__ [link tree_node.concepts.associative_tree_node [*Associative Tree Node]]]
+[def __Non_Associative_Tree_Node__ [link tree_node.concepts.non_assoc_tree_node [*Non-Associative Tree Node]]]
+[def __Binary_Tree_Node__ [link tree_node.concepts.binary_tree_node [*Binary Tree Node]]]
+[def __N_ary_Tree_Node__ [link tree_node.concepts.nary_tree_node [*N-ary 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_binary_node__ [link tree_node.reference.raw_binary_node `raw_binary_node`]]
+[def _raw_binary_node_ [link tree_node.reference.raw_binary_node raw_binary_node]]
+[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 __in_order_iterator__ [link tree_node.reference.in_order_iterator `in_order_iterator`]]
+[def __make_in_order_forward_iterator__ [link tree_node.reference.in_order_iterator `make_in_order_forward_iterator()`]]
+[def __make_in_order_reverse_iterator__ [link tree_node.reference.in_order_iterator `make_in_order_reverse_iterator()`]]
+[def _in_order_iterator_ [link tree_node.reference.in_order_iterator in_order_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_binary_node.hpp]
+[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/in_order_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_binary_node.cpp]
+[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]
+